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"); }