Merge branch 'master' into ddLayerExtensions

Former-commit-id: 9eab593479

CMakeLists.txt

@@ -122,6 +122,9 @@ elseif(MSVC)
 	# Windows.h breaks GMM in gmm_except.h because of its macro definition for min and max
 	add_definitions(/DNOMINMAX)
 	
+	# since nobody cares at the moment
+	add_definitions(/wd4250)
+	
 	if(ENABLE_Z3)
 		set(Z3_LIB_NAME "libz3")
 	endif()

resources/3rdparty/ltl2dstar-0.5.1/src/parsers/nba-parser-lbtt.lex.cpp

@@ -31,7 +31,7 @@
 
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+#if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || defined _WIN32
 #include <inttypes.h>
 typedef int8_t flex_int8_t;
 typedef uint8_t flex_uint8_t;

resources/3rdparty/ltl2dstar-0.5.1/src/parsers/nba-parser-promela.lex.cpp

@@ -31,7 +31,7 @@
 
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+#if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || defined _WIN32
 #include <inttypes.h>
 typedef int8_t flex_int8_t;
 typedef uint8_t flex_uint8_t;

src/modelchecker/prctl/SparseDtmcPrctlModelChecker.h

@@ -393,7 +393,7 @@ public:
 
 		// Perform the actual matrix-vector multiplication as long as the bound of the formula is met.
         if (linearEquationSolver != nullptr) {
-            this->linearEquationSolver->performMatrixVectorMultiplication(this->getModel().getTransitionMatrix(), result, &totalRewardVector, formula.getBound());
+			this->linearEquationSolver->performMatrixVectorMultiplication(this->getModel().getTransitionMatrix(), result, &totalRewardVector, static_cast<uint_fast64_t>(formula.getBound()));
         } else {
             throw storm::exceptions::InvalidStateException() << "No valid linear equation solver available.";
         }

src/modelchecker/prctl/SparseMdpPrctlModelChecker.h

@@ -410,7 +410,7 @@ namespace storm {
                         result.resize(this->getModel().getNumberOfStates());
                     }
                     
-                    this->nondeterministicLinearEquationSolver->performMatrixVectorMultiplication(this->minimumOperatorStack.top(), this->getModel().getTransitionMatrix(), result, &totalRewardVector, formula.getBound());
+					this->nondeterministicLinearEquationSolver->performMatrixVectorMultiplication(this->minimumOperatorStack.top(), this->getModel().getTransitionMatrix(), result, &totalRewardVector, static_cast<uint_fast64_t>(formula.getBound()));
                     
                     return result;
                 }

src/parser/PrctlParser.cpp

@@ -140,7 +140,7 @@ struct PrctlParser::PrctlGrammar : qi::grammar<Iterator, storm::property::prctl:
 		reachabilityReward = (qi::lit("F") > stateFormula)[qi::_val =
 				phoenix::new_<storm::property::prctl::ReachabilityReward<double>>(qi::_1)];
 		reachabilityReward.name("path formula (for reward operator)");
-		instantaneousReward = (qi::lit("I") > qi::lit("=") > qi::double_)
+		instantaneousReward = (qi::lit("I") > qi::lit("=") > qi::uint_)
 						[qi::_val = phoenix::new_<storm::property::prctl::InstantaneousReward<double>>(qi::_1)];
 		instantaneousReward.name("path formula (for reward operator)");
 		steadyStateReward = (qi::lit("S"))[qi::_val = phoenix::new_<storm::property::prctl::SteadyStateReward<double>>()];

src/parser/PrismParser.cpp

@@ -91,10 +91,10 @@ namespace storm {
             relativeExpression = (plusExpression >> qi::lit(">=") >> plusExpression)[qi::_val = phoenix::bind(&PrismParser::createGreaterOrEqualExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit(">") >> plusExpression)[qi::_val = phoenix::bind(&PrismParser::createGreaterExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit("<=") >> plusExpression)[qi::_val = phoenix::bind(&PrismParser::createLessOrEqualExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit("<") >> plusExpression)[qi::_val = phoenix::bind(&PrismParser::createLessExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit("=") >> plusExpression)[qi::_val = phoenix::bind(&PrismParser::createEqualsExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit("!=") >> plusExpression)[qi::_val = phoenix::bind(&PrismParser::createNotEqualsExpression, phoenix::ref(*this), qi::_1, qi::_2)] | plusExpression[qi::_val = qi::_1];
             relativeExpression.name("relative expression");
             
-            andExpression = relativeExpression[qi::_val = qi::_1] >> *(qi::lit("&") >> relativeExpression)[qi::_val = phoenix::bind(&PrismParser::createAndExpression, phoenix::ref(*this), qi::_val, qi::_1)];
+            andExpression = relativeExpression[qi::_val = qi::_1] >> *((qi::lit("&")[qi::_a = storm::expressions::BinaryBooleanFunctionExpression::OperatorType::And] | qi::lit("<=>")[qi::_a = storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Iff] | qi::lit("^")[qi::_a = storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Xor]) >> relativeExpression)[phoenix::if_(qi::_a == storm::expressions::BinaryBooleanFunctionExpression::OperatorType::And) [ qi::_val = phoenix::bind(&PrismParser::createAndExpression, phoenix::ref(*this), qi::_val, qi::_1)] .else_ [ phoenix::if_(qi::_a == storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Iff) [ qi::_val = phoenix::bind(&PrismParser::createIffExpression, phoenix::ref(*this), qi::_val, qi::_1) ] .else_ [ qi::_val = phoenix::bind(&PrismParser::createXorExpression, phoenix::ref(*this), qi::_val, qi::_1) ] ] ];
             andExpression.name("and expression");
             
-            orExpression = andExpression[qi::_val = qi::_1] >> *(qi::lit("|") >> andExpression)[qi::_val = phoenix::bind(&PrismParser::createOrExpression, phoenix::ref(*this), qi::_val, qi::_1)];
+            orExpression = andExpression[qi::_val = qi::_1] >> *((qi::lit("|")[qi::_a = true] | qi::lit("=>")[qi::_a = false]) >> andExpression)[phoenix::if_(qi::_a) [qi::_val = phoenix::bind(&PrismParser::createOrExpression, phoenix::ref(*this), qi::_val, qi::_1)] .else_ [qi::_val = phoenix::bind(&PrismParser::createImpliesExpression, phoenix::ref(*this), qi::_val, qi::_1)] ];
             orExpression.name("or expression");
             
             iteExpression = orExpression[qi::_val = qi::_1] >> -(qi::lit("?") > orExpression > qi::lit(":") > orExpression)[qi::_val = phoenix::bind(&PrismParser::createIteExpression, phoenix::ref(*this), qi::_val, qi::_1, qi::_2)];
@@ -271,6 +271,14 @@ namespace storm {
             }
         }
         
+        storm::expressions::Expression PrismParser::createImpliesExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const {
+            if (!this->secondRun) {
+                return storm::expressions::Expression::createFalse();
+            } else {
+                return e1.implies(e2);
+            }
+        }
+        
         storm::expressions::Expression PrismParser::createOrExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const {
             if (!this->secondRun) {
                 return storm::expressions::Expression::createFalse();
@@ -319,6 +327,22 @@ namespace storm {
             }
         }
         
+        storm::expressions::Expression PrismParser::createIffExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const {
+            if (!this->secondRun) {
+                return storm::expressions::Expression::createFalse();
+            } else {
+                return e1.iff(e2);
+            }
+        }
+        
+        storm::expressions::Expression PrismParser::createXorExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const {
+            if (!this->secondRun) {
+                return storm::expressions::Expression::createFalse();
+            } else {
+                return e1 ^ e2;
+            }
+        }
+        
         storm::expressions::Expression PrismParser::createEqualsExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const {
             if (!this->secondRun) {
                 return storm::expressions::Expression::createFalse();
@@ -585,7 +609,7 @@ namespace storm {
                     auto const& renamingPair = renaming.find(variable.getName());
                     LOG_THROW(renamingPair != renaming.end(), storm::exceptions::WrongFormatException, "Boolean variable '" << variable.getName() << " was not renamed.");
                     
-                    booleanVariables.push_back(storm::prism::BooleanVariable(renamingPair->second, variable.getInitialValueExpression().substitute<std::map>(expressionRenaming), this->getFilename(), get_line(qi::_1)));
+                    booleanVariables.push_back(storm::prism::BooleanVariable(renamingPair->second, variable.getInitialValueExpression().substitute(expressionRenaming), this->getFilename(), get_line(qi::_1)));
                 }
                 
                 // Rename the integer variables.
@@ -594,7 +618,7 @@ namespace storm {
                     auto const& renamingPair = renaming.find(variable.getName());
                     LOG_THROW(renamingPair != renaming.end(), storm::exceptions::WrongFormatException, "Integer variable '" << variable.getName() << " was not renamed.");
                     
-                    integerVariables.push_back(storm::prism::IntegerVariable(renamingPair->second, variable.getLowerBoundExpression().substitute<std::map>(expressionRenaming), variable.getUpperBoundExpression().substitute<std::map>(expressionRenaming), variable.getInitialValueExpression().substitute<std::map>(expressionRenaming), this->getFilename(), get_line(qi::_1)));
+                    integerVariables.push_back(storm::prism::IntegerVariable(renamingPair->second, variable.getLowerBoundExpression().substitute(expressionRenaming), variable.getUpperBoundExpression().substitute(expressionRenaming), variable.getInitialValueExpression().substitute(expressionRenaming), this->getFilename(), get_line(qi::_1)));
                 }
                 
                 // Rename commands.
@@ -606,12 +630,12 @@ namespace storm {
                         for (auto const& assignment : update.getAssignments()) {
                             auto const& renamingPair = renaming.find(assignment.getVariableName());
                             if (renamingPair != renaming.end()) {
-                                assignments.emplace_back(renamingPair->second, assignment.getExpression().substitute<std::map>(expressionRenaming), this->getFilename(), get_line(qi::_1));
+                                assignments.emplace_back(renamingPair->second, assignment.getExpression().substitute(expressionRenaming), this->getFilename(), get_line(qi::_1));
                             } else {
-                                assignments.emplace_back(assignment.getVariableName(), assignment.getExpression().substitute<std::map>(expressionRenaming), this->getFilename(), get_line(qi::_1));
+                                assignments.emplace_back(assignment.getVariableName(), assignment.getExpression().substitute(expressionRenaming), this->getFilename(), get_line(qi::_1));
                             }
                         }
-                        updates.emplace_back(globalProgramInformation.currentUpdateIndex, update.getLikelihoodExpression().substitute<std::map>(expressionRenaming), assignments, this->getFilename(), get_line(qi::_1));
+                        updates.emplace_back(globalProgramInformation.currentUpdateIndex, update.getLikelihoodExpression().substitute(expressionRenaming), assignments, this->getFilename(), get_line(qi::_1));
                         ++globalProgramInformation.currentUpdateIndex;
                     }
                     
@@ -621,7 +645,7 @@ namespace storm {
                         newActionName = renamingPair->second;
                     }
                     
-                    commands.emplace_back(globalProgramInformation.currentCommandIndex, newActionName, command.getGuardExpression().substitute<std::map>(expressionRenaming), updates, this->getFilename(), get_line(qi::_1));
+                    commands.emplace_back(globalProgramInformation.currentCommandIndex, newActionName, command.getGuardExpression().substitute(expressionRenaming), updates, this->getFilename(), get_line(qi::_1));
                     ++globalProgramInformation.currentCommandIndex;
                 }
                 

src/parser/PrismParser.h

@@ -25,6 +25,7 @@ typedef BOOST_TYPEOF(qi::lit("//") >> *(qi::char_ - qi::eol) >> qi::eol | boost:
 
 #include "src/storage/prism/Program.h"
 #include "src/storage/expressions/Expression.h"
+#include "src/storage/expressions/Expressions.h"
 #include "src/exceptions/ExceptionMacros.h"
 
 namespace storm {
@@ -85,7 +86,7 @@ namespace storm {
                 }
             };
             
-            struct keywordsStruct : qi::symbols<char, bool> {
+            struct keywordsStruct : qi::symbols<char, uint_fast64_t> {
                 keywordsStruct() {
                     add
                     ("dtmc", 1)
@@ -244,8 +245,8 @@ namespace storm {
             // Rules for parsing a composed expression.
             qi::rule<Iterator, storm::expressions::Expression(), Skipper> expression;
             qi::rule<Iterator, storm::expressions::Expression(), Skipper> iteExpression;
-            qi::rule<Iterator, storm::expressions::Expression(), Skipper> orExpression;
+            qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> orExpression;
-            qi::rule<Iterator, storm::expressions::Expression(), Skipper> andExpression;
+            qi::rule<Iterator, storm::expressions::Expression(), qi::locals<storm::expressions::BinaryBooleanFunctionExpression::OperatorType>, Skipper> andExpression;
             qi::rule<Iterator, storm::expressions::Expression(), Skipper> relativeExpression;
             qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> plusExpression;
             qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> multiplicationExpression;
@@ -269,12 +270,15 @@ namespace storm {
             bool addInitialStatesExpression(storm::expressions::Expression initialStatesExpression, GlobalProgramInformation& globalProgramInformation);
             
             storm::expressions::Expression createIteExpression(storm::expressions::Expression e1, storm::expressions::Expression e2, storm::expressions::Expression e3) const;
+            storm::expressions::Expression createImpliesExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createOrExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createAndExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createGreaterExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createGreaterOrEqualExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createLessExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createLessOrEqualExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
+            storm::expressions::Expression createIffExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
+            storm::expressions::Expression createXorExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createEqualsExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createNotEqualsExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;
             storm::expressions::Expression createPlusExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const;

src/storage/dd/CuddDd.cpp

@@ -389,14 +389,14 @@ namespace storm {
                 std::vector<char*> ddNames;
                 std::string ddName("f");
                 ddNames.push_back(new char[ddName.size() + 1]);
-                memcpy(ddNames.back(), ddName.c_str(), 2);
+                std::copy(ddName.c_str(), ddName.c_str() + 2, ddNames.back());
                 
                 // Now build the variables names.
                 std::vector<std::string> ddVariableNamesAsStrings = this->getDdManager()->getDdVariableNames();
                 std::vector<char*> ddVariableNames;
                 for (auto const& element : ddVariableNamesAsStrings) {
                     ddVariableNames.push_back(new char[element.size() + 1]);
-                    memcpy(ddVariableNames.back(), element.c_str(), element.size() + 1);
+                    std::copy(element.c_str(), element.c_str() + element.size() + 1, ddVariableNames.back());
                 }
                 
                 // Open the file, dump the DD and close it again.

src/storage/expressions/BinaryBooleanFunctionExpression.cpp

@@ -23,6 +23,7 @@ namespace storm {
             switch (this->getOperatorType()) {
                 case OperatorType::And: result = firstOperandEvaluation && secondOperandEvaluation; break;
                 case OperatorType::Or: result = firstOperandEvaluation || secondOperandEvaluation; break;
+                case OperatorType::Xor: result = firstOperandEvaluation ^ secondOperandEvaluation; break;
                 case OperatorType::Implies: result = !firstOperandEvaluation || secondOperandEvaluation; break;
                 case OperatorType::Iff: result = (firstOperandEvaluation && secondOperandEvaluation) || (!firstOperandEvaluation && !secondOperandEvaluation); break;
             }
@@ -55,6 +56,7 @@ namespace storm {
                     return firstOperandSimplified;
                 }
                 break;
+                case OperatorType::Xor: break;
                 case OperatorType::Implies: if (firstOperandSimplified->isTrue()) {
                     return secondOperandSimplified;
                 } else if (firstOperandSimplified->isFalse()) {
@@ -88,6 +90,7 @@ namespace storm {
             switch (this->getOperatorType()) {
                 case OperatorType::And: stream << " & "; break;
                 case OperatorType::Or: stream << " | "; break;
+                case OperatorType::Xor: stream << " ^ "; break;
                 case OperatorType::Implies: stream << " => "; break;
                 case OperatorType::Iff: stream << " <=> "; break;
             }

src/storage/expressions/BinaryBooleanFunctionExpression.h

@@ -11,7 +11,7 @@ namespace storm {
             /*!
              * An enum type specifying the different operators applicable.
              */
-            enum class OperatorType {And, Or, Implies, Iff};
+            enum class OperatorType {And, Or, Xor, Implies, Iff};
             
             /*!
              * Creates a binary boolean function expression with the given return type, operands and operator.

src/storage/expressions/Expression.cpp

@@ -27,15 +27,21 @@ namespace storm {
             // Intentionally left empty.
         }
         
-        template<template<typename... Arguments> class MapType>
+		Expression Expression::substitute(std::map<std::string, Expression> const& identifierToExpressionMap) const {
-        Expression Expression::substitute(MapType<std::string, Expression> const& identifierToExpressionMap) const {
+            return SubstitutionVisitor< std::map<std::string, Expression> >(identifierToExpressionMap).substitute(this->getBaseExpressionPointer().get());
-            return SubstitutionVisitor<MapType>(identifierToExpressionMap).substitute(this->getBaseExpressionPointer().get());
         }
+
+		Expression Expression::substitute(std::unordered_map<std::string, Expression> const& identifierToExpressionMap) const {
+			return SubstitutionVisitor< std::unordered_map<std::string, Expression> >(identifierToExpressionMap).substitute(this->getBaseExpressionPointer().get());
+		}
         
-        template<template<typename... Arguments> class MapType>
+		Expression Expression::substitute(std::map<std::string, std::string> const& identifierToIdentifierMap) const {
-        Expression Expression::substitute(MapType<std::string, std::string> const& identifierToIdentifierMap) const {
+			return IdentifierSubstitutionVisitor< std::map<std::string, std::string> >(identifierToIdentifierMap).substitute(this->getBaseExpressionPointer().get());
-            return IdentifierSubstitutionVisitor<MapType>(identifierToIdentifierMap).substitute(this->getBaseExpressionPointer().get());
         }
+
+		Expression Expression::substitute(std::unordered_map<std::string, std::string> const& identifierToIdentifierMap) const {
+			return IdentifierSubstitutionVisitor< std::unordered_map<std::string, std::string> >(identifierToIdentifierMap).substitute(this->getBaseExpressionPointer().get());
+		}
         
         bool Expression::evaluateAsBool(Valuation const* valuation) const {
             return this->getBaseExpression().evaluateAsBool(valuation);
@@ -166,6 +172,11 @@ namespace storm {
             return Expression(std::shared_ptr<BaseExpression>(new BinaryNumericalFunctionExpression(this->getReturnType() == ExpressionReturnType::Int && other.getReturnType() == ExpressionReturnType::Int ? ExpressionReturnType::Int : ExpressionReturnType::Double, this->getBaseExpressionPointer(), other.getBaseExpressionPointer(), BinaryNumericalFunctionExpression::OperatorType::Divide)));
         }
         
+        Expression Expression::operator^(Expression const& other) const {
+            LOG_THROW(this->hasBooleanReturnType() && other.hasBooleanReturnType(), storm::exceptions::InvalidTypeException, "Operator '^' requires boolean operands.");
+            return Expression(std::shared_ptr<BaseExpression>(new BinaryBooleanFunctionExpression(ExpressionReturnType::Bool, this->getBaseExpressionPointer(), other.getBaseExpressionPointer(), BinaryBooleanFunctionExpression::OperatorType::Xor)));
+        }
+        
         Expression Expression::operator&&(Expression const& other) const {
             LOG_THROW(this->hasBooleanReturnType() && other.hasBooleanReturnType(), storm::exceptions::InvalidTypeException, "Operator '&&' requires boolean operands.");
             return Expression(std::shared_ptr<BaseExpression>(new BinaryBooleanFunctionExpression(ExpressionReturnType::Bool, this->getBaseExpressionPointer(), other.getBaseExpressionPointer(), BinaryBooleanFunctionExpression::OperatorType::And)));
@@ -247,11 +258,6 @@ namespace storm {
             return Expression(std::shared_ptr<BaseExpression>(new UnaryNumericalFunctionExpression(ExpressionReturnType::Int, this->getBaseExpressionPointer(), UnaryNumericalFunctionExpression::OperatorType::Ceil)));
         }
         
-        template Expression Expression::substitute<std::map>(std::map<std::string, storm::expressions::Expression> const&) const;
-        template Expression Expression::substitute<std::unordered_map>(std::unordered_map<std::string, storm::expressions::Expression> const&) const;
-        template Expression Expression::substitute<std::map>(std::map<std::string, std::string> const&) const;
-        template Expression Expression::substitute<std::unordered_map>(std::unordered_map<std::string, std::string> const&) const;
-        
         std::ostream& operator<<(std::ostream& stream, Expression const& expression) {
             stream << expression.getBaseExpression();
             return stream;

src/storage/expressions/Expression.h

@@ -2,6 +2,8 @@
 #define STORM_STORAGE_EXPRESSIONS_EXPRESSION_H_
 
 #include <memory>
+#include <map>
+#include <unordered_map>
 
 #include "src/storage/expressions/BaseExpression.h"
 #include "src/utility/OsDetection.h"
@@ -47,6 +49,7 @@ namespace storm {
             Expression operator-() const;
             Expression operator*(Expression const& other) const;
             Expression operator/(Expression const& other) const;
+            Expression operator^(Expression const& other) const;
             Expression operator&&(Expression const& other) const;
             Expression operator||(Expression const& other) const;
             Expression operator!() const;
@@ -76,8 +79,18 @@ namespace storm {
              * @return An expression in which all identifiers in the key set of the mapping are replaced by the
              * expression they are mapped to.
              */
-            template<template<typename... Arguments> class MapType>
+			Expression substitute(std::map<std::string, Expression> const& identifierToExpressionMap) const;
-            Expression substitute(MapType<std::string, Expression> const& identifierToExpressionMap) const;
+			/*!
+			* Substitutes all occurrences of identifiers according to the given map. Note that this substitution is
+			* done simultaneously, i.e., identifiers appearing in the expressions that were "plugged in" are not
+			* substituted.
+			*
+			* @param identifierToExpressionMap A mapping from identifiers to the expression they are substituted with.
+			* @return An expression in which all identifiers in the key set of the mapping are replaced by the
+			* expression they are mapped to.
+			*/
+			Expression substitute(std::unordered_map<std::string, Expression> const& identifierToExpressionMap) const;
             
             /*!
              * Substitutes all occurrences of identifiers with different names given by a mapping.
@@ -86,8 +99,16 @@ namespace storm {
              * @return An expression in which all identifiers in the key set of the mapping are replaced by the
              * identifiers they are mapped to.
              */
-            template<template<typename... Arguments> class MapType>
+			Expression substitute(std::map<std::string, std::string> const& identifierToIdentifierMap) const;
-            Expression substitute(MapType<std::string, std::string> const& identifierToIdentifierMap) const;
+			/*!
+			* Substitutes all occurrences of identifiers with different names given by a mapping.
+			*
+			* @param identifierToIdentifierMap A mapping from identifiers to identifiers they are substituted with.
+			* @return An expression in which all identifiers in the key set of the mapping are replaced by the
+			* identifiers they are mapped to.
+			*/
+			Expression substitute(std::unordered_map<std::string, std::string> const& identifierToIdentifierMap) const;
             
             /*!
              * Evaluates the expression under the valuation of unknowns (variables and constants) given by the

src/storage/expressions/IdentifierSubstitutionVisitor.cpp

@@ -1,5 +1,6 @@
 #include <map>
 #include <unordered_map>
+#include <string>
 
 #include "src/storage/expressions/IdentifierSubstitutionVisitor.h"
 
@@ -19,18 +20,18 @@
 
 namespace storm {
     namespace expressions  {
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
-        IdentifierSubstitutionVisitor<MapType>::IdentifierSubstitutionVisitor(MapType<std::string, std::string> const& identifierToIdentifierMap) : identifierToIdentifierMap(identifierToIdentifierMap) {
+        IdentifierSubstitutionVisitor<MapType>::IdentifierSubstitutionVisitor(MapType const& identifierToIdentifierMap) : identifierToIdentifierMap(identifierToIdentifierMap) {
             // Intentionally left empty.
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         Expression IdentifierSubstitutionVisitor<MapType>::substitute(BaseExpression const* expression) {
             expression->accept(this);
             return Expression(this->expressionStack.top());
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(IfThenElseExpression const* expression) {
             expression->getCondition()->accept(this);
             std::shared_ptr<BaseExpression const> conditionExpression = expressionStack.top();
@@ -52,7 +53,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(BinaryBooleanFunctionExpression const* expression) {
             expression->getFirstOperand()->accept(this);
             std::shared_ptr<BaseExpression const> firstExpression = expressionStack.top();
@@ -70,7 +71,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(BinaryNumericalFunctionExpression const* expression) {
             expression->getFirstOperand()->accept(this);
             std::shared_ptr<BaseExpression const> firstExpression = expressionStack.top();
@@ -88,7 +89,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(BinaryRelationExpression const* expression) {
             expression->getFirstOperand()->accept(this);
             std::shared_ptr<BaseExpression const> firstExpression = expressionStack.top();
@@ -106,7 +107,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(BooleanConstantExpression const* expression) {
             // If the boolean constant is in the key set of the substitution, we need to replace it.
             auto const& namePair = this->identifierToIdentifierMap.find(expression->getConstantName());
@@ -117,7 +118,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(DoubleConstantExpression const* expression) {
             // If the double constant is in the key set of the substitution, we need to replace it.
             auto const& namePair = this->identifierToIdentifierMap.find(expression->getConstantName());
@@ -128,7 +129,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(IntegerConstantExpression const* expression) {
             // If the integer constant is in the key set of the substitution, we need to replace it.
             auto const& namePair = this->identifierToIdentifierMap.find(expression->getConstantName());
@@ -139,7 +140,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(VariableExpression const* expression) {
             // If the variable is in the key set of the substitution, we need to replace it.
             auto const& namePair = this->identifierToIdentifierMap.find(expression->getVariableName());
@@ -150,7 +151,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(UnaryBooleanFunctionExpression const* expression) {
             expression->getOperand()->accept(this);
             std::shared_ptr<BaseExpression const> operandExpression = expressionStack.top();
@@ -164,7 +165,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(UnaryNumericalFunctionExpression const* expression) {
             expression->getOperand()->accept(this);
             std::shared_ptr<BaseExpression const> operandExpression = expressionStack.top();
@@ -178,23 +179,23 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(BooleanLiteralExpression const* expression) {
             this->expressionStack.push(expression->getSharedPointer());
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(IntegerLiteralExpression const* expression) {
             this->expressionStack.push(expression->getSharedPointer());
         }
         
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         void IdentifierSubstitutionVisitor<MapType>::visit(DoubleLiteralExpression const* expression) {
             this->expressionStack.push(expression->getSharedPointer());
         }
         
         // Explicitly instantiate the class with map and unordered_map.
-        template class IdentifierSubstitutionVisitor<std::map>;
+		template class IdentifierSubstitutionVisitor< std::map<std::string, std::string> >;
-        template class IdentifierSubstitutionVisitor<std::unordered_map>;
+		template class IdentifierSubstitutionVisitor< std::unordered_map<std::string, std::string> >;
     }
 }

src/storage/expressions/IdentifierSubstitutionVisitor.h

@@ -8,7 +8,7 @@
 
 namespace storm {
     namespace expressions {
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         class IdentifierSubstitutionVisitor : public ExpressionVisitor {
         public:
             /*!
@@ -16,7 +16,7 @@ namespace storm {
              *
              * @param identifierToExpressionMap A mapping from identifiers to expressions.
              */
-            IdentifierSubstitutionVisitor(MapType<std::string, std::string> const& identifierToExpressionMap);
+            IdentifierSubstitutionVisitor(MapType const& identifierToExpressionMap);
             
             /*!
              * Substitutes the identifiers in the given expression according to the previously given map and returns the
@@ -47,7 +47,7 @@ namespace storm {
             std::stack<std::shared_ptr<BaseExpression const>> expressionStack;
             
             // A mapping of identifier names to expressions with which they shall be replaced.
-            MapType<std::string, std::string> const& identifierToIdentifierMap;
+            MapType const& identifierToIdentifierMap;
         };
     }
 }

src/storage/expressions/SimpleValuation.h

@@ -7,6 +7,7 @@
 #include <iostream>
 
 #include "src/storage/expressions/Valuation.h"
+#include "src/utility/OsDetection.h"
 
 namespace storm {
     namespace expressions {
@@ -23,8 +24,10 @@ namespace storm {
             // Instantiate some constructors and assignments with their default implementations.
             SimpleValuation(SimpleValuation const&) = default;
             SimpleValuation& operator=(SimpleValuation const&) = default;
-            SimpleValuation(SimpleValuation&&) = default;
+#ifndef WINDOWS            
+			SimpleValuation(SimpleValuation&&) = default;
             SimpleValuation& operator=(SimpleValuation&&) = default;
+#endif
             virtual ~SimpleValuation() = default;
 
             /*!

src/storage/expressions/SubstitutionVisitor.cpp

@@ -1,5 +1,6 @@
 #include <map>
 #include <unordered_map>
+#include <string>
 
 #include "src/storage/expressions/SubstitutionVisitor.h"
 
@@ -19,18 +20,18 @@
 
 namespace storm {
     namespace expressions  {
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
-        SubstitutionVisitor<MapType>::SubstitutionVisitor(MapType<std::string, Expression> const& identifierToExpressionMap) : identifierToExpressionMap(identifierToExpressionMap) {
+        SubstitutionVisitor<MapType>::SubstitutionVisitor(MapType const& identifierToExpressionMap) : identifierToExpressionMap(identifierToExpressionMap) {
             // Intentionally left empty.
         }
 
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         Expression SubstitutionVisitor<MapType>::substitute(BaseExpression const* expression) {
             expression->accept(this);
             return Expression(this->expressionStack.top());
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(IfThenElseExpression const* expression) {
             expression->getCondition()->accept(this);
             std::shared_ptr<BaseExpression const> conditionExpression = expressionStack.top();
@@ -52,7 +53,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(BinaryBooleanFunctionExpression const* expression) {
             expression->getFirstOperand()->accept(this);
             std::shared_ptr<BaseExpression const> firstExpression = expressionStack.top();
@@ -70,7 +71,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(BinaryNumericalFunctionExpression const* expression) {
             expression->getFirstOperand()->accept(this);
             std::shared_ptr<BaseExpression const> firstExpression = expressionStack.top();
@@ -88,7 +89,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(BinaryRelationExpression const* expression) {
             expression->getFirstOperand()->accept(this);
             std::shared_ptr<BaseExpression const> firstExpression = expressionStack.top();
@@ -106,7 +107,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(BooleanConstantExpression const* expression) {
             // If the boolean constant is in the key set of the substitution, we need to replace it.
             auto const& nameExpressionPair = this->identifierToExpressionMap.find(expression->getConstantName());
@@ -117,7 +118,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(DoubleConstantExpression const* expression) {
             // If the double constant is in the key set of the substitution, we need to replace it.
             auto const& nameExpressionPair = this->identifierToExpressionMap.find(expression->getConstantName());
@@ -128,7 +129,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(IntegerConstantExpression const* expression) {
             // If the integer constant is in the key set of the substitution, we need to replace it.
             auto const& nameExpressionPair = this->identifierToExpressionMap.find(expression->getConstantName());
@@ -139,7 +140,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(VariableExpression const* expression) {
             // If the variable is in the key set of the substitution, we need to replace it.
             auto const& nameExpressionPair = this->identifierToExpressionMap.find(expression->getVariableName());
@@ -150,7 +151,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(UnaryBooleanFunctionExpression const* expression) {
             expression->getOperand()->accept(this);
             std::shared_ptr<BaseExpression const> operandExpression = expressionStack.top();
@@ -164,7 +165,7 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(UnaryNumericalFunctionExpression const* expression) {
             expression->getOperand()->accept(this);
             std::shared_ptr<BaseExpression const> operandExpression = expressionStack.top();
@@ -178,23 +179,23 @@ namespace storm {
             }
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(BooleanLiteralExpression const* expression) {
             this->expressionStack.push(expression->getSharedPointer());
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(IntegerLiteralExpression const* expression) {
             this->expressionStack.push(expression->getSharedPointer());
         }
         
-        template<template<typename... Arguments> class MapType>
+		template<typename MapType>
         void SubstitutionVisitor<MapType>::visit(DoubleLiteralExpression const* expression) {
             this->expressionStack.push(expression->getSharedPointer());
         }
         
         // Explicitly instantiate the class with map and unordered_map.
-        template class SubstitutionVisitor<std::map>;
+		template class SubstitutionVisitor< std::map<std::string, Expression> >;
-        template class SubstitutionVisitor<std::unordered_map>;
+		template class SubstitutionVisitor< std::unordered_map<std::string, Expression> >;
     }
 }

src/storage/expressions/SubstitutionVisitor.h

@@ -8,7 +8,7 @@
 
 namespace storm {
     namespace expressions {
-        template<template<typename... Arguments> class MapType>
+        template<typename MapType>
         class SubstitutionVisitor : public ExpressionVisitor {
         public:
             /*!
@@ -16,7 +16,7 @@ namespace storm {
              *
              * @param identifierToExpressionMap A mapping from identifiers to expressions.
              */
-            SubstitutionVisitor(MapType<std::string, Expression> const& identifierToExpressionMap);
+            SubstitutionVisitor(MapType const& identifierToExpressionMap);
             
             /*!
              * Substitutes the identifiers in the given expression according to the previously given map and returns the
@@ -47,7 +47,7 @@ namespace storm {
             std::stack<std::shared_ptr<BaseExpression const>> expressionStack;
             
             // A mapping of identifier names to expressions with which they shall be replaced.
-            MapType<std::string, Expression> const& identifierToExpressionMap;
+            MapType const& identifierToExpressionMap;
         };
     }
 }

src/storage/prism/Assignment.cpp

@@ -15,7 +15,7 @@ namespace storm {
         }
         
         Assignment Assignment::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return Assignment(this->getVariableName(), this->getExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return Assignment(this->getVariableName(), this->getExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, Assignment const& assignment) {

src/storage/prism/BooleanVariable.cpp

@@ -11,7 +11,7 @@ namespace storm {
         }
         
         BooleanVariable BooleanVariable::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return BooleanVariable(this->getName(), this->getInitialValueExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return BooleanVariable(this->getName(), this->getInitialValueExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, BooleanVariable const& variable) {

src/storage/prism/Command.cpp

@@ -37,7 +37,7 @@ namespace storm {
                 newUpdates.emplace_back(update.substitute(substitution));
             }
             
-            return Command(this->getGlobalIndex(), this->getActionName(), this->getGuardExpression().substitute<std::map>(substitution), newUpdates, this->getFilename(), this->getLineNumber());
+            return Command(this->getGlobalIndex(), this->getActionName(), this->getGuardExpression().substitute(substitution), newUpdates, this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, Command const& command) {

src/storage/prism/Constant.cpp

@@ -27,7 +27,7 @@ namespace storm {
         }
         
         Constant Constant::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return Constant(this->getType(), this->getName(), this->getExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return Constant(this->getType(), this->getName(), this->getExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, Constant const& constant) {

src/storage/prism/Formula.cpp

@@ -19,7 +19,7 @@ namespace storm {
         }
         
         Formula Formula::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return Formula(this->getName(), this->getExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return Formula(this->getName(), this->getExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, Formula const& formula) {

src/storage/prism/IntegerVariable.cpp

@@ -19,7 +19,7 @@ namespace storm {
         }
         
         IntegerVariable IntegerVariable::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return IntegerVariable(this->getName(), this->getLowerBoundExpression().substitute<std::map>(substitution), this->getUpperBoundExpression().substitute<std::map>(substitution), this->getInitialValueExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return IntegerVariable(this->getName(), this->getLowerBoundExpression().substitute(substitution), this->getUpperBoundExpression().substitute(substitution), this->getInitialValueExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, IntegerVariable const& variable) {

src/storage/prism/Label.cpp

@@ -15,7 +15,7 @@ namespace storm {
         }
         
         Label Label::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return Label(this->getName(), this->getStatePredicateExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return Label(this->getName(), this->getStatePredicateExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, Label const& label) {

src/storage/prism/LocatedInformation.h

@@ -2,6 +2,7 @@
 #define STORM_STORAGE_PRISM_LOCATEDINFORMATION_H_
 
 #include <string>
+#include <cstdint>
 
 #include "src/utility/OsDetection.h"
 

src/storage/prism/Program.cpp

@@ -229,7 +229,7 @@ namespace storm {
                     LOG_THROW(constantDefinitions.find(constant.getName()) == constantDefinitions.end(), storm::exceptions::InvalidArgumentException, "Illegally defining already defined constant '" << constant.getName() << "'.");
                     
                     // Now replace the occurrences of undefined constants in its defining expression.
-                    newConstants.emplace_back(constant.getType(), constant.getName(), constant.getExpression().substitute<std::map>(constantDefinitions), constant.getFilename(), constant.getLineNumber());
+                    newConstants.emplace_back(constant.getType(), constant.getName(), constant.getExpression().substitute(constantDefinitions), constant.getFilename(), constant.getLineNumber());
                 } else {
                     auto const& variableExpressionPair = constantDefinitions.find(constant.getName());
                     
@@ -306,7 +306,7 @@ namespace storm {
                 newRewardModels.emplace_back(rewardModel.substitute(constantSubstitution));
             }
             
-            storm::expressions::Expression newInitialStateExpression = this->getInitialStatesExpression().substitute<std::map>(constantSubstitution);
+            storm::expressions::Expression newInitialStateExpression = this->getInitialStatesExpression().substitute(constantSubstitution);
             
             std::vector<Label> newLabels;
             newLabels.reserve(this->getNumberOfLabels());

src/storage/prism/StateReward.cpp

@@ -15,7 +15,7 @@ namespace storm {
         }
         
         StateReward StateReward::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return StateReward(this->getStatePredicateExpression().substitute<std::map>(substitution), this->getRewardValueExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return StateReward(this->getStatePredicateExpression().substitute(substitution), this->getRewardValueExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, StateReward const& stateReward) {

src/storage/prism/TransitionReward.cpp

@@ -19,7 +19,7 @@ namespace storm {
         }
         
         TransitionReward TransitionReward::substitute(std::map<std::string, storm::expressions::Expression> const& substitution) const {
-            return TransitionReward(this->getActionName(), this->getStatePredicateExpression().substitute<std::map>(substitution), this->getRewardValueExpression().substitute<std::map>(substitution), this->getFilename(), this->getLineNumber());
+            return TransitionReward(this->getActionName(), this->getStatePredicateExpression().substitute(substitution), this->getRewardValueExpression().substitute(substitution), this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, TransitionReward const& transitionReward) {

src/storage/prism/Update.cpp

@@ -44,7 +44,7 @@ namespace storm {
                 newAssignments.emplace_back(assignment.substitute(substitution));
             }
             
-            return Update(this->getGlobalIndex(), this->getLikelihoodExpression().substitute<std::map>(substitution), newAssignments, this->getFilename(), this->getLineNumber());
+            return Update(this->getGlobalIndex(), this->getLikelihoodExpression().substitute(substitution), newAssignments, this->getFilename(), this->getLineNumber());
         }
         
         std::ostream& operator<<(std::ostream& stream, Update const& update) {

src/storage/prism/Variable.cpp

@@ -8,7 +8,7 @@ namespace storm {
             // Nothing to do here.
         }
         
-        Variable::Variable(Variable const& oldVariable, std::string const& newName, std::map<std::string, std::string> const& renaming, std::string const& filename, uint_fast64_t lineNumber) : LocatedInformation(filename, lineNumber), name(newName), initialValueExpression(oldVariable.getInitialValueExpression().substitute<std::map>(renaming)), defaultInitialValue(oldVariable.hasDefaultInitialValue()) {
+        Variable::Variable(Variable const& oldVariable, std::string const& newName, std::map<std::string, std::string> const& renaming, std::string const& filename, uint_fast64_t lineNumber) : LocatedInformation(filename, lineNumber), name(newName), initialValueExpression(oldVariable.getInitialValueExpression().substitute(renaming)), defaultInitialValue(oldVariable.hasDefaultInitialValue()) {
             // Intentionally left empty.
         }
         

test/functional/parser/PrismParserTest.cpp

@@ -47,7 +47,7 @@ TEST(PrismParser, SimpleFullTest) {
     R"(dtmc
     module mod1
         b : bool;
-        [a] true -> 1: (b'=true);
+        [a] true -> 1: (b'=true ^ false <=> b => false);
     endmodule)";
     
     storm::prism::Program result;

test/functional/solver/GmmxxLinearEquationSolverTest.cpp

@@ -81,7 +81,7 @@ TEST(GmmxxLinearEquationSolver, qmr) {
     
     ASSERT_NO_THROW(storm::solver::GmmxxLinearEquationSolver<double> solver(storm::solver::GmmxxLinearEquationSolver<double>::QMR, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::NONE));
     
-    storm::solver::GmmxxLinearEquationSolver<double> solver(storm::solver::GmmxxLinearEquationSolver<double>::QMR, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::NONE, 50);
+    storm::solver::GmmxxLinearEquationSolver<double> solver(storm::solver::GmmxxLinearEquationSolver<double>::QMR, 1e-6, 10000, storm::solver::GmmxxLinearEquationSolver<double>::NONE, true, 50);
     ASSERT_NO_THROW(solver.solveEquationSystem(A, x, b));
     ASSERT_LT(std::abs(x[0] - 1), storm::settings::Settings::getInstance()->getOptionByLongName("precision").getArgument(0).getValueAsDouble());
     ASSERT_LT(std::abs(x[1] - 3), storm::settings::Settings::getInstance()->getOptionByLongName("precision").getArgument(0).getValueAsDouble());

test/functional/storage/ExpressionTest.cpp

@@ -1,4 +1,5 @@
 #include <map>
+#include <string>
 
 #include "gtest/gtest.h"
 #include "src/storage/expressions/Expression.h"
@@ -264,6 +265,12 @@ TEST(Expression, OperatorTest) {
     ASSERT_NO_THROW(tempExpression = boolVarExpression.iff(boolConstExpression));
     EXPECT_TRUE(tempExpression.getReturnType() == storm::expressions::ExpressionReturnType::Bool);
     
+    ASSERT_THROW(tempExpression = trueExpression ^ piExpression, storm::exceptions::InvalidTypeException);
+    ASSERT_NO_THROW(tempExpression = trueExpression ^ falseExpression);
+    EXPECT_TRUE(tempExpression.getReturnType() == storm::expressions::ExpressionReturnType::Bool);
+    ASSERT_NO_THROW(tempExpression = boolVarExpression ^ boolConstExpression);
+    EXPECT_TRUE(tempExpression.getReturnType() == storm::expressions::ExpressionReturnType::Bool);
+    
     ASSERT_THROW(tempExpression = trueExpression.floor(), storm::exceptions::InvalidTypeException);
     ASSERT_NO_THROW(tempExpression = threeExpression.floor());
     EXPECT_TRUE(tempExpression.getReturnType() == storm::expressions::ExpressionReturnType::Int);
@@ -305,7 +312,7 @@ TEST(Expression, SubstitutionTest) {
 
     std::map<std::string, storm::expressions::Expression> substution = { std::make_pair("y", doubleConstExpression), std::make_pair("x", storm::expressions::Expression::createTrue()), std::make_pair("a", storm::expressions::Expression::createTrue()) };
     storm::expressions::Expression substitutedExpression;
-    ASSERT_NO_THROW(substitutedExpression = tempExpression.substitute<std::map>(substution));
+    ASSERT_NO_THROW(substitutedExpression = tempExpression.substitute(substution));
     EXPECT_TRUE(substitutedExpression.simplify().isTrue());
 }