diff --git a/src/language/modules/BinaryOperatorRegisterForVh.cpp b/src/language/modules/BinaryOperatorRegisterForVh.cpp
index 1af57fc9e7e6308a7d96540245d66246c1977e00..098228f1310d8d056a9d4fbf533ce5f9b0405153 100644
--- a/src/language/modules/BinaryOperatorRegisterForVh.cpp
+++ b/src/language/modules/BinaryOperatorRegisterForVh.cpp
@@ -4,7 +4,7 @@
 #include <language/utils/BinaryOperatorProcessorBuilder.hpp>
 #include <language/utils/DataHandler.hpp>
 #include <language/utils/DataVariant.hpp>
-#include <language/utils/EmbeddedIDiscreteFunctionOperators.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionOperators.hpp>
 #include <language/utils/OperatorRepository.hpp>
 #include <scheme/IDiscreteFunction.hpp>
 
diff --git a/src/language/modules/MathFunctionRegisterForVh.cpp b/src/language/modules/MathFunctionRegisterForVh.cpp
index 17f005e88c5c6ed9ec35ed4b9021c51899f69972..aa309ca19389414dbc8c843f68475da9ec918f61 100644
--- a/src/language/modules/MathFunctionRegisterForVh.cpp
+++ b/src/language/modules/MathFunctionRegisterForVh.cpp
@@ -2,7 +2,7 @@
 
 #include <language/modules/SchemeModule.hpp>
 #include <language/utils/BuiltinFunctionEmbedder.hpp>
-#include <language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp>
 #include <scheme/DiscreteFunctionVariant.hpp>
 #include <scheme/IDiscreteFunctionDescriptor.hpp>
 
diff --git a/src/language/modules/UnaryOperatorRegisterForVh.cpp b/src/language/modules/UnaryOperatorRegisterForVh.cpp
index db3b61058e51dc615088e34108667b5b82c6f7de..417cc32f5e6dd9ff14f5709268a41ce068e071b9 100644
--- a/src/language/modules/UnaryOperatorRegisterForVh.cpp
+++ b/src/language/modules/UnaryOperatorRegisterForVh.cpp
@@ -3,7 +3,7 @@
 #include <language/modules/SchemeModule.hpp>
 #include <language/utils/DataHandler.hpp>
 #include <language/utils/DataVariant.hpp>
-#include <language/utils/EmbeddedIDiscreteFunctionOperators.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionOperators.hpp>
 #include <language/utils/OperatorRepository.hpp>
 #include <language/utils/UnaryOperatorProcessorBuilder.hpp>
 #include <scheme/IDiscreteFunction.hpp>
diff --git a/src/language/utils/CMakeLists.txt b/src/language/utils/CMakeLists.txt
index 0254d25cafda269cb94cb7008e893ed16635b7e1..a81ffa8aecdf7af0085296b181f2b3ec4d63238f 100644
--- a/src/language/utils/CMakeLists.txt
+++ b/src/language/utils/CMakeLists.txt
@@ -23,8 +23,8 @@ add_library(PugsLanguageUtils
   BuiltinFunctionEmbedderUtils.cpp
   DataVariant.cpp
   EmbeddedData.cpp
-  EmbeddedIDiscreteFunctionMathFunctions.cpp
-  EmbeddedIDiscreteFunctionOperators.cpp
+  EmbeddedDiscreteFunctionMathFunctions.cpp
+  EmbeddedDiscreteFunctionOperators.cpp
   FunctionSymbolId.cpp
   IncDecOperatorRegisterForN.cpp
   IncDecOperatorRegisterForZ.cpp
diff --git a/src/language/utils/EmbeddedIDiscreteFunctionMathFunctions.cpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
similarity index 83%
rename from src/language/utils/EmbeddedIDiscreteFunctionMathFunctions.cpp
rename to src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
index 63b7d47b462c3c73932c43a3435c0a9382630624..f71b3bec237eccbc96b1726cdb5c8db538cb4571 100644
--- a/src/language/utils/EmbeddedIDiscreteFunctionMathFunctions.cpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
@@ -1,6 +1,6 @@
-#include <language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp>
 
-#include <language/utils/EmbeddedIDiscreteFunctionUtils.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionUtils.hpp>
 #include <mesh/IMesh.hpp>
 #include <scheme/DiscreteFunctionP0.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
@@ -20,7 +20,7 @@
                     std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
         return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function));           \
       } else {                                                                                   \
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(ARG));              \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG));               \
       }                                                                                          \
     },                                                                                           \
     ARG->discreteFunction());
@@ -34,59 +34,59 @@
                     std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
         return FUNCTION(discrete_function);                                                      \
       } else {                                                                                   \
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(ARG));              \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG));               \
       }                                                                                          \
     },                                                                                           \
     ARG->discreteFunction());
 
-#define DISCRETE_VH_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                        \
-  if (not hasSameMesh({ARG0, ARG1})) {                                                       \
-    throw NormalError("operands are defined on different meshes");                           \
-  }                                                                                          \
-  return std::visit(                                                                         \
-    [&](auto&& f, auto&& g) -> std::shared_ptr<DiscreteFunctionVariant> {                    \
-      using TypeOfF = std::decay_t<decltype(f)>;                                             \
-      using TypeOfG = std::decay_t<decltype(g)>;                                             \
-      if constexpr (std::is_same_v<TypeOfF, DiscreteFunctionP0<1, const double>> or          \
-                    std::is_same_v<TypeOfF, DiscreteFunctionP0<2, const double>> or          \
-                    std::is_same_v<TypeOfF, DiscreteFunctionP0<3, const double>>) {          \
-        if constexpr (std::is_same_v<TypeOfF, TypeOfG>) {                                    \
-          return std::make_shared<DiscreteFunctionVariant>(FUNCTION(f, g));                  \
-        } else {                                                                             \
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g)); \
-        }                                                                                    \
-      } else {                                                                               \
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));   \
-      }                                                                                      \
-    },                                                                                       \
+#define DISCRETE_VH_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                       \
+  if (not hasSameMesh({ARG0, ARG1})) {                                                      \
+    throw NormalError("operands are defined on different meshes");                          \
+  }                                                                                         \
+  return std::visit(                                                                        \
+    [&](auto&& f, auto&& g) -> std::shared_ptr<DiscreteFunctionVariant> {                   \
+      using TypeOfF = std::decay_t<decltype(f)>;                                            \
+      using TypeOfG = std::decay_t<decltype(g)>;                                            \
+      if constexpr (std::is_same_v<TypeOfF, DiscreteFunctionP0<1, const double>> or         \
+                    std::is_same_v<TypeOfF, DiscreteFunctionP0<2, const double>> or         \
+                    std::is_same_v<TypeOfF, DiscreteFunctionP0<3, const double>>) {         \
+        if constexpr (std::is_same_v<TypeOfF, TypeOfG>) {                                   \
+          return std::make_shared<DiscreteFunctionVariant>(FUNCTION(f, g));                 \
+        } else {                                                                            \
+          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g)); \
+        }                                                                                   \
+      } else {                                                                              \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));   \
+      }                                                                                     \
+    },                                                                                      \
     ARG0->discreteFunction(), ARG1->discreteFunction());
 
-#define DISCRETE_R_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                                          \
-  return std::visit(                                                                                          \
-    [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                               \
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                                 \
-      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or              \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or              \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) {              \
-        return std::make_shared<DiscreteFunctionVariant>(FUNCTION(ARG0, discrete_function));                  \
-      } else {                                                                                                \
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(ARG0, discrete_function)); \
-      }                                                                                                       \
-    },                                                                                                        \
+#define DISCRETE_R_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                                         \
+  return std::visit(                                                                                         \
+    [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                              \
+      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                                \
+      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or             \
+                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or             \
+                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) {             \
+        return std::make_shared<DiscreteFunctionVariant>(FUNCTION(ARG0, discrete_function));                 \
+      } else {                                                                                               \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(ARG0, discrete_function)); \
+      }                                                                                                      \
+    },                                                                                                       \
     ARG1->discreteFunction());
 
-#define DISCRETE_VH_R_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                                          \
-  return std::visit(                                                                                          \
-    [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                               \
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                                 \
-      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or              \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or              \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) {              \
-        return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function, ARG1));                  \
-      } else {                                                                                                \
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(discrete_function, ARG1)); \
-      }                                                                                                       \
-    },                                                                                                        \
+#define DISCRETE_VH_R_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                                         \
+  return std::visit(                                                                                         \
+    [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                              \
+      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                                \
+      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or             \
+                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or             \
+                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) {             \
+        return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function, ARG1));                 \
+      } else {                                                                                               \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(discrete_function, ARG1)); \
+      }                                                                                                      \
+    },                                                                                                       \
     ARG0->discreteFunction());
 
 std::shared_ptr<const DiscreteFunctionVariant>
@@ -235,14 +235,14 @@ dot(const std::shared_ptr<const DiscreteFunctionVariant>& f_v,
       using TypeOfF = std::decay_t<decltype(f)>;
       using TypeOfG = std::decay_t<decltype(g)>;
       if constexpr (not std::is_same_v<TypeOfF, TypeOfG>) {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
       } else {
         using DataType = std::decay_t<typename TypeOfF::data_type>;
         if constexpr (is_discrete_function_P0_v<TypeOfF>) {
           if constexpr (is_tiny_vector_v<DataType>) {
             return std::make_shared<DiscreteFunctionVariant>(dot(f, g));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
           }
         } else if constexpr (is_discrete_function_P0_vector_v<TypeOfF>) {
           if (f.size() == g.size()) {
@@ -251,7 +251,7 @@ dot(const std::shared_ptr<const DiscreteFunctionVariant>& f_v,
             throw NormalError("operands have different dimension");
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
         }
       }
     },
@@ -271,13 +271,13 @@ dot(const std::shared_ptr<const DiscreteFunctionVariant>& f, const TinyVector<Ve
           if constexpr (std::is_same_v<DataType, TinyVector<VectorDimension>>) {
             return std::make_shared<DiscreteFunctionVariant>(dot(discrete_function0, a));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
       }
     },
     f->discreteFunction());
@@ -296,13 +296,13 @@ dot(const TinyVector<VectorDimension>& a, const std::shared_ptr<const DiscreteFu
           if constexpr (std::is_same_v<DataType, TinyVector<VectorDimension>>) {
             return std::make_shared<DiscreteFunctionVariant>(dot(a, discrete_function0));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
       }
     },
     f->discreteFunction());
@@ -338,13 +338,13 @@ det(const std::shared_ptr<const DiscreteFunctionVariant>& A)
                         DiscreteFunctionType::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(det(discrete_function));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
       }
     },
     A->discreteFunction());
@@ -362,13 +362,13 @@ trace(const std::shared_ptr<const DiscreteFunctionVariant>& A)
                         DiscreteFunctionType::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(trace(discrete_function));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
       }
     },
     A->discreteFunction());
@@ -386,13 +386,13 @@ inverse(const std::shared_ptr<const DiscreteFunctionVariant>& A)
                         DiscreteFunctionType::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(inverse(discrete_function));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
       }
     },
     A->discreteFunction());
@@ -410,13 +410,13 @@ transpose(const std::shared_ptr<const DiscreteFunctionVariant>& A)
                         DiscreteFunctionType::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(transpose(discrete_function));
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
           }
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(A));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
       }
     },
     A->discreteFunction());
@@ -483,10 +483,10 @@ sum_of(const std::shared_ptr<const DiscreteFunctionVariant>& f)
         if constexpr (std::is_same_v<ValueT, DataType>) {
           value = sum(discrete_function);
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
       }
     },
     f->discreteFunction());
@@ -505,7 +505,7 @@ sum_of_Vh_components(const std::shared_ptr<const DiscreteFunctionVariant>& f)
         static_assert(std::is_same_v<DataType, double>);
         return std::make_shared<DiscreteFunctionVariant>(sumOfComponents(discrete_function));
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
       }
     },
     f->discreteFunction());
@@ -532,10 +532,10 @@ vectorize_to(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>&
                   discrete_vector_function[cell_id][i_discrete_function] = discrete_function[cell_id];
                 });
             } else {
-              throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(discrete_function));
+              throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(discrete_function));
             }
           } else {
-            throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(discrete_function));
+            throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(discrete_function));
           }
         },
         discrete_function_list[i_discrete_function]->discreteFunction());
@@ -624,10 +624,10 @@ integral_of(const std::shared_ptr<const DiscreteFunctionVariant>& f)
         if constexpr (std::is_same_v<ValueT, DataType>) {
           return integrate(discrete_function);
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::invalidOperandType(f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(f));
       }
     },
     f->discreteFunction());
diff --git a/src/language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp
similarity index 97%
rename from src/language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp
rename to src/language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp
index 9a310d0998f962ea02f7010c0b47dfd49e34fde2..66b784921da372cc7dfa2d616b94d6fbfe403ee3 100644
--- a/src/language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp
@@ -1,5 +1,5 @@
-#ifndef EMBEDDED_I_DISCRETE_FUNCTION_MATH_FUNCTIONS_HPP
-#define EMBEDDED_I_DISCRETE_FUNCTION_MATH_FUNCTIONS_HPP
+#ifndef EMBEDDED_DISCRETE_FUNCTION_MATH_FUNCTIONS_HPP
+#define EMBEDDED_DISCRETE_FUNCTION_MATH_FUNCTIONS_HPP
 
 #include <algebra/TinyMatrix.hpp>
 #include <algebra/TinyVector.hpp>
@@ -107,4 +107,4 @@ ValueT sum_of(const std::shared_ptr<const DiscreteFunctionVariant>&);
 template <typename ValueT>
 ValueT integral_of(const std::shared_ptr<const DiscreteFunctionVariant>&);
 
-#endif   // EMBEDDED_I_DISCRETE_FUNCTION_MATH_FUNCTIONS_HPP
+#endif   // EMBEDDED_DISCRETE_FUNCTION_MATH_FUNCTIONS_HPP
diff --git a/src/language/utils/EmbeddedIDiscreteFunctionOperators.cpp b/src/language/utils/EmbeddedDiscreteFunctionOperators.cpp
similarity index 92%
rename from src/language/utils/EmbeddedIDiscreteFunctionOperators.cpp
rename to src/language/utils/EmbeddedDiscreteFunctionOperators.cpp
index bc4dabaabc76f5e5c5e83928b5174d3e3d36c640..0b47153cf0660abd807774d477e7fcd8ae712b62 100644
--- a/src/language/utils/EmbeddedIDiscreteFunctionOperators.cpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionOperators.cpp
@@ -1,8 +1,8 @@
-#include <language/utils/EmbeddedIDiscreteFunctionOperators.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionOperators.hpp>
 
 #include <language/node_processor/BinaryExpressionProcessor.hpp>
 #include <language/node_processor/UnaryExpressionProcessor.hpp>
-#include <language/utils/EmbeddedIDiscreteFunctionUtils.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionUtils.hpp>
 #include <scheme/DiscreteFunctionP0.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 #include <scheme/DiscreteFunctionUtils.hpp>
@@ -36,12 +36,12 @@ innerCompositionLaw(const DiscreteFunctionT& f, const DiscreteFunctionT& g)
   using data_type = std::decay_t<typename DiscreteFunctionT::data_type>;
   if constexpr ((std::is_same_v<language::multiply_op, BinOperatorT> and is_tiny_vector_v<data_type>) or
                 (std::is_same_v<language::divide_op, BinOperatorT> and not std::is_arithmetic_v<data_type>)) {
-    throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
+    throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
   } else {
     if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionT>) {
       if (f.size() != g.size()) {
         std::ostringstream error_msg;
-        error_msg << EmbeddedIDiscreteFunctionUtils::getOperandTypeName(f) << " spaces have different sizes";
+        error_msg << EmbeddedDiscreteFunctionUtils::getOperandTypeName(f) << " spaces have different sizes";
         throw NormalError(error_msg.str());
       } else {
         return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(f, g));
@@ -71,16 +71,16 @@ applyBinaryOperation(const DiscreteFunctionT1& f, const DiscreteFunctionT2& g)
         if constexpr (f_data_type::NumberOfColumns == g_data_type::Dimension) {
           return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(f, g));
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
       }
     } else {
-      throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
+      throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
     }
   } else {
-    throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
+    throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));
   }
 }
 
@@ -99,7 +99,7 @@ operator+(const std::shared_ptr<const DiscreteFunctionVariant>& f_v,
       if constexpr (std::is_same_v<TypeOfF, TypeOfG>) {
         return innerCompositionLaw<TypeOfF, language::plus_op>(f, g);
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f_v, g_v));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f_v, g_v));
       }
     },
     f_v->discreteFunction(), g_v->discreteFunction());
@@ -120,7 +120,7 @@ operator-(const std::shared_ptr<const DiscreteFunctionVariant>& f_v,
       if constexpr (std::is_same_v<TypeOfF, TypeOfG>) {
         return innerCompositionLaw<TypeOfF, language::minus_op>(f, g);
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f_v, g_v));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f_v, g_v));
       }
     },
     f_v->discreteFunction(), g_v->discreteFunction());
@@ -168,7 +168,7 @@ operator/(const std::shared_ptr<const DiscreteFunctionVariant>& f_v,
       if constexpr (std::is_same_v<TypeOfF, TypeOfG> and not is_discrete_function_P0_vector_v<TypeOfF>) {
         return innerCompositionLaw<TypeOfF, language::divide_op>(f, g);
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f_v, g_v));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f_v, g_v));
       }
     },
     f_v->discreteFunction(), g_v->discreteFunction());
@@ -191,16 +191,16 @@ applyBinaryOperationWithLeftConstant(const DataType& a, const DiscreteFunctionT&
         if constexpr (lhs_data_type::NumberOfColumns == rhs_data_type::Dimension) {
           return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(a, f));
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
         }
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
       }
     } else if constexpr (std::is_same_v<language::divide_op, BinOperatorT>) {
       if constexpr (std::is_same_v<lhs_data_type, double> and std::is_same_v<rhs_data_type, double>) {
         return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(a, f));
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
       }
     } else if constexpr (std::is_same_v<language::plus_op, BinOperatorT> or
                          std::is_same_v<language::minus_op, BinOperatorT>) {
@@ -208,10 +208,10 @@ applyBinaryOperationWithLeftConstant(const DataType& a, const DiscreteFunctionT&
                     (std::is_arithmetic_v<rhs_data_type> and std::is_arithmetic_v<lhs_data_type>)) {
         return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(a, f));
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
       }
     } else {
-      throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+      throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
     }
   } else if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionT> and
                        std::is_same_v<language::multiply_op, BinOperatorT>) {
@@ -219,10 +219,10 @@ applyBinaryOperationWithLeftConstant(const DataType& a, const DiscreteFunctionT&
     if constexpr (std::is_same_v<lhs_data_type, double>) {
       return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(a, f));
     } else {
-      throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+      throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
     }
   } else {
-    throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
+    throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(a, f));
   }
 }
 
@@ -239,20 +239,20 @@ applyBinaryOperationWithRightConstant(const DiscreteFunctionT& f, const DataType
         if constexpr (lhs_data_type::NumberOfColumns == rhs_data_type::NumberOfRows) {
           return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(f, a));
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
         }
       } else if constexpr (is_tiny_matrix_v<lhs_data_type> and is_tiny_vector_v<rhs_data_type>) {
         if constexpr (lhs_data_type::NumberOfColumns == rhs_data_type::Dimension) {
           return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(f, a));
         } else {
-          throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
         }
       } else if constexpr (std::is_same_v<lhs_data_type, double> and
                            (is_tiny_matrix_v<rhs_data_type> or is_tiny_vector_v<rhs_data_type> or
                             std::is_arithmetic_v<rhs_data_type>)) {
         return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(f, a));
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
       }
     } else if constexpr (std::is_same_v<language::plus_op, BinOperatorT> or
                          std::is_same_v<language::minus_op, BinOperatorT>) {
@@ -260,13 +260,13 @@ applyBinaryOperationWithRightConstant(const DiscreteFunctionT& f, const DataType
                     (std::is_arithmetic_v<lhs_data_type> and std::is_arithmetic_v<rhs_data_type>)) {
         return std::make_shared<DiscreteFunctionVariant>(BinOp<BinOperatorT>{}.eval(f, a));
       } else {
-        throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
       }
     } else {
-      throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+      throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
     }
   } else {
-    throw NormalError(EmbeddedIDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
+    throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, a));
   }
 }
 
diff --git a/src/language/utils/EmbeddedIDiscreteFunctionOperators.hpp b/src/language/utils/EmbeddedDiscreteFunctionOperators.hpp
similarity index 98%
rename from src/language/utils/EmbeddedIDiscreteFunctionOperators.hpp
rename to src/language/utils/EmbeddedDiscreteFunctionOperators.hpp
index e1291e08136f5945404807da33516fd8d8b4604c..a23ea91a0929a10148d703dd4ec13d703f48e2bf 100644
--- a/src/language/utils/EmbeddedIDiscreteFunctionOperators.hpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionOperators.hpp
@@ -1,5 +1,5 @@
-#ifndef EMBEDDED_I_DISCRETE_FUNCTION_OPERATORS_HPP
-#define EMBEDDED_I_DISCRETE_FUNCTION_OPERATORS_HPP
+#ifndef EMBEDDED_DISCRETE_FUNCTION_OPERATORS_HPP
+#define EMBEDDED_DISCRETE_FUNCTION_OPERATORS_HPP
 
 #include <algebra/TinyMatrix.hpp>
 #include <algebra/TinyVector.hpp>
@@ -147,5 +147,4 @@ std::shared_ptr<const DiscreteFunctionVariant> operator/(const double&,
 std::shared_ptr<const DiscreteFunctionVariant> operator/(const std::shared_ptr<const DiscreteFunctionVariant>&,
                                                          const std::shared_ptr<const DiscreteFunctionVariant>&);
 
-#
-#endif   // EMBEDDED_I_DISCRETE_FUNCTION_OPERATORS_HPP
+#endif   // EMBEDDED_DISCRETE_FUNCTION_OPERATORS_HPP
diff --git a/src/language/utils/EmbeddedIDiscreteFunctionUtils.hpp b/src/language/utils/EmbeddedDiscreteFunctionUtils.hpp
similarity index 87%
rename from src/language/utils/EmbeddedIDiscreteFunctionUtils.hpp
rename to src/language/utils/EmbeddedDiscreteFunctionUtils.hpp
index e8ba3a3840722a5d08736651cd35cc8b6b52a6a8..bca3b6772b7913be46ebee9a7731aa26fb7f7a6d 100644
--- a/src/language/utils/EmbeddedIDiscreteFunctionUtils.hpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionUtils.hpp
@@ -1,5 +1,5 @@
-#ifndef EMBEDDED_I_DISCRETE_FUNCTION_UTILS_HPP
-#define EMBEDDED_I_DISCRETE_FUNCTION_UTILS_HPP
+#ifndef EMBEDDED_DISCRETE_FUNCTION_UTILS_HPP
+#define EMBEDDED_DISCRETE_FUNCTION_UTILS_HPP
 
 #include <language/utils/ASTNodeDataType.hpp>
 #include <scheme/DiscreteFunctionVariant.hpp>
@@ -9,7 +9,7 @@
 
 #include <string>
 
-struct EmbeddedIDiscreteFunctionUtils
+struct EmbeddedDiscreteFunctionUtils
 {
   template <typename T>
   static PUGS_INLINE std::string
@@ -43,4 +43,4 @@ struct EmbeddedIDiscreteFunctionUtils
   }
 };
 
-#endif   // EMBEDDED_I_DISCRETE_FUNCTION_UTILS_HPP
+#endif   // EMBEDDED_DISCRETE_FUNCTION_UTILS_HPP
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 10995de788daf3ece543c47a7c8adb7aa6cb74f0..0e585acac5ba1e5b7656ffa29411567e0f0d54f4 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -82,7 +82,7 @@ add_executable (unit_tests
   test_EdgeIntegrator.cpp
   test_EigenvalueSolver.cpp
   test_EmbeddedData.cpp
-  test_EmbeddedIDiscreteFunctionUtils.cpp
+  test_EmbeddedDiscreteFunctionUtils.cpp
   test_EscapedString.cpp
   test_Exceptions.cpp
   test_ExecutionPolicy.cpp
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
index 5760703b91f79ccef3a32d23b76e9f4d2ace48b8..ed0331dde90ba7270c0050a633a84982545a5e7b 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
@@ -5,7 +5,7 @@
 
 #include <scheme/DiscreteFunctionP0.hpp>
 
-#include <language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 #include <scheme/DiscreteFunctionVariant.hpp>
 
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
index 958b3bd5701dce9af9cda9dc7b869c37bf5a2f16..dfbdb01500b08f73dd9804d4d4581aafe4c4ba63 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
@@ -5,7 +5,7 @@
 
 #include <scheme/DiscreteFunctionP0.hpp>
 
-#include <language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 #include <scheme/DiscreteFunctionVariant.hpp>
 
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
index 9fd3ad39f7f016c37e9a18f219998d694f4411ec..5f9896ad64df5601f54f9d701fc5bfe94f4d51b9 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
@@ -5,7 +5,7 @@
 
 #include <scheme/DiscreteFunctionP0.hpp>
 
-#include <language/utils/EmbeddedIDiscreteFunctionMathFunctions.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionMathFunctions.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 #include <scheme/DiscreteFunctionVariant.hpp>
 
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators.hpp b/tests/test_EmbeddedDiscreteFunctionOperators.hpp
index 8cb58b09e692ea2764f735d01ca4d566af818cfa..93faf56eb06d16469a89bd54206620ee98e0e74d 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators.hpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators.hpp
@@ -6,7 +6,7 @@
 
 #include <MeshDataBaseForTests.hpp>
 
-#include <language/utils/EmbeddedIDiscreteFunctionOperators.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionOperators.hpp>
 #include <scheme/DiscreteFunctionP0.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 #include <scheme/DiscreteFunctionVariant.hpp>
diff --git a/tests/test_EmbeddedIDiscreteFunctionUtils.cpp b/tests/test_EmbeddedDiscreteFunctionUtils.cpp
similarity index 54%
rename from tests/test_EmbeddedIDiscreteFunctionUtils.cpp
rename to tests/test_EmbeddedDiscreteFunctionUtils.cpp
index 8e3f65030ada56f4de3891a5506b55850aa52d40..dd2fe97b69541189d1eb859bad6d952e9d705605 100644
--- a/tests/test_EmbeddedIDiscreteFunctionUtils.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionUtils.cpp
@@ -1,7 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
-#include <language/utils/EmbeddedIDiscreteFunctionUtils.hpp>
+#include <language/utils/EmbeddedDiscreteFunctionUtils.hpp>
 #include <scheme/DiscreteFunctionP0.hpp>
 #include <scheme/DiscreteFunctionP0Vector.hpp>
 
@@ -9,7 +9,7 @@
 
 // clazy:excludeall=non-pod-global-static
 
-TEST_CASE("EmbeddedIDiscreteFunctionUtils", "[language]")
+TEST_CASE("EmbeddedDiscreteFunctionUtils", "[language]")
 {
   using R1 = TinyVector<1, double>;
   using R2 = TinyVector<2, double>;
@@ -23,8 +23,8 @@ TEST_CASE("EmbeddedIDiscreteFunctionUtils", "[language]")
   {
     SECTION("basic types")
     {
-      REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(double{1}) == "R");
-      REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(std::make_shared<double>(1)) == "R");
+      REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(double{1}) == "R");
+      REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(std::make_shared<double>(1)) == "R");
     }
 
     SECTION("discrete P0 function")
@@ -36,21 +36,21 @@ TEST_CASE("EmbeddedIDiscreteFunctionUtils", "[language]")
         {
           auto mesh_1d = named_mesh.mesh();
 
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, double>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, double>{mesh_1d}) ==
                   "Vh(P0:R)");
 
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R1>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R1>{mesh_1d}) ==
                   "Vh(P0:R^1)");
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R2>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R2>{mesh_1d}) ==
                   "Vh(P0:R^2)");
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R3>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R3>{mesh_1d}) ==
                   "Vh(P0:R^3)");
 
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R1x1>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R1x1>{mesh_1d}) ==
                   "Vh(P0:R^1x1)");
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R2x2>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R2x2>{mesh_1d}) ==
                   "Vh(P0:R^2x2)");
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R3x3>{mesh_1d}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, R3x3>{mesh_1d}) ==
                   "Vh(P0:R^3x3)");
         }
       }
@@ -65,7 +65,7 @@ TEST_CASE("EmbeddedIDiscreteFunctionUtils", "[language]")
         {
           auto mesh_1d = named_mesh.mesh();
 
-          REQUIRE(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0Vector<1, double>{mesh_1d, 2}) ==
+          REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0Vector<1, double>{mesh_1d, 2}) ==
                   "Vh(P0Vector:R)");
         }
       }
@@ -75,7 +75,7 @@ TEST_CASE("EmbeddedIDiscreteFunctionUtils", "[language]")
 #ifndef NDEBUG
   SECTION("errors")
   {
-    REQUIRE_THROWS_WITH(EmbeddedIDiscreteFunctionUtils::getOperandTypeName(std::shared_ptr<double>()),
+    REQUIRE_THROWS_WITH(EmbeddedDiscreteFunctionUtils::getOperandTypeName(std::shared_ptr<double>()),
                         "dangling shared_ptr");
   }