Renamed ValueTypeToExpression to RationalFunctionToExpression

src/storm-pars/analysis/AssumptionChecker.cpp

@@ -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

src/storm/storage/expressions/ValueTypeToExpression.cpp → src/storm/storage/expressions/RationalFunctionToExpression.cpp

@@ -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>;
     }
 }

src/storm/storage/expressions/ValueTypeToExpression.h → src/storm/storage/expressions/RationalFunctionToExpression.h

@@ -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

src/test/storm/storage/ExpressionTest.cpp

@@ -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"
@@ -376,14 +376,14 @@ TEST(Expression, VisitorTest) {
     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,7 +396,7 @@ 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));