You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
312 lines
14 KiB
312 lines
14 KiB
#ifndef STORM_STORAGE_EXPRESSIONS_EXPRESSION_H_
|
|
#define STORM_STORAGE_EXPRESSIONS_EXPRESSION_H_
|
|
|
|
#include <memory>
|
|
#include <map>
|
|
#include <unordered_map>
|
|
|
|
#include "src/storage/expressions/BaseExpression.h"
|
|
#include "src/storage/expressions/ExpressionVisitor.h"
|
|
#include "src/utility/OsDetection.h"
|
|
|
|
namespace storm {
|
|
namespace expressions {
|
|
class Expression {
|
|
public:
|
|
Expression() = default;
|
|
|
|
/*!
|
|
* Creates an expression with the given underlying base expression.
|
|
*
|
|
* @param expressionPtr A pointer to the underlying base expression.
|
|
*/
|
|
Expression(std::shared_ptr<BaseExpression const> const& expressionPtr);
|
|
|
|
// Instantiate constructors and assignments with their default implementations.
|
|
Expression(Expression const& other) = default;
|
|
Expression& operator=(Expression const& other) = default;
|
|
#ifndef WINDOWS
|
|
Expression(Expression&&) = default;
|
|
Expression& operator=(Expression&&) = default;
|
|
#endif
|
|
|
|
// Static factory methods to create atomic expression parts.
|
|
static Expression createBooleanLiteral(bool value);
|
|
static Expression createTrue();
|
|
static Expression createFalse();
|
|
static Expression createIntegerLiteral(int_fast64_t value);
|
|
static Expression createDoubleLiteral(double value);
|
|
static Expression createBooleanVariable(std::string const& variableName);
|
|
static Expression createIntegerVariable(std::string const& variableName);
|
|
static Expression createDoubleVariable(std::string const& variableName);
|
|
static Expression createUndefinedVariable(std::string const& variableName);
|
|
|
|
// Provide operator overloads to conveniently construct new expressions from other expressions.
|
|
Expression operator+(Expression const& other) const;
|
|
Expression operator-(Expression const& other) const;
|
|
Expression operator-() const;
|
|
Expression operator*(Expression const& other) const;
|
|
Expression operator/(Expression const& other) const;
|
|
Expression operator^(Expression const& other) const;
|
|
Expression operator&&(Expression const& other) const;
|
|
Expression operator||(Expression const& other) const;
|
|
Expression operator!() const;
|
|
Expression operator==(Expression const& other) const;
|
|
Expression operator!=(Expression const& other) const;
|
|
Expression operator>(Expression const& other) const;
|
|
Expression operator>=(Expression const& other) const;
|
|
Expression operator<(Expression const& other) const;
|
|
Expression operator<=(Expression const& other) const;
|
|
|
|
Expression ite(Expression const& thenExpression, Expression const& elseExpression);
|
|
Expression implies(Expression const& other) const;
|
|
Expression iff(Expression const& other) const;
|
|
|
|
Expression floor() const;
|
|
Expression ceil() const;
|
|
|
|
static Expression minimum(Expression const& lhs, Expression const& rhs);
|
|
static Expression maximum(Expression const& lhs, Expression const& rhs);
|
|
|
|
/*!
|
|
* Substitutes all occurrences of identifiers according to the given map. Note that this substitution is
|
|
* done simultaneously, i.e., identifiers appearing in the expressions that were "plugged in" are not
|
|
* substituted.
|
|
*
|
|
* @param identifierToExpressionMap A mapping from identifiers to the expression they are substituted with.
|
|
* @return An expression in which all identifiers in the key set of the mapping are replaced by the
|
|
* expression they are mapped to.
|
|
*/
|
|
Expression substitute(std::map<std::string, Expression> const& identifierToExpressionMap) const;
|
|
|
|
/*!
|
|
* Substitutes all occurrences of identifiers according to the given map. Note that this substitution is
|
|
* done simultaneously, i.e., identifiers appearing in the expressions that were "plugged in" are not
|
|
* substituted.
|
|
*
|
|
* @param identifierToExpressionMap A mapping from identifiers to the expression they are substituted with.
|
|
* @return An expression in which all identifiers in the key set of the mapping are replaced by the
|
|
* expression they are mapped to.
|
|
*/
|
|
Expression substitute(std::unordered_map<std::string, Expression> const& identifierToExpressionMap) const;
|
|
|
|
/*!
|
|
* Substitutes all occurrences of identifiers with different names given by a mapping.
|
|
*
|
|
* @param identifierToIdentifierMap A mapping from identifiers to identifiers they are substituted with.
|
|
* @return An expression in which all identifiers in the key set of the mapping are replaced by the
|
|
* identifiers they are mapped to.
|
|
*/
|
|
Expression substitute(std::map<std::string, std::string> const& identifierToIdentifierMap) const;
|
|
|
|
/*!
|
|
* Substitutes all occurrences of identifiers with different names given by a mapping.
|
|
*
|
|
* @param identifierToIdentifierMap A mapping from identifiers to identifiers they are substituted with.
|
|
* @return An expression in which all identifiers in the key set of the mapping are replaced by the
|
|
* identifiers they are mapped to.
|
|
*/
|
|
Expression substitute(std::unordered_map<std::string, std::string> const& identifierToIdentifierMap) const;
|
|
|
|
/*!
|
|
* Evaluates the expression under the valuation of variables given by the valuation and returns the
|
|
* resulting boolean value. If the return type of the expression is not a boolean an exception is thrown.
|
|
*
|
|
* @param valuation The valuation of unknowns under which to evaluate the expression.
|
|
* @return The boolean value of the expression under the given valuation.
|
|
*/
|
|
bool evaluateAsBool(Valuation const* valuation = nullptr) const;
|
|
|
|
/*!
|
|
* Evaluates the expression under the valuation of variables given by the valuation and returns the
|
|
* resulting integer value. If the return type of the expression is not an integer an exception is thrown.
|
|
*
|
|
* @param valuation The valuation of unknowns under which to evaluate the expression.
|
|
* @return The integer value of the expression under the given valuation.
|
|
*/
|
|
int_fast64_t evaluateAsInt(Valuation const* valuation = nullptr) const;
|
|
|
|
/*!
|
|
* Evaluates the expression under the valuation of variables given by the valuation and returns the
|
|
* resulting double value. If the return type of the expression is not a double an exception is thrown.
|
|
*
|
|
* @param valuation The valuation of unknowns under which to evaluate the expression.
|
|
* @return The double value of the expression under the given valuation.
|
|
*/
|
|
double evaluateAsDouble(Valuation const* valuation = nullptr) const;
|
|
|
|
/*!
|
|
* Simplifies the expression according to some basic rules.
|
|
*
|
|
* @return The simplified expression.
|
|
*/
|
|
Expression simplify();
|
|
|
|
/*!
|
|
* Retrieves the operator of a function application. This is only legal to call if the expression is
|
|
* function application.
|
|
*
|
|
* @return The operator associated with the function application.
|
|
*/
|
|
OperatorType getOperator() const;
|
|
|
|
/*!
|
|
* Checks if the expression is a function application (of any sort).
|
|
*
|
|
* @return True iff the expression is a function application.
|
|
*/
|
|
bool isFunctionApplication() const;
|
|
|
|
/*!
|
|
* Retrieves the arity of the expression.
|
|
*
|
|
* @return The arity of the expression.
|
|
*/
|
|
uint_fast64_t getArity() const;
|
|
|
|
/*!
|
|
* Retrieves the given operand from the expression.
|
|
*
|
|
* @param operandIndex The index of the operand to retrieve. This must be lower than the arity of the expression.
|
|
* @return The operand at the given index.
|
|
*/
|
|
Expression getOperand(uint_fast64_t operandIndex) const;
|
|
|
|
/*!
|
|
* Retrieves the identifier associated with this expression. This is only legal to call if the expression
|
|
* is a variable.
|
|
*
|
|
* @return The identifier associated with this expression.
|
|
*/
|
|
std::string const& getIdentifier() const;
|
|
|
|
/*!
|
|
* Retrieves whether the expression contains a variable.
|
|
*
|
|
* @return True iff the expression contains a variable.
|
|
*/
|
|
bool containsVariables() const;
|
|
|
|
/*!
|
|
* Retrieves whether the expression is a literal.
|
|
*
|
|
* @return True iff the expression is a literal.
|
|
*/
|
|
bool isLiteral() const;
|
|
|
|
/*!
|
|
* Retrieves whether the expression is a variable.
|
|
*
|
|
* @return True iff the expression is a variable.
|
|
*/
|
|
bool isVariable() const;
|
|
|
|
/*!
|
|
* Checks if the expression is equal to the boolean literal true.
|
|
*
|
|
* @return True iff the expression is equal to the boolean literal true.
|
|
*/
|
|
bool isTrue() const;
|
|
|
|
/*!
|
|
* Checks if the expression is equal to the boolean literal false.
|
|
*
|
|
* @return True iff the expression is equal to the boolean literal false.
|
|
*/
|
|
bool isFalse() const;
|
|
|
|
/*!
|
|
* Retrieves whether this expression is a relation expression, i.e., an expression that has a relation
|
|
* (equal, not equal, less, less or equal, etc.) as its top-level operator.
|
|
*
|
|
* @return True iff the expression is a relation expression.
|
|
*/
|
|
bool isRelationalExpression() const;
|
|
|
|
/*!
|
|
* Retrieves whether this expression is a linear expression.
|
|
*
|
|
* @return True iff the expression is linear.
|
|
*/
|
|
bool isLinear() const;
|
|
|
|
/*!
|
|
* Retrieves the set of all variables that appear in the expression.
|
|
*
|
|
* @return The set of all variables that appear in the expression.
|
|
*/
|
|
std::set<std::string> getVariables() const;
|
|
|
|
/*!
|
|
* Retrieves the mapping of all variables that appear in the expression to their return type.
|
|
*
|
|
* @param validate If this parameter is true, check() is called with the returnvalue before
|
|
* it is returned.
|
|
*
|
|
* @throws storm::exceptions::InvalidTypeException If a variables with the same name but different
|
|
* types occur somewhere withing the expression.
|
|
*
|
|
* @return The mapping of all variables that appear in the expression to their return type.
|
|
*/
|
|
std::map<std::string, ExpressionReturnType> getVariablesAndTypes(bool validate = true) const;
|
|
|
|
/*!
|
|
* Retrieves the base expression underlying this expression object. Note that prior to calling this, the
|
|
* expression object must be properly initialized.
|
|
*
|
|
* @return A reference to the underlying base expression.
|
|
*/
|
|
BaseExpression const& getBaseExpression() const;
|
|
|
|
/*!
|
|
* Retrieves a pointer to the base expression underlying this expression object.
|
|
*
|
|
* @return A pointer to the underlying base expression.
|
|
*/
|
|
std::shared_ptr<BaseExpression const> const& getBaseExpressionPointer() const;
|
|
|
|
/*!
|
|
* Retrieves the return type of the expression.
|
|
*
|
|
* @return The return type of the expression.
|
|
*/
|
|
ExpressionReturnType getReturnType() const;
|
|
|
|
/*!
|
|
* Retrieves whether the expression has a numerical return type, i.e., integer or double.
|
|
*
|
|
* @return True iff the expression has a numerical return type.
|
|
*/
|
|
bool hasNumericalReturnType() const;
|
|
|
|
/*!
|
|
* Retrieves whether the expression has a boolean return type.
|
|
*
|
|
* @return True iff the expression has a boolean return type.
|
|
*/
|
|
bool hasBooleanReturnType() const;
|
|
|
|
/*!
|
|
* Retrieves whether the expression has an integral return type.
|
|
*
|
|
* @return True iff the expression has a integral return type.
|
|
*/
|
|
bool hasIntegralReturnType() const;
|
|
|
|
/*!
|
|
* Accepts the given visitor.
|
|
*
|
|
* @param visitor The visitor to accept.
|
|
*/
|
|
boost::any accept(ExpressionVisitor& visitor) const;
|
|
|
|
friend std::ostream& operator<<(std::ostream& stream, Expression const& expression);
|
|
|
|
private:
|
|
// A pointer to the underlying base expression.
|
|
std::shared_ptr<BaseExpression const> expressionPtr;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endif /* STORM_STORAGE_EXPRESSIONS_EXPRESSION_H_ */
|