David_Korzeniewski
11 years ago
25 changed files with 1717 additions and 531 deletions
-
400src/parser/ExpressionParser.cpp
-
128src/parser/ExpressionParser.h
-
384src/parser/PrismParser.cpp
-
82src/parser/PrismParser.h
-
21src/parser/SpiritParserDefinitions.h
-
473src/storage/dd/CuddDd.cpp
-
241src/storage/dd/CuddDd.h
-
2src/storage/dd/CuddDdForwardIterator.cpp
-
12src/storage/dd/CuddDdManager.cpp
-
2src/storage/dd/CuddDdManager.h
-
4src/storage/dd/CuddDdMetaVariable.cpp
-
4src/storage/dd/CuddDdMetaVariable.h
-
111src/storage/dd/CuddOdd.cpp
-
131src/storage/dd/CuddOdd.h
-
13src/storage/dd/Odd.h
-
5src/storage/expressions/BinaryNumericalFunctionExpression.cpp
-
2src/storage/expressions/BinaryNumericalFunctionExpression.h
-
12src/storage/expressions/Expression.cpp
-
1src/storage/expressions/LinearityCheckVisitor.cpp
-
1src/storage/expressions/OperatorType.h
-
65src/storm.cpp
-
2src/utility/StormOptions.cpp
-
1test/functional/parser/PrismParserTest.cpp
-
137test/functional/storage/CuddDdTest.cpp
-
12test/functional/storage/ExpressionTest.cpp
@ -0,0 +1,400 @@ |
|||
#include "src/parser/ExpressionParser.h"
|
|||
#include "src/exceptions/InvalidArgumentException.h"
|
|||
#include "src/exceptions/InvalidTypeException.h"
|
|||
#include "src/exceptions/WrongFormatException.h"
|
|||
|
|||
namespace storm { |
|||
namespace parser { |
|||
ExpressionParser::ExpressionParser(qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_) : ExpressionParser::base_type(expression), createExpressions(false), acceptDoubleLiterals(true), identifiers_(nullptr), invalidIdentifiers_(invalidIdentifiers_) { |
|||
identifier %= qi::as_string[qi::raw[qi::lexeme[((qi::alpha | qi::char_('_')) >> *(qi::alnum | qi::char_('_')))]]][qi::_pass = phoenix::bind(&ExpressionParser::isValidIdentifier, phoenix::ref(*this), qi::_1)]; |
|||
identifier.name("identifier"); |
|||
|
|||
floorCeilExpression = ((qi::lit("floor")[qi::_a = true] | qi::lit("ceil")[qi::_a = false]) >> qi::lit("(") >> plusExpression >> qi::lit(")"))[phoenix::if_(qi::_a) [qi::_val = phoenix::bind(&ExpressionParser::createFloorExpression, phoenix::ref(*this), qi::_1)] .else_ [qi::_val = phoenix::bind(&ExpressionParser::createCeilExpression, phoenix::ref(*this), qi::_1)]]; |
|||
floorCeilExpression.name("floor/ceil expression"); |
|||
|
|||
minMaxExpression = ((qi::lit("min")[qi::_a = true] | qi::lit("max")[qi::_a = false]) >> qi::lit("(") >> plusExpression >> qi::lit(",") >> plusExpression >> qi::lit(")"))[phoenix::if_(qi::_a) [qi::_val = phoenix::bind(&ExpressionParser::createMinimumExpression, phoenix::ref(*this), qi::_1, qi::_2)] .else_ [qi::_val = phoenix::bind(&ExpressionParser::createMaximumExpression, phoenix::ref(*this), qi::_1, qi::_2)]]; |
|||
minMaxExpression.name("min/max expression"); |
|||
|
|||
identifierExpression = identifier[qi::_val = phoenix::bind(&ExpressionParser::getIdentifierExpression, phoenix::ref(*this), qi::_1)]; |
|||
identifierExpression.name("identifier expression"); |
|||
|
|||
literalExpression = qi::lit("true")[qi::_val = phoenix::bind(&ExpressionParser::createTrueExpression, phoenix::ref(*this))] | qi::lit("false")[qi::_val = phoenix::bind(&ExpressionParser::createFalseExpression, phoenix::ref(*this))] | strict_double[qi::_val = phoenix::bind(&ExpressionParser::createDoubleLiteralExpression, phoenix::ref(*this), qi::_1, qi::_pass)] | qi::int_[qi::_val = phoenix::bind(&ExpressionParser::createIntegerLiteralExpression, phoenix::ref(*this), qi::_1)]; |
|||
literalExpression.name("literal expression"); |
|||
|
|||
atomicExpression = minMaxExpression | floorCeilExpression | qi::lit("(") >> expression >> qi::lit(")") | literalExpression | identifierExpression; |
|||
atomicExpression.name("atomic expression"); |
|||
|
|||
unaryExpression = atomicExpression[qi::_val = qi::_1] | (qi::lit("!") >> atomicExpression)[qi::_val = phoenix::bind(&ExpressionParser::createNotExpression, phoenix::ref(*this), qi::_1)] | (qi::lit("-") >> atomicExpression)[qi::_val = phoenix::bind(&ExpressionParser::createMinusExpression, phoenix::ref(*this), qi::_1)]; |
|||
unaryExpression.name("unary expression"); |
|||
|
|||
powerExpression = unaryExpression[qi::_val = qi::_1] >> -(qi::lit("^") > expression)[qi::_val = phoenix::bind(&ExpressionParser::createPowerExpression, phoenix::ref(*this), qi::_val, qi::_1)]; |
|||
powerExpression.name("power expression"); |
|||
|
|||
multiplicationExpression = powerExpression[qi::_val = qi::_1] >> *((qi::lit("*")[qi::_a = true] | qi::lit("/")[qi::_a = false]) >> powerExpression[phoenix::if_(qi::_a) [qi::_val = phoenix::bind(&ExpressionParser::createMultExpression, phoenix::ref(*this), qi::_val, qi::_1)] .else_ [qi::_val = phoenix::bind(&ExpressionParser::createDivExpression, phoenix::ref(*this), qi::_val, qi::_1)]]); |
|||
multiplicationExpression.name("multiplication expression"); |
|||
|
|||
plusExpression = multiplicationExpression[qi::_val = qi::_1] >> *((qi::lit("+")[qi::_a = true] | qi::lit("-")[qi::_a = false]) >> multiplicationExpression)[phoenix::if_(qi::_a) [qi::_val = phoenix::bind(&ExpressionParser::createPlusExpression, phoenix::ref(*this), qi::_val, qi::_1)] .else_ [qi::_val = phoenix::bind(&ExpressionParser::createMinusExpression, phoenix::ref(*this), qi::_val, qi::_1)]]; |
|||
plusExpression.name("plus expression"); |
|||
|
|||
relativeExpression = (plusExpression >> qi::lit(">=") >> plusExpression)[qi::_val = phoenix::bind(&ExpressionParser::createGreaterOrEqualExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit(">") >> plusExpression)[qi::_val = phoenix::bind(&ExpressionParser::createGreaterExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit("<=") >> plusExpression)[qi::_val = phoenix::bind(&ExpressionParser::createLessOrEqualExpression, phoenix::ref(*this), qi::_1, qi::_2)] | (plusExpression >> qi::lit("<") >> plusExpression)[qi::_val = phoenix::bind(&ExpressionParser::createLessExpression, phoenix::ref(*this), qi::_1, qi::_2)] | plusExpression[qi::_val = qi::_1]; |
|||
relativeExpression.name("relative expression"); |
|||
|
|||
equalityExpression = relativeExpression[qi::_val = qi::_1] >> *((qi::lit("=")[qi::_a = true] | qi::lit("!=")[qi::_a = false]) >> relativeExpression)[phoenix::if_(qi::_a) [ qi::_val = phoenix::bind(&ExpressionParser::createEqualsExpression, phoenix::ref(*this), qi::_val, qi::_1) ] .else_ [ qi::_val = phoenix::bind(&ExpressionParser::createNotEqualsExpression, phoenix::ref(*this), qi::_val, qi::_1) ] ]; |
|||
equalityExpression.name("equality expression"); |
|||
|
|||
andExpression = equalityExpression[qi::_val = qi::_1] >> *(qi::lit("&") >> equalityExpression)[qi::_val = phoenix::bind(&ExpressionParser::createAndExpression, phoenix::ref(*this), qi::_val, qi::_1)]; |
|||
andExpression.name("and expression"); |
|||
|
|||
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(&ExpressionParser::createOrExpression, phoenix::ref(*this), qi::_val, qi::_1)] .else_ [qi::_val = phoenix::bind(&ExpressionParser::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(&ExpressionParser::createIteExpression, phoenix::ref(*this), qi::_val, qi::_1, qi::_2)]; |
|||
iteExpression.name("if-then-else expression"); |
|||
|
|||
expression %= iteExpression; |
|||
expression.name("expression"); |
|||
|
|||
// Enable error reporting.
|
|||
qi::on_error<qi::fail>(expression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(iteExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(orExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(andExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(equalityExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(relativeExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(plusExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(multiplicationExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(unaryExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(atomicExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(literalExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(identifierExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(minMaxExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
qi::on_error<qi::fail>(floorCeilExpression, handler(qi::_1, qi::_2, qi::_3, qi::_4)); |
|||
} |
|||
|
|||
void ExpressionParser::setIdentifierMapping(qi::symbols<char, storm::expressions::Expression> const* identifiers_) { |
|||
if (identifiers_ != nullptr) { |
|||
this->createExpressions = true; |
|||
this->identifiers_ = identifiers_; |
|||
} else { |
|||
this->createExpressions = false; |
|||
this->identifiers_ = nullptr; |
|||
} |
|||
} |
|||
|
|||
void ExpressionParser::unsetIdentifierMapping() { |
|||
this->createExpressions = false; |
|||
this->identifiers_ = nullptr; |
|||
} |
|||
|
|||
void ExpressionParser::setAcceptDoubleLiterals(bool flag) { |
|||
this->acceptDoubleLiterals = flag; |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createIteExpression(storm::expressions::Expression e1, storm::expressions::Expression e2, storm::expressions::Expression e3) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1.ite(e2, e3); |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createImpliesExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1.implies(e2); |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createOrExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 || e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createAndExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try{ |
|||
return e1 && e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createGreaterExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 > e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createGreaterOrEqualExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 >= e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createLessExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 < e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createLessOrEqualExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 <= e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createEqualsExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
if (e1.hasBooleanReturnType() && e2.hasBooleanReturnType()) { |
|||
return e1.iff(e2); |
|||
} else { |
|||
return e1 == e2; |
|||
} |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createNotEqualsExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 != e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createPlusExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 + e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createMinusExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 - e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createMultExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 * e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createPowerExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 ^ e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createDivExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1 / e2; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createNotExpression(storm::expressions::Expression e1) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return !e1; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createMinusExpression(storm::expressions::Expression e1) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return -e1; |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createTrueExpression() const { |
|||
if (this->createExpressions) { |
|||
return storm::expressions::Expression::createTrue(); |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createFalseExpression() const { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createDoubleLiteralExpression(double value, bool& pass) const { |
|||
// If we are not supposed to accept double expressions, we reject it by setting pass to false.
|
|||
if (!this->acceptDoubleLiterals) { |
|||
pass = false; |
|||
} |
|||
|
|||
if (this->createExpressions) { |
|||
return storm::expressions::Expression::createDoubleLiteral(value); |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createIntegerLiteralExpression(int value) const { |
|||
if (this->createExpressions) { |
|||
return storm::expressions::Expression::createIntegerLiteral(static_cast<int_fast64_t>(value)); |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createMinimumExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return storm::expressions::Expression::minimum(e1, e2); |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createMaximumExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return storm::expressions::Expression::maximum(e1, e2); |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createFloorExpression(storm::expressions::Expression e1) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1.floor(); |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::createCeilExpression(storm::expressions::Expression e1) const { |
|||
if (this->createExpressions) { |
|||
try { |
|||
return e1.ceil(); |
|||
} catch (storm::exceptions::InvalidTypeException const& e) { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": " << e.what()); |
|||
} |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
storm::expressions::Expression ExpressionParser::getIdentifierExpression(std::string const& identifier) const { |
|||
if (this->createExpressions) { |
|||
LOG_THROW(this->identifiers_ != nullptr, storm::exceptions::WrongFormatException, "Unable to substitute identifier expressions without given mapping."); |
|||
storm::expressions::Expression const* expression = this->identifiers_->find(identifier); |
|||
LOG_THROW(expression != nullptr, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(qi::_3) << ": Undeclared identifier '" << identifier << "'."); |
|||
return *expression; |
|||
} else { |
|||
return storm::expressions::Expression::createFalse(); |
|||
} |
|||
} |
|||
|
|||
bool ExpressionParser::isValidIdentifier(std::string const& identifier) { |
|||
if (this->invalidIdentifiers_.find(identifier) != nullptr) { |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,128 @@ |
|||
#ifndef STORM_PARSER_EXPRESSIONPARSER_H_ |
|||
#define STORM_PARSER_EXPRESSIONPARSER_H_ |
|||
|
|||
#include "src/parser/SpiritParserDefinitions.h" |
|||
#include "src/storage/expressions/Expression.h" |
|||
#include "src/exceptions/ExceptionMacros.h" |
|||
#include "src/exceptions/WrongFormatException.h" |
|||
|
|||
namespace storm { |
|||
namespace parser { |
|||
class ExpressionParser : public qi::grammar<Iterator, storm::expressions::Expression(), Skipper> { |
|||
public: |
|||
/*! |
|||
* Creates an expression parser. Initially the parser is set to a mode in which it will not generate the |
|||
* actual expressions but only perform a syntax check and return the expression "false". To make the parser |
|||
* generate the actual expressions, a mapping of valid identifiers to their expressions need to be provided |
|||
* later. |
|||
* |
|||
* @param invalidIdentifiers_ A symbol table of identifiers that are to be rejected. |
|||
*/ |
|||
ExpressionParser(qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_); |
|||
|
|||
/*! |
|||
* Sets an identifier mapping that is used to determine valid variables in the expression. The mapped-to |
|||
* expressions will be substituted wherever the key value appears in the parsed expression. After setting |
|||
* this, the parser will generate expressions. |
|||
* |
|||
* @param identifiers A pointer to a mapping from identifiers to expressions. |
|||
*/ |
|||
void setIdentifierMapping(qi::symbols<char, storm::expressions::Expression> const* identifiers_); |
|||
|
|||
/*! |
|||
* Unsets a previously set identifier mapping. This will make the parser not generate expressions any more |
|||
* but merely check for syntactic correctness of an expression. |
|||
*/ |
|||
void unsetIdentifierMapping(); |
|||
|
|||
/*! |
|||
* Sets whether double literals are to be accepted or not. |
|||
* |
|||
* @param flag If set to true, double literals are accepted. |
|||
*/ |
|||
void setAcceptDoubleLiterals(bool flag); |
|||
|
|||
private: |
|||
// A flag that indicates whether expressions should actually be generated or just a syntax check shall be |
|||
// performed. |
|||
bool createExpressions; |
|||
|
|||
// A flag that indicates whether double literals are accepted. |
|||
bool acceptDoubleLiterals; |
|||
|
|||
// The currently used mapping of identifiers to expressions. This is used if the parser is set to create |
|||
// expressions. |
|||
qi::symbols<char, storm::expressions::Expression> const* identifiers_; |
|||
|
|||
// The symbol table of invalid identifiers. |
|||
qi::symbols<char, uint_fast64_t> const& invalidIdentifiers_; |
|||
|
|||
// 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(), qi::locals<bool>, Skipper> orExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), Skipper> andExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), Skipper> relativeExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> equalityExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> plusExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> multiplicationExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> powerExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), Skipper> unaryExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), Skipper> atomicExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), Skipper> literalExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), Skipper> identifierExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> minMaxExpression; |
|||
qi::rule<Iterator, storm::expressions::Expression(), qi::locals<bool>, Skipper> floorCeilExpression; |
|||
qi::rule<Iterator, std::string(), Skipper> identifier; |
|||
|
|||
// Parser that is used to recognize doubles only (as opposed to Spirit's double_ parser). |
|||
boost::spirit::qi::real_parser<double, boost::spirit::qi::strict_real_policies<double>> strict_double; |
|||
|
|||
// Helper functions to create expressions. |
|||
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 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; |
|||
storm::expressions::Expression createMinusExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const; |
|||
storm::expressions::Expression createMultExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const; |
|||
storm::expressions::Expression createPowerExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const; |
|||
storm::expressions::Expression createDivExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const; |
|||
storm::expressions::Expression createNotExpression(storm::expressions::Expression e1) const; |
|||
storm::expressions::Expression createMinusExpression(storm::expressions::Expression e1) const; |
|||
storm::expressions::Expression createTrueExpression() const; |
|||
storm::expressions::Expression createFalseExpression() const; |
|||
storm::expressions::Expression createDoubleLiteralExpression(double value, bool& pass) const; |
|||
storm::expressions::Expression createIntegerLiteralExpression(int value) const; |
|||
storm::expressions::Expression createMinimumExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const; |
|||
storm::expressions::Expression createMaximumExpression(storm::expressions::Expression e1, storm::expressions::Expression e2) const; |
|||
storm::expressions::Expression createFloorExpression(storm::expressions::Expression e1) const; |
|||
storm::expressions::Expression createCeilExpression(storm::expressions::Expression e1) const; |
|||
storm::expressions::Expression getIdentifierExpression(std::string const& identifier) const; |
|||
|
|||
bool isValidIdentifier(std::string const& identifier); |
|||
|
|||
// Functor used for displaying error information. |
|||
struct ErrorHandler { |
|||
typedef qi::error_handler_result result_type; |
|||
|
|||
template<typename T1, typename T2, typename T3, typename T4> |
|||
qi::error_handler_result operator()(T1 b, T2 e, T3 where, T4 const& what) const { |
|||
LOG_THROW(false, storm::exceptions::WrongFormatException, "Parsing error in line " << get_line(where) << ": " << " expecting " << what << "."); |
|||
return qi::fail; |
|||
} |
|||
}; |
|||
|
|||
// An error handler function. |
|||
phoenix::function<ErrorHandler> handler; |
|||
}; |
|||
} // namespace parser |
|||
} // namespace storm |
|||
|
|||
#endif /* STORM_PARSER_EXPRESSIONPARSER_H_ */ |
|||
@ -0,0 +1,21 @@ |
|||
#ifndef STORM_PARSER_SPIRITPARSERDEFINITIONS_H_ |
|||
#define STORM_PARSER_SPIRITPARSERDEFINITIONS_H_ |
|||
|
|||
// Include boost spirit. |
|||
#define BOOST_SPIRIT_USE_PHOENIX_V3 |
|||
#include <boost/typeof/typeof.hpp> |
|||
#include <boost/spirit/include/qi.hpp> |
|||
#include <boost/spirit/include/phoenix.hpp> |
|||
#include <boost/spirit/include/support_line_pos_iterator.hpp> |
|||
#include <boost/spirit/home/classic/iterator/position_iterator.hpp> |
|||
|
|||
namespace qi = boost::spirit::qi; |
|||
namespace phoenix = boost::phoenix; |
|||
|
|||
typedef std::string::const_iterator BaseIteratorType; |
|||
typedef boost::spirit::line_pos_iterator<BaseIteratorType> PositionIteratorType; |
|||
typedef PositionIteratorType Iterator; |
|||
|
|||
typedef BOOST_TYPEOF(boost::spirit::ascii::space | qi::lit("//") >> *(qi::char_ - qi::eol) >> qi::eol) Skipper; |
|||
|
|||
#endif /* STORM_PARSER_SPIRITPARSERDEFINITIONS_H_ */ |
|||
@ -0,0 +1,111 @@ |
|||
#include "src/storage/dd/CuddOdd.h"
|
|||
|
|||
#include <algorithm>
|
|||
|
|||
#include "src/storage/dd/CuddDdManager.h"
|
|||
#include "src/storage/dd/CuddDdMetaVariable.h"
|
|||
|
|||
namespace storm { |
|||
namespace dd { |
|||
Odd<DdType::CUDD>::Odd(Dd<DdType::CUDD> const& dd) { |
|||
std::shared_ptr<DdManager<DdType::CUDD>> manager = dd.getDdManager(); |
|||
|
|||
// First, we need to determine the involved DD variables indices.
|
|||
std::vector<uint_fast64_t> ddVariableIndices = dd.getSortedVariableIndices(); |
|||
|
|||
// Prepare a unique table for each level that keeps the constructed ODD nodes unique.
|
|||
std::vector<std::map<DdNode*, std::shared_ptr<Odd<DdType::CUDD>>>> uniqueTableForLevels(ddVariableIndices.size() + 1); |
|||
|
|||
// Now construct the ODD structure.
|
|||
std::shared_ptr<Odd<DdType::CUDD>> rootOdd = buildOddRec(dd.getCuddAdd().getNode(), manager->getCuddManager(), 0, ddVariableIndices.size(), ddVariableIndices, uniqueTableForLevels); |
|||
|
|||
// Finally, move the children of the root ODD into this ODD.
|
|||
this->dd = rootOdd->dd; |
|||
this->elseNode = std::move(rootOdd->elseNode); |
|||
this->thenNode = std::move(rootOdd->thenNode); |
|||
this->elseOffset = rootOdd->elseOffset; |
|||
this->thenOffset = rootOdd->thenOffset; |
|||
} |
|||
|
|||
Odd<DdType::CUDD>::Odd(ADD dd, std::shared_ptr<Odd<DdType::CUDD>>&& elseNode, uint_fast64_t elseOffset, std::shared_ptr<Odd<DdType::CUDD>>&& thenNode, uint_fast64_t thenOffset) : dd(dd), elseNode(elseNode), thenNode(thenNode), elseOffset(elseOffset), thenOffset(thenOffset) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
Odd<DdType::CUDD> const& Odd<DdType::CUDD>::getThenSuccessor() const { |
|||
return *this->thenNode; |
|||
} |
|||
|
|||
Odd<DdType::CUDD> const& Odd<DdType::CUDD>::getElseSuccessor() const { |
|||
return *this->elseNode; |
|||
} |
|||
|
|||
uint_fast64_t Odd<DdType::CUDD>::getElseOffset() const { |
|||
return this->elseOffset; |
|||
} |
|||
|
|||
void Odd<DdType::CUDD>::setElseOffset(uint_fast64_t newOffset) { |
|||
this->elseOffset = newOffset; |
|||
} |
|||
|
|||
uint_fast64_t Odd<DdType::CUDD>::getThenOffset() const { |
|||
return this->thenOffset; |
|||
} |
|||
|
|||
void Odd<DdType::CUDD>::setThenOffset(uint_fast64_t newOffset) { |
|||
this->thenOffset = newOffset; |
|||
} |
|||
|
|||
uint_fast64_t Odd<DdType::CUDD>::getTotalOffset() const { |
|||
return this->elseOffset + this->thenOffset; |
|||
} |
|||
|
|||
uint_fast64_t Odd<DdType::CUDD>::getNodeCount() const { |
|||
// If the ODD contains a constant (and thus has no children), the size is 1.
|
|||
if (this->elseNode == nullptr && this->thenNode == nullptr) { |
|||
return 1; |
|||
} |
|||
|
|||
// If the two successors are actually the same, we need to count the subnodes only once.
|
|||
if (this->elseNode == this->thenNode) { |
|||
return this->elseNode->getNodeCount(); |
|||
} else { |
|||
return this->elseNode->getNodeCount() + this->thenNode->getNodeCount(); |
|||
} |
|||
} |
|||
|
|||
std::shared_ptr<Odd<DdType::CUDD>> Odd<DdType::CUDD>::buildOddRec(DdNode* dd, Cudd const& manager, uint_fast64_t currentLevel, uint_fast64_t maxLevel, std::vector<uint_fast64_t> const& ddVariableIndices, std::vector<std::map<DdNode*, std::shared_ptr<Odd<DdType::CUDD>>>>& uniqueTableForLevels) { |
|||
// Check whether the ODD for this node has already been computed (for this level) and if so, return this instead.
|
|||
auto const& iterator = uniqueTableForLevels[currentLevel].find(dd); |
|||
if (iterator != uniqueTableForLevels[currentLevel].end()) { |
|||
return iterator->second; |
|||
} else { |
|||
// Otherwise, we need to recursively compute the ODD.
|
|||
|
|||
// If we are already past the maximal level that is to be considered, we can simply create a Odd without
|
|||
// successors
|
|||
if (currentLevel == maxLevel) { |
|||
uint_fast64_t elseOffset = 0; |
|||
uint_fast64_t thenOffset = 0; |
|||
|
|||
// If the DD is not the zero leaf, then the then-offset is 1.
|
|||
if (dd != Cudd_ReadZero(manager.getManager())) { |
|||
thenOffset = 1; |
|||
} |
|||
|
|||
return std::shared_ptr<Odd<DdType::CUDD>>(new Odd<DdType::CUDD>(ADD(manager, dd), nullptr, elseOffset, nullptr, thenOffset)); |
|||
} else if (ddVariableIndices[currentLevel] < static_cast<uint_fast64_t>(dd->index)) { |
|||
// If we skipped the level in the DD, we compute the ODD just for the else-successor and use the same
|
|||
// node for the then-successor as well.
|
|||
std::shared_ptr<Odd<DdType::CUDD>> elseNode = buildOddRec(dd, manager, currentLevel + 1, maxLevel, ddVariableIndices, uniqueTableForLevels); |
|||
std::shared_ptr<Odd<DdType::CUDD>> thenNode = elseNode; |
|||
return std::shared_ptr<Odd<DdType::CUDD>>(new Odd<DdType::CUDD>(ADD(manager, dd), std::move(elseNode), elseNode->getElseOffset() + elseNode->getThenOffset(), std::move(thenNode), thenNode->getElseOffset() + thenNode->getThenOffset())); |
|||
} else { |
|||
// Otherwise, we compute the ODDs for both the then- and else successors.
|
|||
std::shared_ptr<Odd<DdType::CUDD>> elseNode = buildOddRec(Cudd_E(dd), manager, currentLevel + 1, maxLevel, ddVariableIndices, uniqueTableForLevels); |
|||
std::shared_ptr<Odd<DdType::CUDD>> thenNode = buildOddRec(Cudd_T(dd), manager, currentLevel + 1, maxLevel, ddVariableIndices, uniqueTableForLevels); |
|||
return std::shared_ptr<Odd<DdType::CUDD>>(new Odd<DdType::CUDD>(ADD(manager, dd), std::move(elseNode), elseNode->getElseOffset() + elseNode->getThenOffset(), std::move(thenNode), thenNode->getElseOffset() + thenNode->getThenOffset())); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,131 @@ |
|||
#ifndef STORM_STORAGE_DD_CUDDODD_H_ |
|||
#define STORM_STORAGE_DD_CUDDODD_H_ |
|||
|
|||
#include <memory> |
|||
|
|||
#include "src/storage/dd/Odd.h" |
|||
#include "src/storage/dd/CuddDd.h" |
|||
#include "src/utility/OsDetection.h" |
|||
|
|||
// Include the C++-interface of CUDD. |
|||
#include "cuddObj.hh" |
|||
|
|||
namespace storm { |
|||
namespace dd { |
|||
template<> |
|||
class Odd<DdType::CUDD> { |
|||
public: |
|||
/*! |
|||
* Constructs an offset-labeled DD from the given DD. |
|||
* |
|||
* @param dd The DD for which to build the offset-labeled DD. |
|||
*/ |
|||
Odd(Dd<DdType::CUDD> const& dd); |
|||
|
|||
// Instantiate all copy/move constructors/assignments with the default implementation. |
|||
Odd() = default; |
|||
Odd(Odd<DdType::CUDD> const& other) = default; |
|||
Odd& operator=(Odd<DdType::CUDD> const& other) = default; |
|||
#ifndef WINDOWS |
|||
Odd(Odd<DdType::CUDD>&& other) = default; |
|||
Odd& operator=(Odd<DdType::CUDD>&& other) = default; |
|||
#endif |
|||
|
|||
/*! |
|||
* Retrieves the then-successor of this ODD node. |
|||
* |
|||
* @return The then-successor of this ODD node. |
|||
*/ |
|||
Odd<DdType::CUDD> const& getThenSuccessor() const; |
|||
|
|||
/*! |
|||
* Retrieves the else-successor of this ODD node. |
|||
* |
|||
* @return The else-successor of this ODD node. |
|||
*/ |
|||
Odd<DdType::CUDD> const& getElseSuccessor() const; |
|||
|
|||
/*! |
|||
* Retrieves the else-offset of this ODD node. |
|||
* |
|||
* @return The else-offset of this ODD node. |
|||
*/ |
|||
uint_fast64_t getElseOffset() const; |
|||
|
|||
/*! |
|||
* Sets the else-offset of this ODD node. |
|||
* |
|||
* @param newOffset The new else-offset of this ODD node. |
|||
*/ |
|||
void setElseOffset(uint_fast64_t newOffset); |
|||
|
|||
/*! |
|||
* Retrieves the then-offset of this ODD node. |
|||
* |
|||
* @return The then-offset of this ODD node. |
|||
*/ |
|||
uint_fast64_t getThenOffset() const; |
|||
|
|||
/*! |
|||
* Sets the then-offset of this ODD node. |
|||
* |
|||
* @param newOffset The new then-offset of this ODD node. |
|||
*/ |
|||
void setThenOffset(uint_fast64_t newOffset); |
|||
|
|||
/*! |
|||
* Retrieves the total offset, i.e., the sum of the then- and else-offset. |
|||
* |
|||
* @return The total offset of this ODD. |
|||
*/ |
|||
uint_fast64_t getTotalOffset() const; |
|||
|
|||
/*! |
|||
* Retrieves the size of the ODD. Note: the size is computed by a traversal, so this may be costlier than |
|||
* expected. |
|||
* |
|||
* @return The size (in nodes) of this ODD. |
|||
*/ |
|||
uint_fast64_t getNodeCount() const; |
|||
|
|||
private: |
|||
/*! |
|||
* Constructs an offset-labeled DD with the given topmost DD node, else- and then-successor. |
|||
* |
|||
* @param dd The DD associated with this ODD node. |
|||
* @param elseNode The else-successor of thie ODD node. |
|||
* @param elseOffset The offset of the else-successor. |
|||
* @param thenNode The then-successor of thie ODD node. |
|||
* @param thenOffset The offset of the then-successor. |
|||
*/ |
|||
Odd(ADD dd, std::shared_ptr<Odd<DdType::CUDD>>&& elseNode, uint_fast64_t elseOffset, std::shared_ptr<Odd<DdType::CUDD>>&& thenNode, uint_fast64_t thenOffset); |
|||
|
|||
/*! |
|||
* Recursively builds the ODD. |
|||
* |
|||
* @param dd The DD for which to build the ODD. |
|||
* @param manager The manager responsible for the DD. |
|||
* @param currentLevel The currently considered level in the DD. |
|||
* @param maxLevel The number of levels that need to be considered. |
|||
* @param ddVariableIndices The (sorted) indices of all DD variables that need to be considered. |
|||
* @param uniqueTableForLevels A vector of unique tables, one for each level to be considered, that keeps |
|||
* ODD nodes for the same DD and level unique. |
|||
* @return A pointer to the constructed ODD for the given arguments. |
|||
*/ |
|||
static std::shared_ptr<Odd<DdType::CUDD>> buildOddRec(DdNode* dd, Cudd const& manager, uint_fast64_t currentLevel, uint_fast64_t maxLevel, std::vector<uint_fast64_t> const& ddVariableIndices, std::vector<std::map<DdNode*, std::shared_ptr<Odd<DdType::CUDD>>>>& uniqueTableForLevels); |
|||
|
|||
// The DD associated with this ODD node. |
|||
ADD dd; |
|||
|
|||
// The then- and else-nodes. |
|||
std::shared_ptr<Odd<DdType::CUDD>> elseNode; |
|||
std::shared_ptr<Odd<DdType::CUDD>> thenNode; |
|||
|
|||
// The offsets that need to be added if the then- or else-successor is taken, respectively. |
|||
uint_fast64_t elseOffset; |
|||
uint_fast64_t thenOffset; |
|||
}; |
|||
} |
|||
} |
|||
|
|||
#endif /* STORM_STORAGE_DD_CUDDODD_H_ */ |
|||
@ -0,0 +1,13 @@ |
|||
#ifndef STORM_STORAGE_DD_ODD_H_ |
|||
#define STORM_STORAGE_DD_ODD_H_ |
|||
|
|||
#include "src/storage/dd/DdType.h" |
|||
|
|||
namespace storm { |
|||
namespace dd { |
|||
// Declare Odd class so we can then specialize it for the different DD types. |
|||
template<DdType Type> class Odd; |
|||
} |
|||
} |
|||
|
|||
#endif /* STORM_STORAGE_DD_ODD_H_ */ |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue