Browse Source

cleaning includes for better compilation times

Former-commit-id: e2878ae043
main
sjunges 10 years ago
parent
commit
a129983ae9
  1. 288
      src/adapters/Z3ExpressionAdapter.cpp
  2. 289
      src/adapters/Z3ExpressionAdapter.h
  3. 3
      src/models/sparse/Model.h
  4. 4
      src/models/sparse/StateLabeling.cpp
  5. 7
      src/models/sparse/StateLabeling.h
  6. 7
      src/parser/PrismParser.h
  7. 3
      src/solver/GlpkLpSolver.cpp
  8. 1
      src/solver/GlpkLpSolver.h
  9. 3
      src/solver/GurobiLpSolver.cpp
  10. 1
      src/solver/GurobiLpSolver.h
  11. 23
      src/solver/LpSolver.cpp
  12. 23
      src/solver/LpSolver.h
  13. 2
      src/solver/SymbolicGameSolver.h
  14. 1
      src/solver/SymbolicLinearEquationSolver.h
  15. 1
      src/solver/Z3SmtSolver.cpp
  16. 4
      src/solver/Z3SmtSolver.h
  17. 1
      src/storage/dd/CuddDdForwardIterator.cpp
  18. 1
      src/storage/dd/CuddDdManager.cpp
  19. 7
      src/storage/dd/CuddDdManager.h
  20. 2
      src/storage/dd/CuddDdMetaVariable.h
  21. 9
      src/storage/expressions/BaseExpression.h
  22. 1
      src/storage/expressions/BinaryBooleanFunctionExpression.cpp
  23. 2
      src/storage/expressions/BinaryNumericalFunctionExpression.cpp
  24. 1
      src/storage/expressions/BinaryRelationExpression.cpp
  25. 1
      src/storage/expressions/BooleanLiteralExpression.cpp
  26. 1
      src/storage/expressions/DoubleLiteralExpression.cpp
  27. 1
      src/storage/expressions/Expression.cpp
  28. 25
      src/storage/expressions/Expression.h
  29. 1
      src/storage/expressions/ExpressionManager.cpp
  30. 1
      src/storage/expressions/IfThenElseExpression.cpp
  31. 2
      src/storage/expressions/IntegerLiteralExpression.cpp
  32. 1
      src/storage/expressions/LinearCoefficientVisitor.cpp
  33. 1
      src/storage/expressions/ToRationalFunctionVisitor.cpp
  34. 1
      src/storage/expressions/UnaryBooleanFunctionExpression.cpp
  35. 1
      src/storage/expressions/UnaryNumericalFunctionExpression.cpp
  36. 2
      src/storage/expressions/Variable.cpp
  37. 5
      src/storage/expressions/Variable.h
  38. 2
      src/storage/expressions/VariableExpression.cpp
  39. 1
      src/storage/prism/InitialConstruct.cpp
  40. 11
      src/storage/prism/InitialConstruct.h
  41. 1
      src/storage/prism/Label.cpp
  42. 9
      src/storage/prism/Label.h
  43. 1
      src/storage/prism/Module.h
  44. 1
      src/storage/prism/Program.h
  45. 1
      src/storage/prism/StateReward.cpp
  46. 10
      src/storage/prism/StateReward.h
  47. 1
      src/storage/prism/TransitionReward.cpp
  48. 11
      src/storage/prism/TransitionReward.h
  49. 3
      src/utility/prism.cpp
  50. 14
      src/utility/prism.h
  51. 1
      test/functional/adapter/Z3ExpressionAdapterTest.cpp
  52. 2
      test/functional/builder/die.pm
  53. 3
      test/functional/solver/GlpkLpSolverTest.cpp
  54. 2
      test/functional/solver/GurobiLpSolverTest.cpp
  55. 1
      test/functional/solver/Z3SmtSolverTest.cpp
  56. 1
      test/functional/storm-functional-tests.cpp

288
src/adapters/Z3ExpressionAdapter.cpp

@ -0,0 +1,288 @@
#include "Z3ExpressionAdapter.h"
#include "src/storage/expressions/Expressions.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/utility/macros.h"
#include "src/exceptions/ExpressionEvaluationException.h"
#include "src/exceptions/InvalidTypeException.h"
#include "src/exceptions/NotImplementedException.h"
namespace storm {
namespace adapters {
#ifdef STORM_HAVE_Z3
Z3ExpressionAdapter::Z3ExpressionAdapter(storm::expressions::ExpressionManager& manager, z3::context& context) : manager(manager), context(context), additionalAssertions(), variableToExpressionMapping() {
// Intentionally left empty.
}
z3::expr Z3ExpressionAdapter::translateExpression(storm::expressions::Expression const& expression) {
STORM_LOG_ASSERT(expression.getManager() == this->manager, "Invalid expression for solver.");
z3::expr result = boost::any_cast<z3::expr>(expression.getBaseExpression().accept(*this));
for (z3::expr const& assertion : additionalAssertions) {
result = result && assertion;
}
additionalAssertions.clear();
return result;
}
z3::expr Z3ExpressionAdapter::translateExpression(storm::expressions::Variable const& variable) {
STORM_LOG_ASSERT(variable.getManager() == this->manager, "Invalid expression for solver.");
auto const& variableExpressionPair = variableToExpressionMapping.find(variable);
if (variableExpressionPair == variableToExpressionMapping.end()) {
return createVariable(variable);
}
return variableExpressionPair->second;
}
storm::expressions::Variable const& Z3ExpressionAdapter::getVariable(z3::func_decl z3Declaration) {
auto const& declarationVariablePair = declarationToVariableMapping.find(z3Declaration);
STORM_LOG_ASSERT(declarationVariablePair != declarationToVariableMapping.end(), "Unable to find declaration.");
return declarationVariablePair->second;
}
storm::expressions::Expression Z3ExpressionAdapter::translateExpression(z3::expr const& expr) {
if (expr.is_app()) {
switch (expr.decl().decl_kind()) {
case Z3_OP_TRUE:
return manager.boolean(true);
case Z3_OP_FALSE:
return manager.boolean(false);
case Z3_OP_EQ:
return this->translateExpression(expr.arg(0)) == this->translateExpression(expr.arg(1));
case Z3_OP_ITE:
return storm::expressions::ite(this->translateExpression(expr.arg(0)), this->translateExpression(expr.arg(1)), this->translateExpression(expr.arg(2)));
case Z3_OP_AND: {
unsigned args = expr.num_args();
STORM_LOG_THROW(args != 0, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. 0-ary AND is assumed to be an error.");
if (args == 1) {
return this->translateExpression(expr.arg(0));
} else {
storm::expressions::Expression retVal = this->translateExpression(expr.arg(0));
for (unsigned i = 1; i < args; i++) {
retVal = retVal && this->translateExpression(expr.arg(i));
}
return retVal;
}
}
case Z3_OP_OR: {
unsigned args = expr.num_args();
STORM_LOG_THROW(args != 0, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. 0-ary OR is assumed to be an error.");
if (args == 1) {
return this->translateExpression(expr.arg(0));
} else {
storm::expressions::Expression retVal = this->translateExpression(expr.arg(0));
for (unsigned i = 1; i < args; i++) {
retVal = retVal || this->translateExpression(expr.arg(i));
}
return retVal;
}
}
case Z3_OP_IFF:
return storm::expressions::iff(this->translateExpression(expr.arg(0)), this->translateExpression(expr.arg(1)));
case Z3_OP_XOR:
return this->translateExpression(expr.arg(0)) ^ this->translateExpression(expr.arg(1));
case Z3_OP_NOT:
return !this->translateExpression(expr.arg(0));
case Z3_OP_IMPLIES:
return storm::expressions::implies(this->translateExpression(expr.arg(0)), this->translateExpression(expr.arg(1)));
case Z3_OP_LE:
return this->translateExpression(expr.arg(0)) <= this->translateExpression(expr.arg(1));
case Z3_OP_GE:
return this->translateExpression(expr.arg(0)) >= this->translateExpression(expr.arg(1));
case Z3_OP_LT:
return this->translateExpression(expr.arg(0)) < this->translateExpression(expr.arg(1));
case Z3_OP_GT:
return this->translateExpression(expr.arg(0)) > this->translateExpression(expr.arg(1));
case Z3_OP_ADD:
return this->translateExpression(expr.arg(0)) + this->translateExpression(expr.arg(1));
case Z3_OP_SUB:
return this->translateExpression(expr.arg(0)) - this->translateExpression(expr.arg(1));
case Z3_OP_UMINUS:
return -this->translateExpression(expr.arg(0));
case Z3_OP_MUL:
return this->translateExpression(expr.arg(0)) * this->translateExpression(expr.arg(1));
case Z3_OP_DIV:
return this->translateExpression(expr.arg(0)) / this->translateExpression(expr.arg(1));
case Z3_OP_IDIV:
return this->translateExpression(expr.arg(0)) / this->translateExpression(expr.arg(1));
case Z3_OP_ANUM:
// Arithmetic numeral.
if (expr.is_int() && expr.is_const()) {
long long value;
if (Z3_get_numeral_int64(expr.ctx(), expr, &value)) {
return manager.integer(value);
} else {
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Expression is constant integer and value does not fit into 64-bit integer.");
}
} else if (expr.is_real() && expr.is_const()) {
long long num;
long long den;
if (Z3_get_numeral_rational_int64(expr.ctx(), expr, &num, &den)) {
return manager.rational(static_cast<double>(num) / static_cast<double>(den));
} else {
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Expression is constant real and value does not fit into a fraction with 64-bit integer numerator and denominator.");
}
}
case Z3_OP_UNINTERPRETED:
// Currently, we only support uninterpreted constant functions.
STORM_LOG_THROW(expr.is_const(), storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Encountered non-constant uninterpreted function.");
return manager.getVariable(expr.decl().name().str()).getExpression();
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Encountered unhandled Z3_decl_kind " << expr.decl().kind() <<".");
break;
}
} else {
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Encountered unknown expression type.");
}
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::BinaryBooleanFunctionExpression const& expression) {
z3::expr leftResult = boost::any_cast<z3::expr>(expression.getFirstOperand()->accept(*this));
z3::expr rightResult = boost::any_cast<z3::expr>(expression.getSecondOperand()->accept(*this));
switch(expression.getOperatorType()) {
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::And:
return leftResult && rightResult;
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Or:
return leftResult || rightResult;
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Xor:
return z3::expr(context, Z3_mk_xor(context, leftResult, rightResult));
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Implies:
return z3::expr(context, Z3_mk_implies(context, leftResult, rightResult));
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Iff:
return z3::expr(context, Z3_mk_iff(context, leftResult, rightResult));
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown boolean binary operator '" << static_cast<int>(expression.getOperatorType()) << "' in expression " << expression << ".");
}
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::BinaryNumericalFunctionExpression const& expression) {
z3::expr leftResult = boost::any_cast<z3::expr>(expression.getFirstOperand()->accept(*this));
z3::expr rightResult = boost::any_cast<z3::expr>(expression.getSecondOperand()->accept(*this));
switch(expression.getOperatorType()) {
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Plus:
return leftResult + rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Minus:
return leftResult - rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Times:
return leftResult * rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Divide:
return leftResult / rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Min:
return ite(leftResult <= rightResult, leftResult, rightResult);
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Max:
return ite(leftResult >= rightResult, leftResult, rightResult);
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown numerical binary operator '" << static_cast<int>(expression.getOperatorType()) << "' in expression " << expression << ".");
}
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::BinaryRelationExpression const& expression) {
z3::expr leftResult = boost::any_cast<z3::expr>(expression.getFirstOperand()->accept(*this));
z3::expr rightResult = boost::any_cast<z3::expr>(expression.getSecondOperand()->accept(*this));
switch(expression.getRelationType()) {
case storm::expressions::BinaryRelationExpression::RelationType::Equal:
return leftResult == rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::NotEqual:
return leftResult != rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::Less:
return leftResult < rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::LessOrEqual:
return leftResult <= rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::Greater:
return leftResult > rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual:
return leftResult >= rightResult;
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown boolean binary operator '" << static_cast<int>(expression.getRelationType()) << "' in expression " << expression << ".");
}
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::BooleanLiteralExpression const& expression) {
return context.bool_val(expression.getValue());
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::DoubleLiteralExpression const& expression) {
std::stringstream fractionStream;
fractionStream << expression.getValue();
return context.real_val(fractionStream.str().c_str());
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::IntegerLiteralExpression const& expression) {
return context.int_val(static_cast<int>(expression.getValue()));
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::UnaryBooleanFunctionExpression const& expression) {
z3::expr childResult = boost::any_cast<z3::expr>(expression.getOperand()->accept(*this));
switch (expression.getOperatorType()) {
case storm::expressions::UnaryBooleanFunctionExpression::OperatorType::Not:
return !childResult;
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown boolean binary operator '" << static_cast<int>(expression.getOperatorType()) << "' in expression " << expression << ".");
}
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::UnaryNumericalFunctionExpression const& expression) {
z3::expr childResult = boost::any_cast<z3::expr>(expression.getOperand()->accept(*this));
switch(expression.getOperatorType()) {
case storm::expressions::UnaryNumericalFunctionExpression::OperatorType::Minus:
return 0 - childResult;
case storm::expressions::UnaryNumericalFunctionExpression::OperatorType::Floor: {
storm::expressions::Variable freshAuxiliaryVariable = manager.declareFreshVariable(manager.getIntegerType(), true);
z3::expr floorVariable = context.int_const(freshAuxiliaryVariable.getName().c_str());
additionalAssertions.push_back(z3::expr(context, Z3_mk_int2real(context, floorVariable)) <= childResult && childResult < (z3::expr(context, Z3_mk_int2real(context, floorVariable)) + 1));
return floorVariable;
}
case storm::expressions::UnaryNumericalFunctionExpression::OperatorType::Ceil:{
storm::expressions::Variable freshAuxiliaryVariable = manager.declareFreshVariable(manager.getIntegerType(), true);
z3::expr ceilVariable = context.int_const(freshAuxiliaryVariable.getName().c_str());
additionalAssertions.push_back(z3::expr(context, Z3_mk_int2real(context, ceilVariable)) - 1 <= childResult && childResult < z3::expr(context, Z3_mk_int2real(context, ceilVariable)));
return ceilVariable;
}
default: STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown numerical unary operator '" << static_cast<int>(expression.getOperatorType()) << "'.");
}
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::IfThenElseExpression const& expression) {
z3::expr conditionResult = boost::any_cast<z3::expr>(expression.getCondition()->accept(*this));
z3::expr thenResult = boost::any_cast<z3::expr>(expression.getThenExpression()->accept(*this));
z3::expr elseResult = boost::any_cast<z3::expr>(expression.getElseExpression()->accept(*this));
return z3::expr(context, Z3_mk_ite(context, conditionResult, thenResult, elseResult));
}
boost::any Z3ExpressionAdapter::visit(storm::expressions::VariableExpression const& expression) {
return this->translateExpression(expression.getVariable());
}
z3::expr Z3ExpressionAdapter::createVariable(storm::expressions::Variable const& variable) {
z3::expr z3Variable(context);
if (variable.getType().isBooleanType()) {
z3Variable = context.bool_const(variable.getName().c_str());
} else if (variable.getType().isIntegerType()) {
z3Variable = context.int_const(variable.getName().c_str());
} else if (variable.getType().isBitVectorType()) {
z3Variable = context.bv_const(variable.getName().c_str(), variable.getType().getWidth());
} else if (variable.getType().isRationalType()) {
z3Variable = context.real_const(variable.getName().c_str());
} else {
STORM_LOG_THROW(false, storm::exceptions::InvalidTypeException, "Encountered variable '" << variable.getName() << "' with unknown type while trying to create solver variables.");
}
variableToExpressionMapping.insert(std::make_pair(variable, z3Variable));
declarationToVariableMapping.insert(std::make_pair(z3Variable.decl(), variable));
return z3Variable;
}
#endif
} // namespace adapters
} // namespace storm

289
src/adapters/Z3ExpressionAdapter.h

@ -2,20 +2,17 @@
#define STORM_ADAPTERS_Z3EXPRESSIONADAPTER_H_
#include <unordered_map>
#include <vector>
#include "storm-config.h"
// Include the headers of Z3 only if it is available.
#ifdef STORM_HAVE_Z3
#include "z3++.h"
#include "z3.h"
#endif
#include "storm-config.h"
#include "src/storage/expressions/Expressions.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/utility/macros.h"
#include "src/exceptions/ExpressionEvaluationException.h"
#include "src/exceptions/InvalidTypeException.h"
#include "src/exceptions/NotImplementedException.h"
#include "src/storage/expressions/Variable.h"
#include "src/storage/expressions/ExpressionVisitor.h"
namespace storm {
namespace adapters {
@ -30,275 +27,51 @@ namespace storm {
* @param context A reference to the Z3 context over which to build the expressions. The lifetime of the
* context needs to be guaranteed as long as the instance of this adapter is used.
*/
Z3ExpressionAdapter(storm::expressions::ExpressionManager& manager, z3::context& context) : manager(manager), context(context), additionalAssertions(), variableToExpressionMapping() {
// Intentionally left empty.
}
Z3ExpressionAdapter(storm::expressions::ExpressionManager& manager, z3::context& context);
/*!
* Translates the given expression to an equivalent expression for Z3.
*
* @param expression The expression to translate.
* @return An equivalent expression for Z3.
*/
z3::expr translateExpression(storm::expressions::Expression const& expression) {
STORM_LOG_ASSERT(expression.getManager() == this->manager, "Invalid expression for solver.");
z3::expr result = boost::any_cast<z3::expr>(expression.getBaseExpression().accept(*this));
for (z3::expr const& assertion : additionalAssertions) {
result = result && assertion;
}
additionalAssertions.clear();
return result;
}
z3::expr translateExpression(storm::expressions::Expression const& expression);
/*!
* Translates the given variable to an equivalent expression for Z3.
*
* @param variable The variable to translate.
* @return An equivalent expression for Z3.
*/
z3::expr translateExpression(storm::expressions::Variable const& variable) {
STORM_LOG_ASSERT(variable.getManager() == this->manager, "Invalid expression for solver.");
auto const& variableExpressionPair = variableToExpressionMapping.find(variable);
if (variableExpressionPair == variableToExpressionMapping.end()) {
return createVariable(variable);
}
return variableExpressionPair->second;
}
z3::expr translateExpression(storm::expressions::Variable const& variable);
storm::expressions::Expression translateExpression(z3::expr const& expr);
/*!
* Finds the counterpart to the given z3 variable declaration.
*
* @param z3Declaration The declaration for which to find the equivalent.
* @return The equivalent counterpart.
*/
storm::expressions::Variable const& getVariable(z3::func_decl z3Declaration) {
auto const& declarationVariablePair = declarationToVariableMapping.find(z3Declaration);
STORM_LOG_ASSERT(declarationVariablePair != declarationToVariableMapping.end(), "Unable to find declaration.");
return declarationVariablePair->second;
}
storm::expressions::Expression translateExpression(z3::expr const& expr) {
if (expr.is_app()) {
switch (expr.decl().decl_kind()) {
case Z3_OP_TRUE:
return manager.boolean(true);
case Z3_OP_FALSE:
return manager.boolean(false);
case Z3_OP_EQ:
return this->translateExpression(expr.arg(0)) == this->translateExpression(expr.arg(1));
case Z3_OP_ITE:
return storm::expressions::ite(this->translateExpression(expr.arg(0)), this->translateExpression(expr.arg(1)), this->translateExpression(expr.arg(2)));
case Z3_OP_AND: {
unsigned args = expr.num_args();
STORM_LOG_THROW(args != 0, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. 0-ary AND is assumed to be an error.");
if (args == 1) {
return this->translateExpression(expr.arg(0));
} else {
storm::expressions::Expression retVal = this->translateExpression(expr.arg(0));
for (unsigned i = 1; i < args; i++) {
retVal = retVal && this->translateExpression(expr.arg(i));
}
return retVal;
}
}
case Z3_OP_OR: {
unsigned args = expr.num_args();
STORM_LOG_THROW(args != 0, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. 0-ary OR is assumed to be an error.");
if (args == 1) {
return this->translateExpression(expr.arg(0));
} else {
storm::expressions::Expression retVal = this->translateExpression(expr.arg(0));
for (unsigned i = 1; i < args; i++) {
retVal = retVal || this->translateExpression(expr.arg(i));
}
return retVal;
}
}
case Z3_OP_IFF:
return storm::expressions::iff(this->translateExpression(expr.arg(0)), this->translateExpression(expr.arg(1)));
case Z3_OP_XOR:
return this->translateExpression(expr.arg(0)) ^ this->translateExpression(expr.arg(1));
case Z3_OP_NOT:
return !this->translateExpression(expr.arg(0));
case Z3_OP_IMPLIES:
return storm::expressions::implies(this->translateExpression(expr.arg(0)), this->translateExpression(expr.arg(1)));
case Z3_OP_LE:
return this->translateExpression(expr.arg(0)) <= this->translateExpression(expr.arg(1));
case Z3_OP_GE:
return this->translateExpression(expr.arg(0)) >= this->translateExpression(expr.arg(1));
case Z3_OP_LT:
return this->translateExpression(expr.arg(0)) < this->translateExpression(expr.arg(1));
case Z3_OP_GT:
return this->translateExpression(expr.arg(0)) > this->translateExpression(expr.arg(1));
case Z3_OP_ADD:
return this->translateExpression(expr.arg(0)) + this->translateExpression(expr.arg(1));
case Z3_OP_SUB:
return this->translateExpression(expr.arg(0)) - this->translateExpression(expr.arg(1));
case Z3_OP_UMINUS:
return -this->translateExpression(expr.arg(0));
case Z3_OP_MUL:
return this->translateExpression(expr.arg(0)) * this->translateExpression(expr.arg(1));
case Z3_OP_DIV:
return this->translateExpression(expr.arg(0)) / this->translateExpression(expr.arg(1));
case Z3_OP_IDIV:
return this->translateExpression(expr.arg(0)) / this->translateExpression(expr.arg(1));
case Z3_OP_ANUM:
// Arithmetic numeral.
if (expr.is_int() && expr.is_const()) {
long long value;
if (Z3_get_numeral_int64(expr.ctx(), expr, &value)) {
return manager.integer(value);
} else {
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Expression is constant integer and value does not fit into 64-bit integer.");
}
} else if (expr.is_real() && expr.is_const()) {
long long num;
long long den;
if (Z3_get_numeral_rational_int64(expr.ctx(), expr, &num, &den)) {
return manager.rational(static_cast<double>(num) / static_cast<double>(den));
} else {
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Expression is constant real and value does not fit into a fraction with 64-bit integer numerator and denominator.");
}
}
case Z3_OP_UNINTERPRETED:
// Currently, we only support uninterpreted constant functions.
STORM_LOG_THROW(expr.is_const(), storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Encountered non-constant uninterpreted function.");
return manager.getVariable(expr.decl().name().str()).getExpression();
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Encountered unhandled Z3_decl_kind " << expr.decl().kind() <<".");
break;
}
} else {
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Failed to convert Z3 expression. Encountered unknown expression type.");
}
}
storm::expressions::Variable const& getVariable(z3::func_decl z3Declaration);
virtual boost::any visit(storm::expressions::BinaryBooleanFunctionExpression const& expression) override {
z3::expr leftResult = boost::any_cast<z3::expr>(expression.getFirstOperand()->accept(*this));
z3::expr rightResult = boost::any_cast<z3::expr>(expression.getSecondOperand()->accept(*this));
switch(expression.getOperatorType()) {
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::And:
return leftResult && rightResult;
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Or:
return leftResult || rightResult;
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Xor:
return z3::expr(context, Z3_mk_xor(context, leftResult, rightResult));
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Implies:
return z3::expr(context, Z3_mk_implies(context, leftResult, rightResult));
case storm::expressions::BinaryBooleanFunctionExpression::OperatorType::Iff:
return z3::expr(context, Z3_mk_iff(context, leftResult, rightResult));
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown boolean binary operator '" << static_cast<int>(expression.getOperatorType()) << "' in expression " << expression << ".");
}
}
virtual boost::any visit(storm::expressions::BinaryBooleanFunctionExpression const& expression) override;
virtual boost::any visit(storm::expressions::BinaryNumericalFunctionExpression const& expression) override {
z3::expr leftResult = boost::any_cast<z3::expr>(expression.getFirstOperand()->accept(*this));
z3::expr rightResult = boost::any_cast<z3::expr>(expression.getSecondOperand()->accept(*this));
switch(expression.getOperatorType()) {
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Plus:
return leftResult + rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Minus:
return leftResult - rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Times:
return leftResult * rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Divide:
return leftResult / rightResult;
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Min:
return ite(leftResult <= rightResult, leftResult, rightResult);
case storm::expressions::BinaryNumericalFunctionExpression::OperatorType::Max:
return ite(leftResult >= rightResult, leftResult, rightResult);
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown numerical binary operator '" << static_cast<int>(expression.getOperatorType()) << "' in expression " << expression << ".");
}
}
virtual boost::any visit(storm::expressions::BinaryNumericalFunctionExpression const& expression) override;
virtual boost::any visit(storm::expressions::BinaryRelationExpression const& expression) override {
z3::expr leftResult = boost::any_cast<z3::expr>(expression.getFirstOperand()->accept(*this));
z3::expr rightResult = boost::any_cast<z3::expr>(expression.getSecondOperand()->accept(*this));
switch(expression.getRelationType()) {
case storm::expressions::BinaryRelationExpression::RelationType::Equal:
return leftResult == rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::NotEqual:
return leftResult != rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::Less:
return leftResult < rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::LessOrEqual:
return leftResult <= rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::Greater:
return leftResult > rightResult;
case storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual:
return leftResult >= rightResult;
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown boolean binary operator '" << static_cast<int>(expression.getRelationType()) << "' in expression " << expression << ".");
}
}
virtual boost::any visit(storm::expressions::BinaryRelationExpression const& expression) override;
virtual boost::any visit(storm::expressions::BooleanLiteralExpression const& expression) override {
return context.bool_val(expression.getValue());
}
virtual boost::any visit(storm::expressions::BooleanLiteralExpression const& expression) override;
virtual boost::any visit(storm::expressions::DoubleLiteralExpression const& expression) override {
std::stringstream fractionStream;
fractionStream << expression.getValue();
return context.real_val(fractionStream.str().c_str());
}
virtual boost::any visit(storm::expressions::DoubleLiteralExpression const& expression) override;
virtual boost::any visit(storm::expressions::IntegerLiteralExpression const& expression) override {
return context.int_val(static_cast<int>(expression.getValue()));
}
virtual boost::any visit(storm::expressions::IntegerLiteralExpression const& expression) override;
virtual boost::any visit(storm::expressions::UnaryBooleanFunctionExpression const& expression) override {
z3::expr childResult = boost::any_cast<z3::expr>(expression.getOperand()->accept(*this));
switch (expression.getOperatorType()) {
case storm::expressions::UnaryBooleanFunctionExpression::OperatorType::Not:
return !childResult;
default:
STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown boolean binary operator '" << static_cast<int>(expression.getOperatorType()) << "' in expression " << expression << ".");
}
}
virtual boost::any visit(storm::expressions::UnaryBooleanFunctionExpression const& expression) override;
virtual boost::any visit(storm::expressions::UnaryNumericalFunctionExpression const& expression) override {
z3::expr childResult = boost::any_cast<z3::expr>(expression.getOperand()->accept(*this));
switch(expression.getOperatorType()) {
case storm::expressions::UnaryNumericalFunctionExpression::OperatorType::Minus:
return 0 - childResult;
case storm::expressions::UnaryNumericalFunctionExpression::OperatorType::Floor: {
storm::expressions::Variable freshAuxiliaryVariable = manager.declareFreshVariable(manager.getIntegerType(), true);
z3::expr floorVariable = context.int_const(freshAuxiliaryVariable.getName().c_str());
additionalAssertions.push_back(z3::expr(context, Z3_mk_int2real(context, floorVariable)) <= childResult && childResult < (z3::expr(context, Z3_mk_int2real(context, floorVariable)) + 1));
return floorVariable;
}
case storm::expressions::UnaryNumericalFunctionExpression::OperatorType::Ceil:{
storm::expressions::Variable freshAuxiliaryVariable = manager.declareFreshVariable(manager.getIntegerType(), true);
z3::expr ceilVariable = context.int_const(freshAuxiliaryVariable.getName().c_str());
additionalAssertions.push_back(z3::expr(context, Z3_mk_int2real(context, ceilVariable)) - 1 <= childResult && childResult < z3::expr(context, Z3_mk_int2real(context, ceilVariable)));
return ceilVariable;
}
default: STORM_LOG_THROW(false, storm::exceptions::ExpressionEvaluationException, "Cannot evaluate expression: unknown numerical unary operator '" << static_cast<int>(expression.getOperatorType()) << "'.");
}
}
virtual boost::any visit(storm::expressions::UnaryNumericalFunctionExpression const& expression) override;
virtual boost::any visit(storm::expressions::IfThenElseExpression const& expression) override {
z3::expr conditionResult = boost::any_cast<z3::expr>(expression.getCondition()->accept(*this));
z3::expr thenResult = boost::any_cast<z3::expr>(expression.getThenExpression()->accept(*this));
z3::expr elseResult = boost::any_cast<z3::expr>(expression.getElseExpression()->accept(*this));
return z3::expr(context, Z3_mk_ite(context, conditionResult, thenResult, elseResult));
}
virtual boost::any visit(storm::expressions::IfThenElseExpression const& expression) override;
virtual boost::any visit(storm::expressions::VariableExpression const& expression) override {
return this->translateExpression(expression.getVariable());
}
virtual boost::any visit(storm::expressions::VariableExpression const& expression) override;
private:
/*!
@ -306,25 +79,7 @@ namespace storm {
*
* @param variable The variable for which to create a Z3 counterpart.
*/
z3::expr createVariable(storm::expressions::Variable const& variable) {
z3::expr z3Variable(context);
if (variable.getType().isBooleanType()) {
z3Variable = context.bool_const(variable.getName().c_str());
} else if (variable.getType().isIntegerType()) {
z3Variable = context.int_const(variable.getName().c_str());
} else if (variable.getType().isBitVectorType()) {
z3Variable = context.bv_const(variable.getName().c_str(), variable.getType().getWidth());
} else if (variable.getType().isRationalType()) {
z3Variable = context.real_const(variable.getName().c_str());
} else {
STORM_LOG_THROW(false, storm::exceptions::InvalidTypeException, "Encountered variable '" << variable.getName() << "' with unknown type while trying to create solver variables.");
}
variableToExpressionMapping.insert(std::make_pair(variable, z3Variable));
declarationToVariableMapping.insert(std::make_pair(z3Variable.decl(), variable));
return z3Variable;
}
z3::expr createVariable(storm::expressions::Variable const& variable);
// The manager that can be used to build expressions.
storm::expressions::ExpressionManager& manager;
@ -333,7 +88,7 @@ namespace storm {
// A vector of assertions that need to be kept separate, because they were only implicitly part of an
// assertion that was added.
std::vector<z3::expr> additionalAssertions;
std::vector<z3::expr> additionalAssertions;
// A mapping from variables to their Z3 equivalent.
std::unordered_map<storm::expressions::Variable, z3::expr> variableToExpressionMapping;

3
src/models/sparse/Model.h

@ -11,6 +11,8 @@
#include "src/storage/BitVector.h"
#include "src/storage/SparseMatrix.h"
#include "src/utility/OsDetection.h"
// Forward declarations
namespace storm {
namespace models {
@ -19,6 +21,7 @@ namespace storm {
// The type used for storing a set of labels.
typedef boost::container::flat_set<uint_fast64_t> LabelSet;
/*!
* Base class for all sparse models.
*/

4
src/models/sparse/StateLabeling.cpp

@ -1,4 +1,8 @@
#include "src/models/sparse/StateLabeling.h"
#include "src/storage/BitVector.h"
#include "src/exceptions/OutOfRangeException.h"
#include "src/exceptions/InvalidArgumentException.h"
namespace storm {
namespace models {

7
src/models/sparse/StateLabeling.h

@ -6,17 +6,16 @@
#include <ostream>
#include "src/storage/sparse/StateType.h"
#include "src/storage/BitVector.h"
#include "src/exceptions/OutOfRangeException.h"
#include "src/exceptions/InvalidArgumentException.h"
#include "src/storage/BitVector.h"
#include "src/utility/macros.h"
#include "src/utility/OsDetection.h"
namespace storm {
namespace models {
namespace sparse {
/*!
* This class manages the labeling of the state space with a number of (atomic) labels.
*/

7
src/parser/PrismParser.h

@ -9,12 +9,17 @@
#include "src/parser/SpiritParserDefinitions.h"
#include "src/parser/ExpressionParser.h"
#include "src/storage/prism/Program.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/Expressions.h"
#include "src/utility/macros.h"
#include "src/exceptions/WrongFormatException.h"
namespace storm {
namespace expressions {
class ExpressionManager;
}
}
namespace storm {
namespace parser {
// A class that stores information about the parsed program.

3
src/solver/GlpkLpSolver.cpp

@ -8,6 +8,9 @@
#include "src/settings/SettingsManager.h"
#include "src/utility/macros.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/exceptions/InvalidAccessException.h"
#include "src/exceptions/InvalidStateException.h"

1
src/solver/GlpkLpSolver.h

@ -1,6 +1,7 @@
#ifndef STORM_SOLVER_GLPKLPSOLVER_H_
#define STORM_SOLVER_GLPKLPSOLVER_H_
#include <map>
#include "src/solver/LpSolver.h"
#include "src/exceptions/NotImplementedException.h"

3
src/solver/GurobiLpSolver.cpp

@ -7,6 +7,9 @@
#include "src/settings/SettingsManager.h"
#include "src/utility/macros.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/exceptions/InvalidStateException.h"
#include "src/exceptions/InvalidAccessException.h"

1
src/solver/GurobiLpSolver.h

@ -1,6 +1,7 @@
#ifndef STORM_SOLVER_GUROBILPSOLVER
#define STORM_SOLVER_GUROBILPSOLVER
#include <map>
#include "src/solver/LpSolver.h"
#include "src/exceptions/NotImplementedException.h"

23
src/solver/LpSolver.cpp

@ -0,0 +1,23 @@
#include "LpSolver.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/ExpressionManager.h"
namespace storm {
namespace solver {
LpSolver::LpSolver() : manager(new storm::expressions::ExpressionManager()), currentModelHasBeenOptimized(false), modelSense(ModelSense::Minimize) {
// Intentionally left empty.
}
LpSolver::LpSolver(ModelSense const& modelSense) : manager(new storm::expressions::ExpressionManager()), currentModelHasBeenOptimized(false), modelSense(modelSense) {
// Intentionally left empty.
}
storm::expressions::Expression LpSolver::getConstant(double value) const {
return manager->rational(value);
}
}
}

23
src/solver/LpSolver.h

@ -4,11 +4,13 @@
#include <string>
#include <vector>
#include <cstdint>
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/ExpressionManager.h"
namespace storm {
namespace expressions {
class ExpressionManager;
class Variable;
class Expression;
}
namespace solver {
/*!
* An interface that captures the functionality of an LP solver.
@ -24,19 +26,14 @@ namespace storm {
/*!
* Creates an empty LP solver. By default the objective function is assumed to be minimized.
*/
LpSolver() : manager(new storm::expressions::ExpressionManager()), currentModelHasBeenOptimized(false), modelSense(ModelSense::Minimize) {
// Intentionally left empty.
}
LpSolver();
/*!
* Creates an empty LP solver with the given model sense.
*
* @param modelSense A value indicating whether the objective function of this model is to be minimized or
* maximized.
*/
LpSolver(ModelSense const& modelSense) : manager(new storm::expressions::ExpressionManager()), currentModelHasBeenOptimized(false), modelSense(modelSense) {
// Intentionally left empty.
}
LpSolver(ModelSense const& modelSense);
/*!
* Registers an upper- and lower-bounded continuous variable, i.e. a variable that may take all real values
@ -139,9 +136,7 @@ namespace storm {
* @param value The value of the constant.
* @return The resulting expression.
*/
storm::expressions::Expression getConstant(double value) const {
return manager->rational(value);
}
storm::expressions::Expression getConstant(double value) const;
/*!
* Updates the model to make the variables that have been declared since the last call to <code>update</code>

2
src/solver/SymbolicGameSolver.h

@ -1,6 +1,8 @@
#ifndef STORM_SOLVER_SYMBOLICGAMESOLVER_H_
#define STORM_SOLVER_SYMBOLICGAMESOLVER_H_
#include <set>
#include <vector>
#include "src/storage/expressions/Variable.h"
#include "src/storage/dd/Bdd.h"

1
src/solver/SymbolicLinearEquationSolver.h

@ -3,6 +3,7 @@
#include <memory>
#include <set>
#include <vector>
#include <boost/variant.hpp>
#include "src/storage/expressions/Variable.h"

1
src/solver/Z3SmtSolver.cpp

@ -2,6 +2,7 @@
#include "src/utility/macros.h"
#include "src/exceptions/NotSupportedException.h"
#include "src/exceptions/InvalidStateException.h"
#include "src/exceptions/InvalidArgumentException.h"
namespace storm {
namespace solver {

4
src/solver/Z3SmtSolver.h

@ -46,7 +46,7 @@ namespace storm {
virtual void reset() override;
virtual void add(storm::expressions::Expression const& assertion) override;
virtual CheckResult check() override;
virtual CheckResult checkWithAssumptions(std::set<storm::expressions::Expression> const& assumptions) override;
@ -57,7 +57,7 @@ namespace storm {
virtual storm::expressions::SimpleValuation getModelAsValuation() override;
virtual std::shared_ptr<SmtSolver::ModelReference> getModel() override;
virtual std::shared_ptr<SmtSolver::ModelReference> getModel() override;
virtual std::vector<storm::expressions::SimpleValuation> allSat(std::vector<storm::expressions::Variable> const& important) override;

1
src/storage/dd/CuddDdForwardIterator.cpp

@ -2,6 +2,7 @@
#include "src/storage/dd/CuddDdManager.h"
#include "src/storage/dd/DdMetaVariable.h"
#include "src/utility/macros.h"
#include "src/storage/expressions/ExpressionManager.h"
namespace storm {
namespace dd {

1
src/storage/dd/CuddDdManager.cpp

@ -6,6 +6,7 @@
#include "src/utility/macros.h"
#include "src/exceptions/InvalidArgumentException.h"
#include "src/settings/SettingsManager.h"
#include "src/storage/expressions/ExpressionManager.h"
namespace storm {
namespace dd {

7
src/storage/dd/CuddDdManager.h

@ -6,13 +6,18 @@
#include "src/storage/dd/DdManager.h"
#include "src/storage/dd/CuddDdMetaVariable.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/expressions/Variable.h"
#include "src/utility/OsDetection.h"
// Include the C++-interface of CUDD.
#include "cuddObj.hh"
namespace storm {
namespace expressions {
class Variable;
}
}
namespace storm {
namespace dd {
template<>

2
src/storage/dd/CuddDdMetaVariable.h

@ -11,7 +11,7 @@
#include "src/storage/dd/CuddAdd.h"
#include "src/storage/dd/DdMetaVariable.h"
#include "src/storage/dd/CuddDdForwardIterator.h"
#include "src/storage/expressions/Expression.h"
namespace storm {
namespace dd {

9
src/storage/expressions/BaseExpression.h

@ -8,18 +8,17 @@
#include <iostream>
#include "src/storage/expressions/Type.h"
#include "src/storage/expressions/Valuation.h"
#include "src/storage/expressions/ExpressionVisitor.h"
#include "src/storage/expressions/OperatorType.h"
#include "src/exceptions/InvalidArgumentException.h"
#include "src/utility/OsDetection.h"
#include <boost/any.hpp>
namespace storm {
namespace expressions {
// Forward-declare expression manager.
class ExpressionManager;
class Variable;
class Valuation;
class ExpressionVisitor;
enum struct OperatorType;
/*!
* The base class of all expression classes.
*/

1
src/storage/expressions/BinaryBooleanFunctionExpression.cpp

@ -1,6 +1,7 @@
#include "src/storage/expressions/BinaryBooleanFunctionExpression.h"
#include "src/storage/expressions/BooleanLiteralExpression.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/expressions/ExpressionVisitor.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidTypeException.h"

2
src/storage/expressions/BinaryNumericalFunctionExpression.cpp

@ -4,10 +4,12 @@
#include "src/storage/expressions/BinaryNumericalFunctionExpression.h"
#include "src/storage/expressions/IntegerLiteralExpression.h"
#include "src/storage/expressions/DoubleLiteralExpression.h"
#include "src/storage/expressions/ExpressionVisitor.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidTypeException.h"
#include "src/exceptions/InvalidStateException.h"
namespace storm {
namespace expressions {
BinaryNumericalFunctionExpression::BinaryNumericalFunctionExpression(ExpressionManager const& manager, Type const& type, std::shared_ptr<BaseExpression const> const& firstOperand, std::shared_ptr<BaseExpression const> const& secondOperand, OperatorType operatorType) : BinaryExpression(manager, type, firstOperand, secondOperand), operatorType(operatorType) {

1
src/storage/expressions/BinaryRelationExpression.cpp

@ -5,6 +5,7 @@
#include "src/storage/expressions/BooleanLiteralExpression.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidTypeException.h"
#include "src/storage/expressions/ExpressionVisitor.h"
namespace storm {
namespace expressions {

1
src/storage/expressions/BooleanLiteralExpression.cpp

@ -1,5 +1,6 @@
#include "src/storage/expressions/BooleanLiteralExpression.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/expressions/ExpressionVisitor.h"
namespace storm {
namespace expressions {

1
src/storage/expressions/DoubleLiteralExpression.cpp

@ -1,5 +1,6 @@
#include "src/storage/expressions/DoubleLiteralExpression.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/expressions/ExpressionVisitor.h"
namespace storm {
namespace expressions {

1
src/storage/expressions/Expression.cpp

@ -7,6 +7,7 @@
#include "src/storage/expressions/LinearityCheckVisitor.h"
#include "src/storage/expressions/Expressions.h"
#include "src/exceptions/InvalidTypeException.h"
#include "src/exceptions/InvalidArgumentException.h"
#include "src/utility/macros.h"
namespace storm {

25
src/storage/expressions/Expression.h

@ -5,9 +5,7 @@
#include <map>
#include <unordered_map>
#include "src/storage/expressions/SimpleValuation.h"
#include "src/storage/expressions/BaseExpression.h"
#include "src/storage/expressions/ExpressionVisitor.h"
#include "src/utility/OsDetection.h"
namespace storm {
@ -15,6 +13,7 @@ namespace storm {
// Foward-declare expression manager class.
class ExpressionManager;
class Variable;
class ExpressionVisitor;
class Expression {
public:
@ -71,18 +70,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.
*/
Expression substitute(std::map<Variable, Expression> const& variableToExpressionMap) const;
Expression substitute(std::map<Variable, Expression> const& variableToExpressionMap) const;
/*!
* Substitutes all occurrences of the variables according to the given map. Note that this substitution is
* done simultaneously, i.e., variables appearing in the expressions that were "plugged in" are not
* substituted.
*
* @param variableToExpressionMap A mapping from variables 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<Variable, Expression> const& variableToExpressionMap) const;
/*!
* Substitutes all occurrences of the variables according to the given map. Note that this substitution is
* done simultaneously, i.e., variables appearing in the expressions that were "plugged in" are not
* substituted.
*
* @param variableToExpressionMap A mapping from variables 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<Variable, Expression> const& variableToExpressionMap) const;
/*!
* Evaluates the expression under the valuation of variables given by the valuation and returns the

1
src/storage/expressions/ExpressionManager.cpp

@ -4,6 +4,7 @@
#include "src/storage/expressions/Variable.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidStateException.h"
#include "src/exceptions/InvalidArgumentException.h"
namespace storm {
namespace expressions {

1
src/storage/expressions/IfThenElseExpression.cpp

@ -1,6 +1,7 @@
#include "src/storage/expressions/IfThenElseExpression.h"
#include "src/utility/macros.h"
#include "ExpressionVisitor.h"
#include "src/exceptions/InvalidAccessException.h"
namespace storm {

2
src/storage/expressions/IntegerLiteralExpression.cpp

@ -1,4 +1,6 @@
#include "src/storage/expressions/IntegerLiteralExpression.h"
#include "ExpressionVisitor.h"
#include "src/storage/expressions/ExpressionManager.h"
namespace storm {

1
src/storage/expressions/LinearCoefficientVisitor.cpp

@ -1,6 +1,7 @@
#include "src/storage/expressions/LinearCoefficientVisitor.h"
#include "src/storage/expressions/Expressions.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidArgumentException.h"

1
src/storage/expressions/ToRationalFunctionVisitor.cpp

@ -3,6 +3,7 @@
#include <sstream>
#include "src/utility/macros.h"
#include "src/exceptions/InvalidArgumentException.h"
#ifdef STORM_HAVE_CARL

1
src/storage/expressions/UnaryBooleanFunctionExpression.cpp

@ -1,5 +1,6 @@
#include "src/storage/expressions/UnaryBooleanFunctionExpression.h"
#include "src/storage/expressions/BooleanLiteralExpression.h"
#include "ExpressionVisitor.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidTypeException.h"

1
src/storage/expressions/UnaryNumericalFunctionExpression.cpp

@ -5,6 +5,7 @@
#include "src/storage/expressions/UnaryNumericalFunctionExpression.h"
#include "src/storage/expressions/IntegerLiteralExpression.h"
#include "src/storage/expressions/DoubleLiteralExpression.h"
#include "ExpressionVisitor.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidTypeException.h"

2
src/storage/expressions/Variable.cpp

@ -1,5 +1,6 @@
#include "src/storage/expressions/Variable.h"
#include "src/storage/expressions/ExpressionManager.h"
#include <cassert>
namespace storm {
namespace expressions {
@ -40,6 +41,7 @@ namespace storm {
}
ExpressionManager const& Variable::getManager() const {
assert(manager != nullptr);
return *manager;
}

5
src/storage/expressions/Variable.h

@ -3,14 +3,15 @@
#include <cstdint>
#include <memory>
#include <functional>
#include "src/utility/OsDetection.h"
#include "src/storage/expressions/Type.h"
#include "src/storage/expressions/Expression.h"
namespace storm {
namespace expressions {
class ExpressionManager;
class Expression;
class Type;
// This class captures a simple variable.
class Variable {

2
src/storage/expressions/VariableExpression.cpp

@ -1,4 +1,6 @@
#include "src/storage/expressions/VariableExpression.h"
#include "Valuation.h"
#include "ExpressionVisitor.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidTypeException.h"

1
src/storage/prism/InitialConstruct.cpp

@ -1,4 +1,5 @@
#include "src/storage/prism/InitialConstruct.h"
#include "src/storage/expressions/Variable.h"
namespace storm {
namespace prism {

11
src/storage/prism/InitialConstruct.h

@ -2,12 +2,21 @@
#define STORM_STORAGE_PRISM_INITIALCONSTRUCT_H_
#include <string>
#include <map>
#include "src/storage/prism/LocatedInformation.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/Variable.h"
#include "src/utility/OsDetection.h"
namespace storm {
namespace expressions {
class Variable;
}
}
namespace storm {
namespace prism {
class InitialConstruct : public LocatedInformation {

1
src/storage/prism/Label.cpp

@ -1,4 +1,5 @@
#include "src/storage/prism/Label.h"
#include "src/storage/expressions/Variable.h"
namespace storm {
namespace prism {

9
src/storage/prism/Label.h

@ -5,9 +5,16 @@
#include "src/storage/prism/LocatedInformation.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/Variable.h"
#include "src/utility/OsDetection.h"
namespace storm {
namespace storage {
namespace expressions {
class Variable;
}
}
}
namespace storm {
namespace prism {
class Label : public LocatedInformation {

1
src/storage/prism/Module.h

@ -11,7 +11,6 @@
#include "src/storage/prism/BooleanVariable.h"
#include "src/storage/prism/IntegerVariable.h"
#include "src/storage/prism/Command.h"
#include "src/storage/expressions/VariableExpression.h"
#include "src/utility/OsDetection.h"
namespace storm {

1
src/storage/prism/Program.h

@ -6,7 +6,6 @@
#include <set>
#include <boost/container/flat_set.hpp>
#include "src/storage/expressions/Expression.h"
#include "src/storage/prism/Constant.h"
#include "src/storage/prism/Formula.h"
#include "src/storage/prism/Label.h"

1
src/storage/prism/StateReward.cpp

@ -1,4 +1,5 @@
#include "src/storage/prism/StateReward.h"
#include "src/storage/expressions/Variable.h"
namespace storm {
namespace prism {

10
src/storage/prism/StateReward.h

@ -5,9 +5,17 @@
#include "src/storage/prism/LocatedInformation.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/Variable.h"
#include "src/utility/OsDetection.h"
namespace storm {
namespace storage {
namespace expressions {
class Variable;
}
}
}
namespace storm {
namespace prism {
class StateReward : public LocatedInformation {

1
src/storage/prism/TransitionReward.cpp

@ -1,4 +1,5 @@
#include "src/storage/prism/TransitionReward.h"
#include "src/storage/expressions/Variable.h"
namespace storm {
namespace prism {

11
src/storage/prism/TransitionReward.h

@ -5,9 +5,18 @@
#include "src/storage/prism/LocatedInformation.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/expressions/Variable.h"
#include "src/utility/OsDetection.h"
namespace storm {
namespace storage {
namespace expressions {
class Variable;
}
}
}
namespace storm {
namespace prism {
class TransitionReward : public LocatedInformation {

3
src/utility/prism.cpp

@ -1,4 +1,7 @@
#include "src/utility/prism.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/prism/Program.h"
namespace storm {
namespace utility {

14
src/utility/prism.h

@ -2,15 +2,25 @@
#define STORM_UTILITY_PRISM_H_
#include <memory>
#include <map>
#include <boost/algorithm/string.hpp>
#include <boost/container/flat_set.hpp>
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/prism/Program.h"
#include "src/utility/OsDetection.h"
#include "src/utility/macros.h"
#include "src/exceptions/InvalidArgumentException.h"
namespace storm {
namespace expressions {
class Variable;
class Expression;
}
namespace prism {
class Program;
}
namespace utility {
namespace prism {
// A structure holding information about a particular choice.

1
test/functional/adapter/Z3ExpressionAdapterTest.cpp

@ -148,7 +148,6 @@ TEST(Z3ExpressionAdapter, StormToZ3FloorCeil) {
TEST(Z3ExpressionAdapter, Z3ToStormBasic) {
z3::context ctx;
unsigned args = 2;
std::shared_ptr<storm::expressions::ExpressionManager> manager(new storm::expressions::ExpressionManager());
manager->declareBooleanVariable("x");

2
test/functional/builder/die.pm

@ -29,4 +29,4 @@ label "three" = s=7&d=3;
label "four" = s=7&d=4;
label "five" = s=7&d=5;
label "six" = s=7&d=6;
label "done" = s=7;
label "done" = s=7;

3
test/functional/solver/GlpkLpSolverTest.cpp

@ -2,11 +2,14 @@
#include "storm-config.h"
#ifdef STORM_HAVE_GLPK
#include "src/storage/expressions/Variable.h"
#include "src/solver/GlpkLpSolver.h"
#include "src/exceptions/InvalidStateException.h"
#include "src/exceptions/InvalidAccessException.h"
#include "src/settings/SettingsManager.h"
#include "src/storage/expressions/Expressions.h"
TEST(GlpkLpSolver, LPOptimizeMax) {
storm::solver::GlpkLpSolver solver(storm::solver::LpSolver::ModelSense::Maximize);
storm::expressions::Variable x;

2
test/functional/solver/GurobiLpSolverTest.cpp

@ -6,6 +6,8 @@
#include "src/exceptions/InvalidStateException.h"
#include "src/exceptions/InvalidAccessException.h"
#include "src/settings/SettingsManager.h"
#include "src/storage/expressions/Variable.h"
#include "src/storage/expressions/Expressions.h"
TEST(GurobiLpSolver, LPOptimizeMax) {
storm::solver::GurobiLpSolver solver(storm::solver::LpSolver::ModelSense::Maximize);

1
test/functional/solver/Z3SmtSolverTest.cpp

@ -162,7 +162,6 @@ TEST(Z3SmtSolver, AllSat) {
std::shared_ptr<storm::expressions::ExpressionManager> manager(new storm::expressions::ExpressionManager());
storm::solver::Z3SmtSolver s(*manager);
storm::solver::SmtSolver::CheckResult result = storm::solver::SmtSolver::CheckResult::Unknown;
storm::expressions::Variable a = manager->declareIntegerVariable("a");
storm::expressions::Variable b = manager->declareIntegerVariable("b");

1
test/functional/storm-functional-tests.cpp

@ -8,6 +8,7 @@
#include "log4cplus/consoleappender.h"
#include "log4cplus/fileappender.h"
#include "storm-config.h"
#include "src/settings/SettingsManager.h"
log4cplus::Logger logger;

Loading…
Cancel
Save