sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Renamed ValueTypeToExpression to RationalFunctionToExpression

main
Jip Spel 7 years ago
parent
c9c2816e18
commit
51aace8421
4 changed files with 41 additions and 41 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/storm-pars/analysis/AssumptionChecker.cpp
  2. 10
      src/storm/storage/expressions/RationalFunctionToExpression.cpp
  3. 10
      src/storm/storage/expressions/RationalFunctionToExpression.h
  4. 58
      src/test/storm/storage/ExpressionTest.cpp

4
src/storm-pars/analysis/AssumptionChecker.cpp
View File

@ -17,7 +17,7 @@
#include "storm/storage/expressions/ExpressionManager.h"
#include "storm/storage/expressions/VariableExpression.h"
#include "storm/utility/constants.h"
#include "storm/storage/expressions/ValueTypeToExpression.h"
#include "storm/storage/expressions/RationalFunctionToExpression.h"
namespace storm {
namespace analysis {
@ -217,7 +217,7 @@ namespace storm {
}
storm::expressions::Expression exprGiven = succ1 >= succ2;
auto valueTypeToExpression = storm::expressions::ValueTypeToExpression<ValueType>(manager);
auto valueTypeToExpression = storm::expressions::RationalFunctionToExpression<ValueType>(manager);
storm::expressions::Expression exprToCheck =
(valueTypeToExpression.toExpression(state1succ1->getValue())*succ1
+ valueTypeToExpression.toExpression(state2succ1->getValue())*succ2

10
src/storm/storage/expressions/ValueTypeToExpression.cpp → src/storm/storage/expressions/RationalFunctionToExpression.cpp
View File

@ -2,23 +2,23 @@
// Created by Jip Spel on 24.09.18.
//
#include "ValueTypeToExpression.h"
#include "RationalFunctionToExpression.h"
#include "storm/utility/constants.h"
namespace storm {
namespace expressions {
template <typename ValueType>
ValueTypeToExpression<ValueType>::ValueTypeToExpression(std::shared_ptr<ExpressionManager> manager) : manager(manager) {
RationalFunctionToExpression<ValueType>::RationalFunctionToExpression(std::shared_ptr<ExpressionManager> manager) : manager(manager) {
// Intentionally left empty.
}
template <typename ValueType>
std::shared_ptr<ExpressionManager> ValueTypeToExpression<ValueType>::getManager() {
std::shared_ptr<ExpressionManager> RationalFunctionToExpression<ValueType>::getManager() {
return manager;
}
template <typename ValueType>
Expression ValueTypeToExpression<ValueType>::toExpression(ValueType function) {
Expression RationalFunctionToExpression<ValueType>::toExpression(ValueType function) {
function.simplify();
auto varsFunction = function.gatherVariables();
for (auto var : varsFunction) {
@ -62,6 +62,6 @@ namespace storm {
}
return result;
}
template class ValueTypeToExpression<storm::RationalFunction>;
template class RationalFunctionToExpression<storm::RationalFunction>;
}
}

10
src/storm/storage/expressions/ValueTypeToExpression.h → src/storm/storage/expressions/RationalFunctionToExpression.h
View File

@ -2,8 +2,8 @@
// Created by Jip Spel on 24.09.18.
//
#ifndef STORM_VALUETYPETOEXPRESSION_H
#define STORM_VALUETYPETOEXPRESSION_H
#ifndef STORM_RATIONALFUNCTIONTOEXPRESSION_H
#define STORM_RATIONALFUNCTIONTOEXPRESSION_H
#include "storm/storage/expressions/ExpressionManager.h"
#include "storm/storage/expressions/Expression.h"
@ -11,9 +11,9 @@
namespace storm {
namespace expressions {
template<typename ValueType>
class ValueTypeToExpression {
class RationalFunctionToExpression {
public:
ValueTypeToExpression(std::shared_ptr<ExpressionManager> manager);
RationalFunctionToExpression(std::shared_ptr<ExpressionManager> manager);
/*!
* Retrieves the manager responsible for the variables of this valuation.
@ -37,4 +37,4 @@ namespace storm {
}
}
#endif //STORM_VALUETYPETOEXPRESSION_H
#endif //STORM_RATIONALFUNCTIONTOEXPRESSION_H

58
src/test/storm/storage/ExpressionTest.cpp
View File

@ -7,7 +7,7 @@
#include "storm/storage/expressions/LinearityCheckVisitor.h"
#include "storm/storage/expressions/SimpleValuation.h"
#include "storm/storage/expressions/ExpressionEvaluator.h"
#include "storm/storage/expressions/ValueTypeToExpression.h"
#include "storm/storage/expressions/RationalFunctionToExpression.h"
#include "storm/exceptions/InvalidTypeException.h"
#include "storm/adapters/RationalFunctionAdapter.h"
#include "storm-parsers/parser/ValueParser.h"
@ -299,27 +299,27 @@ TEST(Expression, SimplificationTest) {
storm::expressions::Expression falseExpression;
storm::expressions::Expression threeExpression;
storm::expressions::Expression intVarExpression;
ASSERT_NO_THROW(trueExpression = manager->boolean(true));
ASSERT_NO_THROW(falseExpression = manager->boolean(false));
ASSERT_NO_THROW(threeExpression = manager->integer(3));
ASSERT_NO_THROW(intVarExpression = manager->declareIntegerVariable("y"));
storm::expressions::Expression tempExpression;
storm::expressions::Expression simplifiedExpression;
ASSERT_NO_THROW(tempExpression = trueExpression || intVarExpression > threeExpression);
ASSERT_NO_THROW(simplifiedExpression = tempExpression.simplify());
EXPECT_TRUE(simplifiedExpression.isTrue());
ASSERT_NO_THROW(trueExpression = manager->boolean(true));
ASSERT_NO_THROW(falseExpression = manager->boolean(false));
ASSERT_NO_THROW(threeExpression = manager->integer(3));
ASSERT_NO_THROW(intVarExpression = manager->declareIntegerVariable("y"));
storm::expressions::Expression tempExpression;
storm::expressions::Expression simplifiedExpression;
ASSERT_NO_THROW(tempExpression = falseExpression && intVarExpression > threeExpression);
ASSERT_NO_THROW(simplifiedExpression = tempExpression.simplify());
EXPECT_TRUE(simplifiedExpression.isFalse());
ASSERT_NO_THROW(tempExpression = trueExpression || intVarExpression > threeExpression);
ASSERT_NO_THROW(simplifiedExpression = tempExpression.simplify());
EXPECT_TRUE(simplifiedExpression.isTrue());
ASSERT_NO_THROW(tempExpression = falseExpression && intVarExpression > threeExpression);
ASSERT_NO_THROW(simplifiedExpression = tempExpression.simplify());
EXPECT_TRUE(simplifiedExpression.isFalse());
}
TEST(Expression, SimpleEvaluationTest) {
std::shared_ptr<storm::expressions::ExpressionManager> manager(new storm::expressions::ExpressionManager());
storm::expressions::Expression trueExpression;
storm::expressions::Expression falseExpression;
storm::expressions::Expression threeExpression;
@ -327,7 +327,7 @@ TEST(Expression, SimpleEvaluationTest) {
storm::expressions::Expression boolVarExpression;
storm::expressions::Expression intVarExpression;
storm::expressions::Expression rationalVarExpression;
ASSERT_NO_THROW(trueExpression = manager->boolean(true));
ASSERT_NO_THROW(falseExpression = manager->boolean(false));
ASSERT_NO_THROW(threeExpression = manager->integer(3));
@ -335,23 +335,23 @@ TEST(Expression, SimpleEvaluationTest) {
ASSERT_NO_THROW(boolVarExpression = manager->declareBooleanVariable("x"));
ASSERT_NO_THROW(intVarExpression = manager->declareIntegerVariable("y"));
ASSERT_NO_THROW(rationalVarExpression = manager->declareRationalVariable("z"));
storm::expressions::Expression tempExpression;
ASSERT_NO_THROW(tempExpression = (intVarExpression < threeExpression || boolVarExpression) && boolVarExpression);
ASSERT_NO_THROW(storm::expressions::SimpleValuation valuation(manager));
storm::expressions::SimpleValuation valuation(manager);
ASSERT_NO_THROW(valuation.setBooleanValue(manager->getVariable("x"), false));
ASSERT_NO_THROW(valuation.setIntegerValue(manager->getVariable("y"), 0));
ASSERT_NO_THROW(valuation.setRationalValue(manager->getVariable("z"), 0));
ASSERT_THROW(tempExpression.evaluateAsDouble(&valuation), storm::exceptions::InvalidTypeException);
ASSERT_THROW(tempExpression.evaluateAsInt(&valuation), storm::exceptions::InvalidTypeException);
EXPECT_FALSE(tempExpression.evaluateAsBool(&valuation));
ASSERT_NO_THROW(valuation.setIntegerValue(manager->getVariable("y"), 3));
EXPECT_FALSE(tempExpression.evaluateAsBool(&valuation));
ASSERT_NO_THROW(tempExpression = storm::expressions::ite(intVarExpression < threeExpression, trueExpression, falseExpression));
ASSERT_THROW(tempExpression.evaluateAsDouble(&valuation), storm::exceptions::InvalidTypeException);
ASSERT_THROW(tempExpression.evaluateAsInt(&valuation), storm::exceptions::InvalidTypeException);
@ -360,30 +360,30 @@ TEST(Expression, SimpleEvaluationTest) {
TEST(Expression, VisitorTest) {
std::shared_ptr<storm::expressions::ExpressionManager> manager(new storm::expressions::ExpressionManager());
storm::expressions::Expression threeExpression;
storm::expressions::Expression piExpression;
storm::expressions::Expression intVarExpression;
storm::expressions::Expression rationalVarExpression;
ASSERT_NO_THROW(threeExpression = manager->integer(3));
ASSERT_NO_THROW(piExpression = manager->rational(3.14));
ASSERT_NO_THROW(intVarExpression = manager->declareIntegerVariable("y"));
ASSERT_NO_THROW(rationalVarExpression = manager->declareRationalVariable("z"));
storm::expressions::Expression tempExpression = intVarExpression + rationalVarExpression * threeExpression;
storm::expressions::LinearityCheckVisitor visitor;
EXPECT_TRUE(visitor.check(tempExpression));
}
TEST(Expression, ValueTypeToExpressionTest) {
TEST(Expression, RationalFunctionToExpressionTest) {
storm::parser::ValueParser<storm::RationalFunction> parser;
parser.addParameter("p");
parser.addParameter("q");
auto rationalFunction = parser.parseValue("((5*p^(3))+(q*p*7)+2)/2");
std::shared_ptr<storm::expressions::ExpressionManager> manager(new storm::expressions::ExpressionManager());
auto transformer = storm::expressions::ValueTypeToExpression<storm::RationalFunction>(manager);
auto transformer = storm::expressions::RationalFunctionToExpression<storm::RationalFunction>(manager);
storm::expressions::Expression expr;
EXPECT_NO_THROW(expr = transformer.toExpression(rationalFunction));
@ -396,10 +396,10 @@ TEST(Expression, ValueTypeToExpressionTest) {
EXPECT_EQ(rationalFunction.toString(), result.toString());
rationalFunction = parser.parseValue("(5*((p^(3))+(q*p)))/2");
transformer = storm::expressions::ValueTypeToExpression<storm::RationalFunction>(manager);
transformer = storm::expressions::RationalFunctionToExpression<storm::RationalFunction>(manager);
EXPECT_NO_THROW(expr = transformer.toExpression(rationalFunction));
ASSERT_NO_THROW(rationalFunction.simplify());
ASSERT_NO_THROW(result = visitor.toRationalFunction(expr));
ASSERT_NO_THROW(result.simplify());
EXPECT_EQ(rationalFunction.toString(), result.toString());
}
}
Write Preview
Loading…
Cancel
Save