diff --git a/CMakeLists.txt b/CMakeLists.txt index 560dd74c04bf5f76dee000a9a8883276ff99bdfd..0676fb79a931c8622b0182eb6cb03011f4e681ad 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -92,7 +92,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DKokkos=InlineKokkos") #------------------------------------------------------ # Pugs default compiler flags -set(PUGS_CXX_FLAGS "${PUGS_CXX_FLAGS} -Wall -Wextra -pedantic") +set(PUGS_CXX_FLAGS "${PUGS_CXX_FLAGS} -Wall -Wextra -pedantic -Wshadow") if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "${GNU_CXX_MIN_VERSION}") diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp index b67d81af335e3de1d3c02b0307351f03e75f8089..8a934ee2504c1e38872c8cf25b4d35b9c2f89d14 100644 --- a/src/language/ast/ASTNodeDataTypeBuilder.cpp +++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp @@ -154,13 +154,13 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const ASTNode& parameters_name_node = *function_descriptor.definitionNode().children[0]; { // Function data type - const std::string& symbol = n.children[0]->string(); + const std::string& function_symbol = n.children[0]->string(); std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table; - auto [i_symbol, found] = symbol_table->find(symbol, n.children[0]->begin()); + auto [i_function_symbol, found] = symbol_table->find(function_symbol, n.children[0]->begin()); Assert(found); - i_symbol->attributes().setDataType(n.children[0]->m_data_type); + i_function_symbol->attributes().setDataType(n.children[0]->m_data_type); } const size_t nb_parameter_domains = @@ -209,14 +209,14 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const } }(); - symbol_node.m_data_type = data_type; - const std::string& symbol = symbol_node.string(); + symbol_node.m_data_type = data_type; + const std::string& symbol_node_name = symbol_node.string(); std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table; - auto [i_symbol, found] = symbol_table->find(symbol, symbol_node.begin()); + auto [i_symbol_node_name, found] = symbol_table->find(symbol_node_name, symbol_node.begin()); Assert(found); - i_symbol->attributes().setDataType(data_type); + i_symbol_node_name->attributes().setDataType(data_type); }; if (parameters_domain_node.is_type<language::empty_set>() or diff --git a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp index f4259526fb10a7d1977eec7c575e69c0837a4a26..1ceb09b0dd622251eb0f4a4e71390c897809f2bc 100644 --- a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp +++ b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp @@ -177,7 +177,7 @@ getBuiltinFunctionEmbedder(ASTNode& n) } } - uint64_t builtin_function_id = [&] { + const uint64_t builtin_function_id = [&] { switch (size(callable_id_list)) { case 0: { std::ostringstream error_msg; @@ -186,14 +186,15 @@ getBuiltinFunctionEmbedder(ASTNode& n) << rang::style::reset << rang::style::bold << "\nnote: candidates are"; for (auto candidate : builtin_function_candidate_list) { - uint64_t builtin_function_id = std::get<uint64_t>(candidate.attributes().value()); + uint64_t candidate_builtin_function_id = std::get<uint64_t>(candidate.attributes().value()); - auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable(); - std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[builtin_function_id]; + auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable(); + std::shared_ptr candidate_builtin_function_embedder = + builtin_function_embedder_table[candidate_builtin_function_id]; error_msg << "\n " << builtin_function_name << ": " - << dataTypeName(builtin_function_embedder->getParameterDataTypes()) << " -> " - << dataTypeName(builtin_function_embedder->getReturnDataType()); + << dataTypeName(candidate_builtin_function_embedder->getParameterDataTypes()) << " -> " + << dataTypeName(candidate_builtin_function_embedder->getReturnDataType()); } throw ParseError(error_msg.str(), n.begin()); diff --git a/src/language/utils/DataVariant.cpp b/src/language/utils/DataVariant.cpp index 005dda6f17f9d38cb2c9a7a63322244657f89e50..2525d999791204f0d2b2ed7466354bd6719c1e6a 100644 --- a/src/language/utils/DataVariant.cpp +++ b/src/language/utils/DataVariant.cpp @@ -4,7 +4,7 @@ #include <utils/PugsTraits.hpp> std::ostream& -operator<<(std::ostream& os, const DataVariant& v) +operator<<(std::ostream& os, const DataVariant& data_variant) { std::visit( [&](auto&& v) { @@ -29,7 +29,7 @@ operator<<(std::ostream& os, const DataVariant& v) os << v; } }, - v); + data_variant); return os; } diff --git a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp index ea842f84c24276323f8aa61865e8d1de470ef10d..0f9224fed185541ca8da8cdaaa10ffa777c978ad 100644 --- a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp +++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp @@ -10,63 +10,63 @@ #include <utils/Demangle.hpp> -#define DISCRETE_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG) \ - 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)); \ - } else { \ - throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \ - } \ - }, \ +#define DISCRETE_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG) \ + return std::visit( \ + [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { \ + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \ + if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \ + return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function)); \ + } else { \ + throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \ + } \ + }, \ ARG->discreteFunction()); -#define DISCRETE_VH_TO_R_CALL(FUNCTION, ARG) \ - return std::visit( \ - [&](auto&& discrete_function) -> double { \ - 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 FUNCTION(discrete_function); \ - } else { \ - throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \ - } \ - }, \ +#define DISCRETE_VH_TO_R_CALL(FUNCTION, ARG) \ + return std::visit( \ + [&](auto&& discrete_function) -> double { \ + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \ + if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \ + return FUNCTION(discrete_function); \ + } else { \ + 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(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g)); \ - } \ - } else { \ - throw NormalError(EmbeddedDiscreteFunctionUtils::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&& arg_f, auto&& arg_g) -> std::shared_ptr<DiscreteFunctionVariant> { \ + using TypeOfF = std::decay_t<decltype(arg_f)>; \ + using TypeOfG = std::decay_t<decltype(arg_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(arg_f, arg_g)); \ + } else { \ + throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(arg_f, arg_g)); \ + } \ + } else { \ + throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(arg_f, arg_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>>) { \ + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \ + if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \ return std::make_shared<DiscreteFunctionVariant>(FUNCTION(ARG0, discrete_function)); \ } else { \ throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(ARG0, discrete_function)); \ @@ -77,10 +77,10 @@ #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>>) { \ + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \ + if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \ + std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \ return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function, ARG1)); \ } else { \ throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(discrete_function, ARG1)); \ @@ -330,11 +330,10 @@ det(const std::shared_ptr<const DiscreteFunctionVariant>& A) { return std::visit( [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) { - if constexpr (DiscreteFunctionType::data_type::NumberOfRows == - DiscreteFunctionType::data_type::NumberOfColumns) { + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) { + if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) { return std::make_shared<DiscreteFunctionVariant>(det(discrete_function)); } else { throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A)); @@ -354,11 +353,10 @@ trace(const std::shared_ptr<const DiscreteFunctionVariant>& A) { return std::visit( [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) { - if constexpr (DiscreteFunctionType::data_type::NumberOfRows == - DiscreteFunctionType::data_type::NumberOfColumns) { + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) { + if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) { return std::make_shared<DiscreteFunctionVariant>(trace(discrete_function)); } else { throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A)); @@ -378,11 +376,10 @@ inverse(const std::shared_ptr<const DiscreteFunctionVariant>& A) { return std::visit( [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) { - if constexpr (DiscreteFunctionType::data_type::NumberOfRows == - DiscreteFunctionType::data_type::NumberOfColumns) { + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) { + if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) { return std::make_shared<DiscreteFunctionVariant>(inverse(discrete_function)); } else { throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A)); @@ -402,11 +399,10 @@ transpose(const std::shared_ptr<const DiscreteFunctionVariant>& A) { return std::visit( [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) { - if constexpr (DiscreteFunctionType::data_type::NumberOfRows == - DiscreteFunctionType::data_type::NumberOfColumns) { + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) { + if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) { return std::make_shared<DiscreteFunctionVariant>(transpose(discrete_function)); } else { throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A)); @@ -476,9 +472,9 @@ sum_of(const std::shared_ptr<const DiscreteFunctionVariant>& f) ValueT value; std::visit( [&](auto&& discrete_function) { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - using DataType = std::decay_t<typename DiscreteFunctionType::data_type>; + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + using DataType = std::decay_t<typename DiscreteFunctionT::data_type>; if constexpr (std::is_same_v<ValueT, DataType>) { value = sum(discrete_function); } else { @@ -498,9 +494,9 @@ sum_of_Vh_components(const std::shared_ptr<const DiscreteFunctionVariant>& f) { return std::visit( [&](auto&& discrete_function) -> std::shared_ptr<const DiscreteFunctionVariant> { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionType>) { - using DataType = std::decay_t<typename DiscreteFunctionType::data_type>; + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionT>) { + using DataType = std::decay_t<typename DiscreteFunctionT::data_type>; static_assert(std::is_same_v<DataType, double>); return std::make_shared<DiscreteFunctionVariant>(sumOfComponents(discrete_function)); } else { @@ -520,11 +516,10 @@ vectorize_to(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>& for (size_t i_discrete_function = 0; i_discrete_function < discrete_function_list.size(); ++i_discrete_function) { std::visit( [&](auto&& discrete_function) { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - using DataType = std::remove_const_t<typename DiscreteFunctionType::data_type>; - if constexpr (std::is_same_v<DataType, double> and - (Dimension == DiscreteFunctionType::MeshType::Dimension)) { + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + using DataType = std::remove_const_t<typename DiscreteFunctionT::data_type>; + if constexpr (std::is_same_v<DataType, double> and (Dimension == DiscreteFunctionT::MeshType::Dimension)) { const auto& connectivity = mesh.connectivity(); parallel_for( connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) { @@ -619,9 +614,9 @@ integral_of(const std::shared_ptr<const DiscreteFunctionVariant>& f) { return std::visit( [&](auto&& discrete_function) -> ValueT { - using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; - if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) { - using DataType = std::decay_t<typename DiscreteFunctionType::data_type>; + using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; + if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) { + using DataType = std::decay_t<typename DiscreteFunctionT::data_type>; if constexpr (std::is_same_v<ValueT, DataType>) { return integrate(discrete_function); } else { diff --git a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp index 48b51efba5aa8a9a9905247629e9e398a70ab17a..2ed94cbff4c8ee846e04674fd3e421f718577bfc 100644 --- a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp +++ b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp @@ -58,17 +58,18 @@ ItemArrayVariantFunctionInterpoler::_interpolate() const Assert(function0_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::typename_t or function0_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::tuple_t); - ASTNodeDataType data_type = function0_descriptor.domainMappingNode().children[1]->m_data_type.contentType(); + ASTNodeDataType data_type_candidate = + function0_descriptor.domainMappingNode().children[1]->m_data_type.contentType(); for (size_t i = 1; i < m_function_id_list.size(); ++i) { const auto& function_descriptor = m_function_id_list[i].descriptor(); Assert(function_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::typename_t); - if (data_type != function_descriptor.domainMappingNode().children[1]->m_data_type.contentType()) { + if (data_type_candidate != function_descriptor.domainMappingNode().children[1]->m_data_type.contentType()) { throw NormalError("functions must have the same type"); } } - return data_type; + return data_type_candidate; }(); switch (data_type) { diff --git a/src/mesh/CartesianMeshBuilder.cpp b/src/mesh/CartesianMeshBuilder.cpp index 9f6ea50cab88390669e3471ad3c70f25e870e390..226ff751fdf0b3316d66e2cb0c6e5366a9852d73 100644 --- a/src/mesh/CartesianMeshBuilder.cpp +++ b/src/mesh/CartesianMeshBuilder.cpp @@ -68,11 +68,11 @@ CartesianMeshBuilder::_getNodeCoordinates(const TinyVector<3>& a, const IConnectivity& connectivity) const { const TinyVector<3, uint64_t> node_size = [&] { - TinyVector node_size{cell_size}; + TinyVector sizes_of_nodes{cell_size}; for (size_t i = 0; i < 3; ++i) { - node_size[i] += 1; + sizes_of_nodes[i] += 1; } - return node_size; + return sizes_of_nodes; }(); const auto node_logic_id = [&](size_t r) { diff --git a/src/mesh/ConnectivityBuilderBase.cpp b/src/mesh/ConnectivityBuilderBase.cpp index e7eb95fc6ed064805d12b5a8ece6e2844c37b9e9..f90e506d9edfdeb6242141e08ab9d46892aa6fca 100644 --- a/src/mesh/ConnectivityBuilderBase.cpp +++ b/src/mesh/ConnectivityBuilderBase.cpp @@ -100,7 +100,7 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD Array<unsigned int> dup_faces_to_node_list(total_number_of_face_by_node); Array<unsigned int> dup_face_to_node_row(total_number_of_faces + 1); - size_t i_face = 0; + size_t face_couter = 0; dup_face_to_node_row[0] = 0; Array<unsigned short> cell_nb_faces(cell_to_node_matrix.numberOfRows()); @@ -119,12 +119,12 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; cell_nb_faces[j] = 3; break; } @@ -138,14 +138,14 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; cell_nb_faces[j] = 4; break; } @@ -156,8 +156,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node] = cell_nodes[(i + 1) % cell_nodes.size()]; i_face_node++; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2; + face_couter++; } cell_nb_faces[j] = cell_nodes.size(); @@ -177,48 +177,48 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[4]; dup_faces_to_node_list[i_face_node++] = cell_nodes[5]; dup_faces_to_node_list[i_face_node++] = cell_nodes[6]; dup_faces_to_node_list[i_face_node++] = cell_nodes[7]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[4]; dup_faces_to_node_list[i_face_node++] = cell_nodes[7]; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; dup_faces_to_node_list[i_face_node++] = cell_nodes[6]; dup_faces_to_node_list[i_face_node++] = cell_nodes[5]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[5]; dup_faces_to_node_list[i_face_node++] = cell_nodes[4]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; dup_faces_to_node_list[i_face_node++] = cell_nodes[7]; dup_faces_to_node_list[i_face_node++] = cell_nodes[6]; dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; cell_nb_faces[j] = 6; break; @@ -228,29 +228,29 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; cell_nb_faces[j] = 4; break; @@ -260,39 +260,39 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; dup_faces_to_node_list[i_face_node++] = cell_nodes[4]; dup_faces_to_node_list[i_face_node++] = cell_nodes[5]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; dup_faces_to_node_list[i_face_node++] = cell_nodes[5]; dup_faces_to_node_list[i_face_node++] = cell_nodes[4]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[1]; dup_faces_to_node_list[i_face_node++] = cell_nodes[4]; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; dup_faces_to_node_list[i_face_node++] = cell_nodes[2]; dup_faces_to_node_list[i_face_node++] = cell_nodes[0]; dup_faces_to_node_list[i_face_node++] = cell_nodes[3]; dup_faces_to_node_list[i_face_node++] = cell_nodes[5]; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4; + face_couter++; cell_nb_faces[j] = 5; break; @@ -308,8 +308,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = base_nodes[i]; } - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + base_nodes.size(); - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + base_nodes.size(); + face_couter++; // side faces const auto pyramid_vertex = cell_nodes[cell_nodes.size() - 1]; @@ -318,8 +318,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = base_nodes[i_node]; dup_faces_to_node_list[i_face_node++] = pyramid_vertex; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; } break; } @@ -333,8 +333,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = base_nodes((i_node + 1) % (cell_nodes.size() - 2)); dup_faces_to_node_list[i_face_node++] = top_vertex; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; } } @@ -345,8 +345,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD dup_faces_to_node_list[i_face_node++] = base_nodes(i_node); dup_faces_to_node_list[i_face_node++] = bottom_vertex; - dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3; - i_face++; + dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3; + face_couter++; } } cell_nb_faces[j] = 2 * (cell_nodes.size() - 2); diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp index dde1f930d26d31faa21d06bf2b8d94568ccb93f1..65326b56bd49c1ce155dbf07fe32da8622c2e66c 100644 --- a/src/mesh/ConnectivityDispatcher.cpp +++ b/src/mesh/ConnectivityDispatcher.cpp @@ -294,7 +294,7 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc() using ItemId = ItemIdT<SubItemOfItemT::item_type>; using SubItemId = ItemIdT<SubItemOfItemT::sub_item_type>; - std::vector<Array<const int>> sub_item_numbers_to_send_by_proc(parallel::size()); + std::vector<Array<const int>> mutable_sub_item_numbers_to_send_by_proc(parallel::size()); for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) { const auto& item_list_to_send_by_proc = this->_dispatchedInfo<SubItemOfItemT::item_type>().m_list_to_send_by_proc; @@ -307,9 +307,9 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc() sub_item_numbers_by_item_vector.push_back(sub_item_number[sub_item_id]); } } - sub_item_numbers_to_send_by_proc[i_rank] = convert_to_array(sub_item_numbers_by_item_vector); + mutable_sub_item_numbers_to_send_by_proc[i_rank] = convert_to_array(sub_item_numbers_by_item_vector); } - return sub_item_numbers_to_send_by_proc; + return mutable_sub_item_numbers_to_send_by_proc; }(); const auto& number_of_sub_item_per_item_to_recv_by_proc = @@ -416,8 +416,8 @@ ConnectivityDispatcher<Dimension>::_buildRecvItemIdCorrespondanceByProc() for (size_t i_rank = 0; i_rank < item_list_to_recv_size_by_proc.size(); ++i_rank) { Array<ItemId> item_id_correspondance(item_list_to_recv_size_by_proc[i_rank]); for (size_t l = 0; l < item_list_to_recv_size_by_proc[i_rank]; ++l) { - const int& item_number = recv_item_number_by_proc[i_rank][l]; - const auto& searched_item_id = item_number_to_id_map.find(item_number); + const int& recv_item_number = recv_item_number_by_proc[i_rank][l]; + const auto& searched_item_id = item_number_to_id_map.find(recv_item_number); Assert(searched_item_id != item_number_to_id_map.end()); item_id_correspondance[l] = searched_item_id->second; } @@ -438,11 +438,11 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList() parallel::allGather(m_connectivity.template numberOfRefItemList<item_type>()); const size_t number_of_item_list_sender = [&]() { - size_t number_of_item_list_sender = 0; + size_t mutable_number_of_item_list_sender = 0; for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) { - number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0); + mutable_number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0); } - return number_of_item_list_sender; + return mutable_number_of_item_list_sender; }(); if (number_of_item_list_sender > 0) { @@ -512,15 +512,15 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList() parallel::broadcast(ref_name_cat, sender_rank); std::vector<RefId> ref_id_list = [&]() { - std::vector<RefId> ref_id_list; - ref_id_list.reserve(ref_name_size_list.size()); + std::vector<RefId> mutable_ref_id_list; + mutable_ref_id_list.reserve(ref_name_size_list.size()); size_t begining = 0; for (size_t i_ref = 0; i_ref < ref_name_size_list.size(); ++i_ref) { const size_t size = ref_name_size_list[i_ref]; - ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size}); + mutable_ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size}); begining += size; } - return ref_id_list; + return mutable_ref_id_list; }(); using block_type = int32_t; diff --git a/src/mesh/DiamondDualConnectivityBuilder.cpp b/src/mesh/DiamondDualConnectivityBuilder.cpp index 2cc1f47cd3be15c1012dda01c0c1c5b84ae66355..d170212a38d96628887ebb43ef154923990a5f04 100644 --- a/src/mesh/DiamondDualConnectivityBuilder.cpp +++ b/src/mesh/DiamondDualConnectivityBuilder.cpp @@ -216,11 +216,11 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit const auto& node_number_vector = diamond_descriptor.nodeNumberVector(); { const std::unordered_map<unsigned int, NodeId> node_to_id_map = [&] { - std::unordered_map<unsigned int, NodeId> node_to_id_map; + std::unordered_map<unsigned int, NodeId> mutable_node_to_id_map; for (size_t i_node = 0; i_node < node_number_vector.size(); ++i_node) { - node_to_id_map[node_number_vector[i_node]] = i_node; + mutable_node_to_id_map[node_number_vector[i_node]] = i_node; } - return node_to_id_map; + return mutable_node_to_id_map; }(); for (size_t i_node_list = 0; i_node_list < primal_connectivity.template numberOfRefItemList<ItemType::node>(); @@ -229,17 +229,17 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit const auto& primal_node_list = primal_ref_node_list.list(); const std::vector<NodeId> diamond_node_list = [&]() { - std::vector<NodeId> diamond_node_list; + std::vector<NodeId> mutable_diamond_node_list; for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) { auto primal_node_id = primal_node_list[i_primal_node]; const auto i_diamond_node = node_to_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]); if (i_diamond_node != node_to_id_map.end()) { - diamond_node_list.push_back(i_diamond_node->second); + mutable_diamond_node_list.push_back(i_diamond_node->second); } } - return diamond_node_list; + return mutable_diamond_node_list; }(); if (parallel::allReduceOr(diamond_node_list.size() > 0)) { @@ -286,31 +286,31 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit const auto& primal_face_list = primal_ref_face_list.list(); const std::vector<FaceId> diamond_face_list = [&]() { - std::vector<FaceId> diamond_face_list; - diamond_face_list.reserve(primal_face_list.size()); - for (size_t i = 0; i < primal_face_list.size(); ++i) { - FaceId primal_face_id = primal_face_list[i]; + std::vector<FaceId> mutablt_diamond_face_list; + mutablt_diamond_face_list.reserve(primal_face_list.size()); + for (size_t i_primal_face = 0; i_primal_face < primal_face_list.size(); ++i_primal_face) { + FaceId primal_face_id = primal_face_list[i_primal_face]; const auto& primal_face_node_list = primal_face_to_node_matrix[primal_face_id]; face_node_list.clear(); - for (size_t i = 0; i < primal_face_node_list.size(); ++i) { - face_node_list.push_back(primal_face_node_list[i]); + for (size_t i_primal_face_noe = 0; i_primal_face_noe < primal_face_node_list.size(); ++i_primal_face_noe) { + face_node_list.push_back(primal_face_node_list[i_primal_face_noe]); } auto face_id = find_face(face_node_list); if (face_id.has_value()) { - diamond_face_list.push_back(face_id.value()); + mutablt_diamond_face_list.push_back(face_id.value()); } } - return diamond_face_list; + return mutablt_diamond_face_list; }(); if (parallel::allReduceOr(diamond_face_list.size() > 0)) { Array<FaceId> face_array(diamond_face_list.size()); - for (size_t i = 0; i < diamond_face_list.size(); ++i) { - face_array[i] = diamond_face_list[i]; + for (size_t i_diamond_face = 0; i_diamond_face < diamond_face_list.size(); ++i_diamond_face) { + face_array[i_diamond_face] = diamond_face_list[i_diamond_face]; } diamond_descriptor.addRefItemList( RefFaceList{primal_ref_face_list.refId(), face_array, primal_ref_face_list.type()}); @@ -361,8 +361,8 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit const auto& primal_edge_list = primal_ref_edge_list.list(); const std::vector<EdgeId> diamond_edge_list = [&]() { - std::vector<EdgeId> diamond_edge_list; - diamond_edge_list.reserve(primal_edge_list.size()); + std::vector<EdgeId> mutable_diamond_edge_list; + mutable_diamond_edge_list.reserve(primal_edge_list.size()); for (size_t i = 0; i < primal_edge_list.size(); ++i) { EdgeId primal_edge_id = primal_edge_list[i]; @@ -371,10 +371,10 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit const auto diamond_edge_id = find_edge(primal_edge_node_list[0], primal_edge_node_list[1]); if (diamond_edge_id.has_value()) { - diamond_edge_list.push_back(diamond_edge_id.value()); + mutable_diamond_edge_list.push_back(diamond_edge_id.value()); } } - return diamond_edge_list; + return mutable_diamond_edge_list; }(); if (parallel::allReduceOr(diamond_edge_list.size() > 0)) { diff --git a/src/mesh/Dual1DConnectivityBuilder.cpp b/src/mesh/Dual1DConnectivityBuilder.cpp index 9dd1c743edc0a07f578a4d7fd646ab96cfff490d..bc4f4bccc4b9055b65be7e9b103e124ef4d18eb2 100644 --- a/src/mesh/Dual1DConnectivityBuilder.cpp +++ b/src/mesh/Dual1DConnectivityBuilder.cpp @@ -74,14 +74,14 @@ Dual1DConnectivityBuilder::_buildConnectivityDescriptor(const Connectivity<1>& p Array<unsigned int> cell_to_node_list(cell_to_node_row[cell_to_node_row.size() - 1]); { - size_t next_kept_node_id = 0; - size_t i_cell_node = 0; + size_t i_kept_node_id = 0; + size_t i_cell_node = 0; for (NodeId i_node = 0; i_node < primal_connectivity.numberOfNodes(); ++i_node) { const auto& primal_node_cell_list = primal_node_to_cell_matrix[i_node]; if (primal_node_cell_list.size() == 1) { const auto i_node_in_cell = primal_node_local_number_in_their_cells(i_node, 0); - cell_to_node_list[i_cell_node + i_node_in_cell] = next_kept_node_id++; + cell_to_node_list[i_cell_node + i_node_in_cell] = i_kept_node_id++; cell_to_node_list[i_cell_node + 1 - i_node_in_cell] = number_of_kept_nodes + primal_node_cell_list[0]; i_cell_node += 2; @@ -113,11 +113,11 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_ const auto& dual_node_number_vector = dual_descriptor.nodeNumberVector(); const std::unordered_map<unsigned int, NodeId> node_to_id_map = [&] { - std::unordered_map<unsigned int, NodeId> node_to_id_map; + std::unordered_map<unsigned int, NodeId> mutable_node_to_id_map; for (size_t i_node = 0; i_node < dual_node_number_vector.size(); ++i_node) { - node_to_id_map[dual_node_number_vector[i_node]] = i_node; + mutable_node_to_id_map[dual_node_number_vector[i_node]] = i_node; } - return node_to_id_map; + return mutable_node_to_id_map; }(); for (size_t i_node_list = 0; i_node_list < primal_connectivity.template numberOfRefItemList<ItemType::node>(); @@ -126,17 +126,17 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_ const auto& primal_node_list = primal_ref_node_list.list(); const std::vector<NodeId> dual_node_list = [&]() { - std::vector<NodeId> dual_node_list; + std::vector<NodeId> mutable_dual_node_list; for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) { auto primal_node_id = primal_node_list[i_primal_node]; const auto i_dual_node = node_to_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]); if (i_dual_node != node_to_id_map.end()) { - dual_node_list.push_back(i_dual_node->second); + mutable_dual_node_list.push_back(i_dual_node->second); } } - return dual_node_list; + return mutable_dual_node_list; }(); if (parallel::allReduceOr(dual_node_list.size() > 0)) { diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp index 73de0466d156f53a114494a1419b9ca506bfea26..e05dcaae592bcd4871f11de760ea1f17ee5221dd 100644 --- a/src/mesh/GmshReader.cpp +++ b/src/mesh/GmshReader.cpp @@ -251,12 +251,12 @@ GmshConnectivityBuilder<2>::GmshConnectivityBuilder(const GmshReader::GmshData& std::unordered_map<int, FaceId> face_number_id_map = [&] { const auto& face_number_vector = descriptor.faceNumberVector(); - std::unordered_map<int, FaceId> face_number_id_map; + std::unordered_map<int, FaceId> mutable_face_number_id_map; for (size_t l = 0; l < face_number_vector.size(); ++l) { - face_number_id_map[face_number_vector[l]] = l; + mutable_face_number_id_map[face_number_vector[l]] = l; } - Assert(face_number_id_map.size() == face_number_vector.size()); - return face_number_id_map; + Assert(mutable_face_number_id_map.size() == face_number_vector.size()); + return mutable_face_number_id_map; }(); const auto& node_number_vector = descriptor.nodeNumberVector(); @@ -593,15 +593,15 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData& } } - const auto& face_number_vector = descriptor.faceNumberVector(); + const auto& descriptor_face_number_vector = descriptor.faceNumberVector(); { std::unordered_map<int, FaceId> face_number_id_map = [&] { - std::unordered_map<int, FaceId> face_number_id_map; - for (size_t l = 0; l < face_number_vector.size(); ++l) { - face_number_id_map[face_number_vector[l]] = l; + std::unordered_map<int, FaceId> mutable_face_number_id_map; + for (size_t l = 0; l < descriptor_face_number_vector.size(); ++l) { + mutable_face_number_id_map[descriptor_face_number_vector[l]] = l; } - Assert(face_number_id_map.size() == face_number_vector.size()); - return face_number_id_map; + Assert(mutable_face_number_id_map.size() == descriptor_face_number_vector.size()); + return mutable_face_number_id_map; }(); const auto& node_to_face_matrix = descriptor.nodeToFaceMatrix(); @@ -799,12 +799,12 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData& std::unordered_map<int, EdgeId> edge_number_id_map = [&] { const auto& edge_number_vector = descriptor.edgeNumberVector(); - std::unordered_map<int, EdgeId> edge_number_id_map; + std::unordered_map<int, EdgeId> mutable_edge_number_id_map; for (size_t l = 0; l < edge_number_vector.size(); ++l) { - edge_number_id_map[edge_number_vector[l]] = l; + mutable_edge_number_id_map[edge_number_vector[l]] = l; } - Assert(edge_number_id_map.size() == edge_number_vector.size()); - return edge_number_id_map; + Assert(mutable_edge_number_id_map.size() == edge_number_vector.size()); + return mutable_edge_number_id_map; }(); Array<int> edge_number_vector = copy(descriptor.edgeNumberVector()); @@ -1063,12 +1063,12 @@ GmshReader::GmshReader(const std::string& filename) : m_filename(filename) std::cout << "Sequential mesh read! Need to be dispatched\n" << std::flush; const int mesh_dimension = [&]() { - int mesh_dimension = -1; // unknown mesh dimension + int mutable_mesh_dimension = -1; // unknown mesh dimension if (m_mesh) { - mesh_dimension = m_mesh->dimension(); + mutable_mesh_dimension = m_mesh->dimension(); } - Array<int> dimensions = parallel::allGather(mesh_dimension); + Array<int> dimensions = parallel::allGather(mutable_mesh_dimension); std::set<int> dimension_set; for (size_t i = 0; i < dimensions.size(); ++i) { const int i_dimension = dimensions[i]; @@ -1196,8 +1196,8 @@ GmshReader::__readPeriodic2_2() [[maybe_unused]] const int master_id = this->_getInteger(); [[maybe_unused]] const int nb_corresponding_nodes = this->_getInteger(); for (int i_node = 0; i_node < nb_corresponding_nodes; ++i_node) { - [[maybe_unused]] const int node_id = this->_getInteger(); - [[maybe_unused]] const int master_id = this->_getInteger(); + [[maybe_unused]] const int node_id = this->_getInteger(); + [[maybe_unused]] const int node_master_id = this->_getInteger(); } } } diff --git a/src/mesh/LogicalConnectivityBuilder.cpp b/src/mesh/LogicalConnectivityBuilder.cpp index 0fcbe6752f74f34adcec1d3a2a698ccbe253987a..df205e577a12edf19f4e4a3705ba58b1e89d2cdf 100644 --- a/src/mesh/LogicalConnectivityBuilder.cpp +++ b/src/mesh/LogicalConnectivityBuilder.cpp @@ -574,11 +574,11 @@ LogicalConnectivityBuilder::_buildConnectivity(const TinyVector<3, uint64_t>& ce constexpr size_t Dimension = 3; const TinyVector<Dimension, uint64_t> node_size = [&] { - TinyVector node_size{cell_size}; + TinyVector mutable_node_size{cell_size}; for (size_t i = 0; i < Dimension; ++i) { - node_size[i] += 1; + mutable_node_size[i] += 1; } - return node_size; + return mutable_node_size; }(); auto count_items = [](auto&& v) { diff --git a/src/mesh/MedianDualConnectivityBuilder.cpp b/src/mesh/MedianDualConnectivityBuilder.cpp index ef4b260e4ce695a9386cac4f62396a129738a242..5f608943e2a5a7370b111bdabb842e6e52b48f27 100644 --- a/src/mesh/MedianDualConnectivityBuilder.cpp +++ b/src/mesh/MedianDualConnectivityBuilder.cpp @@ -33,9 +33,8 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit parallel_reduce( primal_number_of_faces, - PUGS_LAMBDA(const FaceId face_id, size_t& number_of_boundary_faces) { - number_of_boundary_faces += - (primal_face_is_owned[face_id] and (primal_face_to_cell_matrix[face_id].size() == 1)); + PUGS_LAMBDA(const FaceId face_id, size_t& nb_of_boundary_faces) { + nb_of_boundary_faces += (primal_face_is_owned[face_id] and (primal_face_to_cell_matrix[face_id].size() == 1)); }, number_of_boundary_faces); return number_of_boundary_faces; @@ -206,16 +205,17 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit auto [face_id, cell_id] = [&]() -> std::pair<FaceId, CellId> { for (size_t i_face = 0; i_face < primal_node_to_face_list.size(); ++i_face) { - const FaceId face_id = primal_node_to_face_list[i_face]; - if (primal_face_to_cell_matrix[face_id].size() > 1) { + const FaceId primal_face_id = primal_node_to_face_list[i_face]; + if (primal_face_to_cell_matrix[primal_face_id].size() > 1) { continue; } - const CellId cell_id = primal_face_to_cell_matrix[face_id][0]; - const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(face_id, 0); + const CellId primal_cell_id = primal_face_to_cell_matrix[primal_face_id][0]; + const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(primal_face_id, 0); - if (primal_face_to_node_matrix[face_id][primal_cell_face_is_reversed(cell_id, i_face_in_cell)] == node_id) { - return std::make_pair(face_id, cell_id); + if (primal_face_to_node_matrix[primal_face_id] + [primal_cell_face_is_reversed(primal_cell_id, i_face_in_cell)] == node_id) { + return std::make_pair(primal_face_id, primal_cell_id); } } // LCOV_EXCL_START @@ -243,14 +243,15 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit // inner cell auto [face_id, cell_id] = [&]() -> std::pair<FaceId, CellId> { - const FaceId face_id = primal_node_to_face_list[0]; + const FaceId primal_face_id = primal_node_to_face_list[0]; - for (size_t i_face_cell = 0; i_face_cell < primal_face_to_cell_matrix[face_id].size(); ++i_face_cell) { - const CellId cell_id = primal_face_to_cell_matrix[face_id][i_face_cell]; - const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(face_id, i_face_cell); + for (size_t i_face_cell = 0; i_face_cell < primal_face_to_cell_matrix[primal_face_id].size(); ++i_face_cell) { + const CellId primal_cell_id = primal_face_to_cell_matrix[primal_face_id][i_face_cell]; + const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(primal_face_id, i_face_cell); - if (primal_face_to_node_matrix[face_id][primal_cell_face_is_reversed(cell_id, i_face_in_cell)] == node_id) { - return std::make_pair(face_id, cell_id); + if (primal_face_to_node_matrix[primal_face_id] + [primal_cell_face_is_reversed(primal_cell_id, i_face_in_cell)] == node_id) { + return std::make_pair(primal_face_id, primal_cell_id); } } // LCOV_EXCL_START diff --git a/src/mesh/MeshBuilderBase.cpp b/src/mesh/MeshBuilderBase.cpp index 973a6099afb49595d02403c697bbb927d2a7ba63..d2b27cd14c6680a99c4d6aba3281d36bcae1071b 100644 --- a/src/mesh/MeshBuilderBase.cpp +++ b/src/mesh/MeshBuilderBase.cpp @@ -91,8 +91,9 @@ MeshBuilderBase::_checkMesh() const if (intersection.size() > 1) { std::ostringstream error_msg; error_msg << "invalid mesh.\n\tFollowing edges\n"; - for (EdgeId edge_id : intersection) { - error_msg << "\t - id=" << edge_id << " number=" << connectivity.edgeNumber()[edge_id] << '\n'; + for (EdgeId duplicated_edge_id : intersection) { + error_msg << "\t - id=" << duplicated_edge_id << " number=" << connectivity.edgeNumber()[duplicated_edge_id] + << '\n'; } error_msg << "\tare duplicated"; throw NormalError(error_msg.str()); @@ -179,8 +180,9 @@ MeshBuilderBase::_checkMesh() const if (intersection.size() > 1) { std::ostringstream error_msg; error_msg << "invalid mesh.\n\tFollowing cells\n"; - for (CellId cell_id : intersection) { - error_msg << "\t - id=" << cell_id << " number=" << connectivity.cellNumber()[cell_id] << '\n'; + for (CellId duplicated_cell_id : intersection) { + error_msg << "\t - id=" << duplicated_cell_id << " number=" << connectivity.cellNumber()[duplicated_cell_id] + << '\n'; } error_msg << "\tare duplicated"; throw NormalError(error_msg.str()); diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp index 459a827c84ead76ed23acdf28cbd8525923694da..f5e60af046b49903304762aec86a237d7b2a868a 100644 --- a/src/mesh/MeshFlatNodeBoundary.cpp +++ b/src/mesh/MeshFlatNodeBoundary.cpp @@ -38,13 +38,13 @@ MeshFlatNodeBoundary<1>::_getNormal(const Mesh<Connectivity<1>>& mesh) using R = TinyVector<1, double>; const size_t number_of_bc_nodes = [&]() { - size_t number_of_bc_nodes = 0; - auto node_is_owned = mesh.connectivity().nodeIsOwned(); - auto node_list = m_ref_node_list.list(); + size_t nb_bc_nodes = 0; + auto node_is_owned = mesh.connectivity().nodeIsOwned(); + auto node_list = m_ref_node_list.list(); for (size_t i_node = 0; i_node < node_list.size(); ++i_node) { - number_of_bc_nodes += (node_is_owned[node_list[i_node]]); + nb_bc_nodes += (node_is_owned[node_list[i_node]]); } - return parallel::allReduceMax(number_of_bc_nodes); + return parallel::allReduceMax(nb_bc_nodes); }(); if (number_of_bc_nodes != 1) { diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp index d97ee08bff9e38a7945490a2441b8e6348c84150..e883aa4eeb80b40962218208fc044f964a7d4a8d 100644 --- a/src/mesh/MeshNodeBoundary.cpp +++ b/src/mesh/MeshNodeBoundary.cpp @@ -20,15 +20,15 @@ MeshNodeBoundary<2>::_getBounds(const Mesh<Connectivity<2>>& mesh) const xmin = R2{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; xmax = R2{-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max()}; - auto update_xmin = [](const R2& x, R2& xmin) { - if ((x[0] < xmin[0]) or ((x[0] == xmin[0]) and (x[1] < xmin[1]))) { - xmin = x; + auto update_xmin = [](const R2& x, R2& x_min) { + if ((x[0] < x_min[0]) or ((x[0] == x_min[0]) and (x[1] < x_min[1]))) { + x_min = x; } }; - auto update_xmax = [](const R2& x, R2& xmax) { - if ((x[0] > xmax[0]) or ((x[0] == xmax[0]) and (x[1] > xmax[1]))) { - xmax = x; + auto update_xmax = [](const R2& x, R2& x_max) { + if ((x[0] > x_max[0]) or ((x[0] == x_max[0]) and (x[1] > x_max[1]))) { + x_max = x; } }; diff --git a/src/output/GnuplotWriter1D.cpp b/src/output/GnuplotWriter1D.cpp index 3e0740446e961505eb01e36eee5ba168e0f47dcc..6b8da7a7e063caeac4cbcd64e577ba75d913fe13 100644 --- a/src/output/GnuplotWriter1D.cpp +++ b/src/output/GnuplotWriter1D.cpp @@ -148,12 +148,12 @@ GnuplotWriter1D::_writeItemDatas(const MeshType& mesh, { using ItemId = ItemIdT<item_type>; - const size_t& number_of_columns = [&] { - size_t number_of_columns = 1; + const size_t number_of_columns = [&] { + size_t nb_columns = 1; for (const auto& [name, item_data] : output_named_item_data_set) { - std::visit([&](auto&& value) { number_of_columns += _itemDataNbRow(value); }, item_data); + std::visit([&](auto&& value) { nb_columns += _itemDataNbRow(value); }, item_data); } - return number_of_columns; + return nb_columns; }(); auto is_owned = mesh.connectivity().template isOwned<item_type>(); diff --git a/src/utils/Partitioner.cpp b/src/utils/Partitioner.cpp index e63a4b48ccfdd57952d77797bbbee3344187352e..85e13c22d80f449c211f4c37ee20f3107556d6ba 100644 --- a/src/utils/Partitioner.cpp +++ b/src/utils/Partitioner.cpp @@ -37,14 +37,14 @@ Partitioner::partition(const CRSGraph& graph) MPI_Group mesh_group; std::vector<int> group_ranks = [&]() { Array<int> graph_node_owners = parallel::allGather(static_cast<int>(graph.numberOfNodes())); - std::vector<int> group_ranks; - group_ranks.reserve(graph_node_owners.size()); + std::vector<int> grp_ranks; + grp_ranks.reserve(graph_node_owners.size()); for (size_t i = 0; i < graph_node_owners.size(); ++i) { if (graph_node_owners[i] > 0) { - group_ranks.push_back(i); + grp_ranks.push_back(i); } } - return group_ranks; + return grp_ranks; }(); MPI_Group_incl(world_group, group_ranks.size(), &(group_ranks[0]), &mesh_group); diff --git a/tests/mpi_test_main.cpp b/tests/mpi_test_main.cpp index fb0da8569382769cf495dedceb42a91528076dd9..ef3fdfcc00569ea3042de6724171fbd24e2ed680 100644 --- a/tests/mpi_test_main.cpp +++ b/tests/mpi_test_main.cpp @@ -81,11 +81,11 @@ main(int argc, char* argv[]) << '\n'; for (size_t i_rank = 1; i_rank < parallel::size(); ++i_rank) { - std::filesystem::path parallel_output = std::filesystem::path{PUGS_BINARY_DIR}.append("tests"); - parallel_output /= output_base_name + stringify(i_rank); - std::cout << " - " << rang::fg::green << parallel_output.parent_path().string() - << parallel_output.preferred_separator << rang::style::reset << rang::fgB::green - << parallel_output.filename().string() << rang::style::reset << '\n'; + std::filesystem::path other_rank_output = std::filesystem::path{PUGS_BINARY_DIR}.append("tests"); + other_rank_output /= output_base_name + stringify(i_rank); + std::cout << " - " << rang::fg::green << other_rank_output.parent_path().string() + << other_rank_output.preferred_separator << rang::style::reset << rang::fgB::green + << other_rank_output.filename().string() << rang::style::reset << '\n'; } } } diff --git a/tests/test_Array.cpp b/tests/test_Array.cpp index 2651ecf43287fed07345f7fdbfef63e7d6f770a8..4a447f70a9e99151027266602763b712d00525cf 100644 --- a/tests/test_Array.cpp +++ b/tests/test_Array.cpp @@ -260,67 +260,67 @@ TEST_CASE("Array", "[utils]") SECTION("checking for Array reductions") { - Array<int> a(10); - a[0] = 13; - a[1] = 1; - a[2] = 8; - a[3] = -3; - a[4] = 23; - a[5] = -1; - a[6] = 13; - a[7] = 0; - a[8] = 12; - a[9] = 9; + Array<int> b(10); + b[0] = 13; + b[1] = 1; + b[2] = 8; + b[3] = -3; + b[4] = 23; + b[5] = -1; + b[6] = 13; + b[7] = 0; + b[8] = 12; + b[9] = 9; SECTION("Min") { - REQUIRE(min(a) == -3); + REQUIRE(min(b) == -3); } SECTION("Max") { - REQUIRE(max(a) == 23); + REQUIRE(max(b) == 23); } SECTION("Sum") { - REQUIRE((sum(a) == 75)); + REQUIRE((sum(b) == 75)); } SECTION("TinyVector Sum") { using N2 = TinyVector<2, int>; - Array<N2> b(10); - b[0] = N2{13, 2}; - b[1] = N2{1, 3}; - b[2] = N2{8, -2}; - b[3] = N2{-3, 2}; - b[4] = N2{23, 4}; - b[5] = N2{-1, -3}; - b[6] = N2{13, 17}; - b[7] = N2{0, 9}; - b[8] = N2{12, 13}; - b[9] = N2{9, -17}; - - REQUIRE((sum(b) == N2{75, 28})); + Array<N2> c(10); + c[0] = N2{13, 2}; + c[1] = N2{1, 3}; + c[2] = N2{8, -2}; + c[3] = N2{-3, 2}; + c[4] = N2{23, 4}; + c[5] = N2{-1, -3}; + c[6] = N2{13, 17}; + c[7] = N2{0, 9}; + c[8] = N2{12, 13}; + c[9] = N2{9, -17}; + + REQUIRE((sum(c) == N2{75, 28})); } SECTION("TinyMatrix Sum") { using N22 = TinyMatrix<2, 2, int>; - Array<N22> b(10); - b[0] = N22{13, 2, 0, 1}; - b[1] = N22{1, 3, 6, 3}; - b[2] = N22{8, -2, -1, 21}; - b[3] = N22{-3, 2, 5, 12}; - b[4] = N22{23, 4, 7, 1}; - b[5] = N22{-1, -3, 33, 11}; - b[6] = N22{13, 17, 12, 13}; - b[7] = N22{0, 9, 1, 14}; - b[8] = N22{12, 13, -3, -71}; - b[9] = N22{9, -17, 0, 16}; - - REQUIRE((sum(b) == N22{75, 28, 60, 21})); + Array<N22> d(10); + d[0] = N22{13, 2, 0, 1}; + d[1] = N22{1, 3, 6, 3}; + d[2] = N22{8, -2, -1, 21}; + d[3] = N22{-3, 2, 5, 12}; + d[4] = N22{23, 4, 7, 1}; + d[5] = N22{-1, -3, 33, 11}; + d[6] = N22{13, 17, 12, 13}; + d[7] = N22{0, 9, 1, 14}; + d[8] = N22{12, 13, -3, -71}; + d[9] = N22{9, -17, 0, 16}; + + REQUIRE((sum(d) == N22{75, 28, 60, 21})); } } diff --git a/tests/test_BuiltinFunctionEmbedder.cpp b/tests/test_BuiltinFunctionEmbedder.cpp index 31cde714627687bb0aee8f62ff122cf2e5ae0a1b..be28e7d75a42240f2f2e248e8cade2261e5ef5e5 100644 --- a/tests/test_BuiltinFunctionEmbedder.cpp +++ b/tests/test_BuiltinFunctionEmbedder.cpp @@ -204,11 +204,11 @@ TEST_CASE("BuiltinFunctionEmbedder", "[language]") SECTION("uint64_t(std::vector<uint64_t>) BuiltinFunctionEmbedder") { std::function sum = [&](const std::vector<uint64_t>& x) -> uint64_t { - uint64_t sum = 0; + uint64_t s = 0; for (size_t i = 0; i < x.size(); ++i) { - sum += x[i]; + s += x[i]; } - return sum; + return s; }; std::unique_ptr<IBuiltinFunctionEmbedder> i_embedded_c = @@ -234,11 +234,11 @@ TEST_CASE("BuiltinFunctionEmbedder", "[language]") SECTION("uint64_t(std::vector<EmbeddedData>) BuiltinFunctionEmbedder") { std::function sum = [&](const std::vector<std::shared_ptr<const uint64_t>>& x) -> uint64_t { - uint64_t sum = 0; + uint64_t s = 0; for (size_t i = 0; i < x.size(); ++i) { - sum += *x[i]; + s += *x[i]; } - return sum; + return s; }; std::unique_ptr<IBuiltinFunctionEmbedder> i_embedded_c = diff --git a/tests/test_BuiltinFunctionProcessor.cpp b/tests/test_BuiltinFunctionProcessor.cpp index de04b76016ad02a78130574129b74d95ca38ba94..b678612fe2c338b641b1e66c6ccce9ae65454b8f 100644 --- a/tests/test_BuiltinFunctionProcessor.cpp +++ b/tests/test_BuiltinFunctionProcessor.cpp @@ -42,7 +42,7 @@ position use_position{10000, 1000, 10, "fixture"}; \ auto [symbol, found] = symbol_table->find(variable_name, use_position); \ \ - REQUIRE_THAT(found, Catch::Matchers::Predicate<bool>([](bool found) -> bool { return found; }, \ + REQUIRE_THAT(found, Catch::Matchers::Predicate<bool>([](bool is_found) -> bool { return is_found; }, \ std::string{"Cannot find symbol '"} + variable_name + "'")); \ \ auto attributes = symbol->attributes(); \ diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp index 7c70d19fd2a538f831507d7eeb41392b0686f158..9b286a44508726c5a286964a89e8acec80ef12ec 100644 --- a/tests/test_CellIntegrator.cpp +++ b/tests/test_CellIntegrator.cpp @@ -1156,8 +1156,6 @@ TEST_CASE("CellIntegrator", "[scheme]") SECTION("2D") { - using R2 = TinyVector<2>; - const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh(); auto f = [](const R2& X) -> R2 { diff --git a/tests/test_CubeTransformation.cpp b/tests/test_CubeTransformation.cpp index 346dd3c4e9b1f3412bb53503c6880ea07a1508e6..e719ea5aaa5c99f659fdad31ca3b3d844b3623ac 100644 --- a/tests/test_CubeTransformation.cpp +++ b/tests/test_CubeTransformation.cpp @@ -151,8 +151,6 @@ TEST_CASE("CubeTransformation", "[geometry]") SECTION("degenerate to tetrahedron") { - using R3 = TinyVector<3>; - const R3 a{1, 2, 1}; const R3 b{3, 1, 3}; const R3 c{2, 5, 2}; diff --git a/tests/test_DiscreteFunctionP0.cpp b/tests/test_DiscreteFunctionP0.cpp index d0f71e984d516ec243de289f399d882663c9c499..d7d4dff52124e734b1d0d5f6bce1d402fa0f680d 100644 --- a/tests/test_DiscreteFunctionP0.cpp +++ b/tests/test_DiscreteFunctionP0.cpp @@ -47,14 +47,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()}; h_values.fill(ZeroType{}); - DiscreteFunctionP0 zero{mesh, [&] { - CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()}; - cell_value.fill(ZeroType{}); - return cell_value; - }()}; + DiscreteFunctionP0 zero_function{mesh, [&] { + CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()}; + cell_value.fill(ZeroType{}); + return cell_value; + }()}; DiscreteFunctionP0 h{mesh, h_values}; - REQUIRE(same_values(h, zero)); + REQUIRE(same_values(h, zero_function)); REQUIRE(same_values(h, h_values)); DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh}; @@ -64,7 +64,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") REQUIRE(same_values(shallow_h, h_values)); REQUIRE(same_values(h, h_values)); - REQUIRE(not same_values(h, zero)); + REQUIRE(not same_values(h, zero_function)); DiscreteFunctionP0 moved_h{std::move(h)}; REQUIRE(same_values(moved_h, h_values)); @@ -95,14 +95,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()}; h_values.fill(ZeroType{}); - DiscreteFunctionP0 zero{mesh, [&] { - CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()}; - cell_value.fill(ZeroType{}); - return cell_value; - }()}; + DiscreteFunctionP0 zero_function{mesh, [&] { + CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()}; + cell_value.fill(ZeroType{}); + return cell_value; + }()}; DiscreteFunctionP0 h{mesh, h_values}; - REQUIRE(same_values(h, zero)); + REQUIRE(same_values(h, zero_function)); REQUIRE(same_values(h, h_values)); DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh}; @@ -112,7 +112,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") REQUIRE(same_values(shallow_h, h_values)); REQUIRE(same_values(h, h_values)); - REQUIRE(not same_values(h, zero)); + REQUIRE(not same_values(h, zero_function)); DiscreteFunctionP0 moved_h{std::move(h)}; REQUIRE(same_values(moved_h, h_values)); @@ -144,14 +144,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()}; h_values.fill(ZeroType{}); - DiscreteFunctionP0 zero{mesh, [&] { - CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()}; - cell_value.fill(ZeroType{}); - return cell_value; - }()}; + DiscreteFunctionP0 zero_function{mesh, [&] { + CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()}; + cell_value.fill(ZeroType{}); + return cell_value; + }()}; DiscreteFunctionP0 h{mesh, h_values}; - REQUIRE(same_values(h, zero)); + REQUIRE(same_values(h, zero_function)); REQUIRE(same_values(h, h_values)); DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh}; @@ -161,7 +161,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") REQUIRE(same_values(shallow_h, h_values)); REQUIRE(same_values(h, h_values)); - REQUIRE(not same_values(h, zero)); + REQUIRE(not same_values(h, zero_function)); DiscreteFunctionP0 moved_h{std::move(h)}; REQUIRE(same_values(moved_h, h_values)); @@ -295,8 +295,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("scalar") { - const size_t value = parallel::rank() + 1; - const size_t zero = 0; + const size_t value = parallel::rank() + 1; + const size_t zero_value = 0; DiscreteFunctionP0<Dimension, size_t> f{mesh}; f.fill(value); @@ -304,18 +304,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_value); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_value)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_value); DiscreteFunctionP0<Dimension, const size_t> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_value)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -326,25 +326,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("vector") { const TinyVector<2, size_t> value{parallel::rank() + 1, 3}; - const TinyVector<2, size_t> zero{ZeroType{}}; + const TinyVector<2, size_t> zero_vector{ZeroType{}}; DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh}; f.fill(value); REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_vector); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_vector)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_vector); DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_vector)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -355,25 +355,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("matrix") { const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9}; - const TinyMatrix<3, 3, size_t> zero{ZeroType{}}; + const TinyMatrix<3, 3, size_t> zero_matrix{ZeroType{}}; DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh}; f.fill(value); REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_matrix); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_matrix)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_matrix); DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_matrix)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -397,8 +397,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("scalar") { - const size_t value = parallel::rank() + 1; - const size_t zero = 0; + const size_t value = parallel::rank() + 1; + const size_t zero_value = 0; DiscreteFunctionP0<Dimension, size_t> f{mesh}; f.fill(value); @@ -406,18 +406,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_value); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_value)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_value); DiscreteFunctionP0<Dimension, const size_t> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_value)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -428,25 +428,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("vector") { const TinyVector<2, size_t> value{parallel::rank() + 1, 3}; - const TinyVector<2, size_t> zero{ZeroType{}}; + const TinyVector<2, size_t> zero_vector{ZeroType{}}; DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh}; f.fill(value); REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_vector); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_vector)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_vector); DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_vector)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -457,25 +457,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("matrix") { const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9}; - const TinyMatrix<3, 3, size_t> zero{ZeroType{}}; + const TinyMatrix<3, 3, size_t> zero_vector{ZeroType{}}; DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh}; f.fill(value); REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_vector); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_vector)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_vector); DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_vector)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -499,8 +499,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("scalar") { - const size_t value = parallel::rank() + 1; - const size_t zero = 0; + const size_t value = parallel::rank() + 1; + const size_t zero_value = 0; DiscreteFunctionP0<Dimension, size_t> f{mesh}; f.fill(value); @@ -508,18 +508,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_value); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_value)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_value); DiscreteFunctionP0<Dimension, const size_t> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_value)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -530,25 +530,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("vector") { const TinyVector<2, size_t> value{parallel::rank() + 1, 3}; - const TinyVector<2, size_t> zero{ZeroType{}}; + const TinyVector<2, size_t> zero_vector{ZeroType{}}; DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh}; f.fill(value); REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_vector); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_vector)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_vector); DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_vector)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -559,25 +559,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") SECTION("matrix") { const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9}; - const TinyMatrix<3, 3, size_t> zero{ZeroType{}}; + const TinyMatrix<3, 3, size_t> zero_matrix{ZeroType{}}; DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh}; f.fill(value); REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0 g = copy(f); - f.fill(zero); + f.fill(zero_matrix); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_matrix)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_matrix); DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f); REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_matrix)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -3439,7 +3439,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) { const double x = xj[cell_id][0]; Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, // - -0.2 * x - 1, 2 + x}; + -0.2 * x - 1, 2 + x}; }); { @@ -3461,7 +3461,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) { const double x = xj[cell_id][0]; Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, // - -0.2 * x - 1, 2 + x}; + -0.2 * x - 1, 2 + x}; }); { @@ -3483,7 +3483,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) { const double x = xj[cell_id][0]; Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, // - -0.2 * x - 1, 2 + x}; + -0.2 * x - 1, 2 + x}; }); { @@ -3505,7 +3505,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]") mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) { const double x = xj[cell_id][0]; Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, // - -0.2 * x - 1, 2 + x}; + -0.2 * x - 1, 2 + x}; }); { diff --git a/tests/test_DiscreteFunctionP0Vector.cpp b/tests/test_DiscreteFunctionP0Vector.cpp index d2da3d84ef517f28dc0bd0ba60149be7c4fba725..2ab61b2405ba5eb098663db5fa6a3d26b6fe75b9 100644 --- a/tests/test_DiscreteFunctionP0Vector.cpp +++ b/tests/test_DiscreteFunctionP0Vector.cpp @@ -50,20 +50,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") CellArray<double> h_arrays{mesh->connectivity(), size}; h_arrays.fill(0); - DiscreteFunctionP0Vector zero{mesh, [&] { - CellArray<double> cell_array{mesh->connectivity(), size}; - cell_array.fill(0); - return cell_array; - }()}; + DiscreteFunctionP0Vector zero_function{mesh, [&] { + CellArray<double> cell_array{mesh->connectivity(), size}; + cell_array.fill(0); + return cell_array; + }()}; DiscreteFunctionP0Vector h{mesh, h_arrays}; - REQUIRE(same_values(h, zero)); + REQUIRE(same_values(h, zero_function)); REQUIRE(same_values(h, h_arrays)); h_arrays.fill(1); REQUIRE(same_values(h, h_arrays)); - REQUIRE(not same_values(h, zero)); + REQUIRE(not same_values(h, zero_function)); DiscreteFunctionP0Vector moved_h{std::move(h)}; REQUIRE(same_values(moved_h, h_arrays)); @@ -98,20 +98,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") CellArray<double> h_arrays{mesh->connectivity(), size}; h_arrays.fill(0); - DiscreteFunctionP0Vector zero{mesh, [&] { - CellArray<double> cell_array{mesh->connectivity(), size}; - cell_array.fill(0); - return cell_array; - }()}; + DiscreteFunctionP0Vector zero_function{mesh, [&] { + CellArray<double> cell_array{mesh->connectivity(), size}; + cell_array.fill(0); + return cell_array; + }()}; DiscreteFunctionP0Vector h{mesh, h_arrays}; - REQUIRE(same_values(h, zero)); + REQUIRE(same_values(h, zero_function)); REQUIRE(same_values(h, h_arrays)); h_arrays.fill(1); REQUIRE(same_values(h, h_arrays)); - REQUIRE(not same_values(h, zero)); + REQUIRE(not same_values(h, zero_function)); DiscreteFunctionP0Vector moved_h{std::move(h)}; REQUIRE(same_values(moved_h, h_arrays)); @@ -146,20 +146,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") CellArray<double> h_arrays{mesh->connectivity(), size}; h_arrays.fill(0); - DiscreteFunctionP0Vector zero{mesh, [&] { - CellArray<double> cell_array{mesh->connectivity(), size}; - cell_array.fill(0); - return cell_array; - }()}; + DiscreteFunctionP0Vector zero_function{mesh, [&] { + CellArray<double> cell_array{mesh->connectivity(), size}; + cell_array.fill(0); + return cell_array; + }()}; DiscreteFunctionP0Vector h{mesh, h_arrays}; - REQUIRE(same_values(h, zero)); + REQUIRE(same_values(h, zero_function)); REQUIRE(same_values(h, h_arrays)); h_arrays.fill(1); REQUIRE(same_values(h, h_arrays)); - REQUIRE(not same_values(h, zero)); + REQUIRE(not same_values(h, zero_function)); DiscreteFunctionP0Vector moved_h{std::move(h)}; REQUIRE(same_values(moved_h, h_arrays)); @@ -271,9 +271,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") { auto mesh = named_mesh.mesh(); - const size_t size = 3; - const size_t value = parallel::rank() + 1; - const size_t zero = 0; + const size_t size = 3; + const size_t value = parallel::rank() + 1; + const size_t zero_value = 0; DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size}; f.fill(value); @@ -281,13 +281,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0Vector g = copy(f); - f.fill(zero); + f.fill(zero_value); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_value)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_value); DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f); @@ -295,8 +295,8 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") shallow_g = g; REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); - REQUIRE(all_values_equal(shallow_g, zero)); + REQUIRE(all_values_equal(g, zero_value)); + REQUIRE(all_values_equal(shallow_g, zero_value)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -317,9 +317,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") { auto mesh = named_mesh.mesh(); - const size_t size = 3; - const size_t value = parallel::rank() + 1; - const size_t zero = 0; + const size_t size = 3; + const size_t value = parallel::rank() + 1; + const size_t zero_value = 0; DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size}; f.fill(value); @@ -327,13 +327,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0Vector g = copy(f); - f.fill(zero); + f.fill(zero_value); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_value)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_value); DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f); @@ -341,8 +341,8 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") shallow_g = g; REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); - REQUIRE(all_values_equal(shallow_g, zero)); + REQUIRE(all_values_equal(g, zero_value)); + REQUIRE(all_values_equal(shallow_g, zero_value)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -364,9 +364,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") { auto mesh = named_mesh.mesh(); - const size_t size = 3; - const size_t value = parallel::rank() + 1; - const size_t zero = 0; + const size_t size = 3; + const size_t value = parallel::rank() + 1; + const size_t zero_value = 0; DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size}; f.fill(value); @@ -374,13 +374,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") REQUIRE(all_values_equal(f, value)); DiscreteFunctionP0Vector g = copy(f); - f.fill(zero); + f.fill(zero_value); - REQUIRE(all_values_equal(f, zero)); + REQUIRE(all_values_equal(f, zero_value)); REQUIRE(all_values_equal(g, value)); copy_to(g, f); - g.fill(zero); + g.fill(zero_value); DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f); @@ -388,7 +388,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") shallow_g = g; REQUIRE(all_values_equal(f, value)); - REQUIRE(all_values_equal(g, zero)); + REQUIRE(all_values_equal(g, zero_value)); REQUIRE(all_values_equal(h, value)); copy_to(h, g); @@ -573,10 +573,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") DiscreteFunctionP0Vector<Dimension, const double> const_f = f; DiscreteFunctionP0Vector<Dimension, const double> const_g{g}; - auto same_data = [](const auto& f, const auto& g) { - const size_t number_of_cells = g.size(); + auto same_data = [](const auto& f0, const auto& f1) { + const size_t number_of_cells = f1.size(); for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) { - if (f[cell_id] != g[cell_id]) { + if (f0[cell_id] != f1[cell_id]) { return false; } } @@ -656,10 +656,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") DiscreteFunctionP0Vector<Dimension, const double> const_f = f; DiscreteFunctionP0Vector<Dimension, const double> const_g{g}; - auto same_data = [](const auto& f, const auto& g) { - const size_t number_of_cells = g.size(); + auto same_data = [](const auto& f1, const auto& f2) { + const size_t number_of_cells = f2.size(); for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) { - if (f[cell_id] != g[cell_id]) { + if (f1[cell_id] != f2[cell_id]) { return false; } } @@ -739,10 +739,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]") DiscreteFunctionP0Vector<Dimension, const double> const_f = f; DiscreteFunctionP0Vector<Dimension, const double> const_g{g}; - auto same_data = [](const auto& f, const auto& g) { - const size_t number_of_cells = g.size(); + auto same_data = [](const auto& f1, const auto& f2) { + const size_t number_of_cells = f2.size(); for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) { - if (f[cell_id] != g[cell_id]) { + if (f1[cell_id] != f2[cell_id]) { return false; } } diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp index bfa17ffc7609a8a304ee5dd36b3574782fbba464..7da58023559d83d7c554c2cc2d0aa44282508e30 100644 --- a/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp +++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp @@ -10,11 +10,11 @@ const U_TYPE& u = P_U->get<U_TYPE>(); \ const FU_TYPE& fu = p_fu->get<FU_TYPE>(); \ \ - bool is_same = true; \ - auto values = u.cellValues(); \ - for (CellId cell_id = 0; cell_id < values.numberOfItems(); ++cell_id) { \ + bool is_same = true; \ + auto u_values = u.cellValues(); \ + for (CellId cell_id = 0; cell_id < u_values.numberOfItems(); ++cell_id) { \ using namespace std; \ - if (fu[cell_id] != FCT(values[cell_id])) { \ + if (fu[cell_id] != FCT(u_values[cell_id])) { \ is_same = false; \ break; \ } \ diff --git a/tests/test_ItemArray.cpp b/tests/test_ItemArray.cpp index 2dbe964f3cdd5733aa77ddf5e1bc9204e9731998..644f348c6ae2df4dcf56c87816d1b3b9c323a1a1 100644 --- a/tests/test_ItemArray.cpp +++ b/tests/test_ItemArray.cpp @@ -157,15 +157,15 @@ TEST_CASE("ItemArray", "[mesh]") CellArray<size_t> cell_array{connectivity, table}; - auto is_same = [](const CellArray<size_t>& cell_array, const Table<size_t>& table) { - bool is_same = true; - for (CellId cell_id = 0; cell_id < cell_array.numberOfItems(); ++cell_id) { - auto sub_array = cell_array[cell_id]; + auto is_same = [](const CellArray<size_t>& a_cell_array, const Table<size_t>& a_table) { + bool same = true; + for (CellId cell_id = 0; cell_id < a_cell_array.numberOfItems(); ++cell_id) { + auto sub_array = a_cell_array[cell_id]; for (size_t i = 0; i < sub_array.size(); ++i) { - is_same &= (sub_array[i] == table(cell_id, i)); + same &= (sub_array[i] == a_table(cell_id, i)); } } - return is_same; + return same; }; REQUIRE(is_same(cell_array, table)); @@ -177,14 +177,14 @@ TEST_CASE("ItemArray", "[mesh]") SECTION("copy") { auto is_same = [](const auto& cell_array, int value) { - bool is_same = true; + bool same = true; for (CellId cell_id = 0; cell_id < cell_array.numberOfItems(); ++cell_id) { auto sub_array = cell_array[cell_id]; for (size_t i = 0; i < sub_array.size(); ++i) { - is_same &= (sub_array[i] == value); + same &= (sub_array[i] == value); } } - return is_same; + return same; }; std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes(); @@ -367,12 +367,12 @@ TEST_CASE("ItemArray", "[mesh]") const Connectivity<2>& connectivity_2d = mesh_2d->connectivity(); - std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes(); + std::array mesh_3d_list = MeshDataBaseForTests::get().all3DMeshes(); - for (const auto& named_mesh : mesh_list) { - SECTION(named_mesh.name()) + for (const auto& named_mesh_3d : mesh_3d_list) { + SECTION(named_mesh_3d.name()) { - auto mesh_3d = named_mesh.mesh(); + auto mesh_3d = named_mesh_3d.mesh(); const Connectivity<3>& connectivity_3d = mesh_3d->connectivity(); diff --git a/tests/test_ItemValue.cpp b/tests/test_ItemValue.cpp index 4271db6c25f21dc7aa7db61d93d9280a22aaf561..e5643274772843499826d487279f1003be2f1c4a 100644 --- a/tests/test_ItemValue.cpp +++ b/tests/test_ItemValue.cpp @@ -311,12 +311,12 @@ TEST_CASE("ItemValue", "[mesh]") const Connectivity<2>& connectivity_2d = mesh_2d->connectivity(); - std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes(); + std::array mesh_3d_list = MeshDataBaseForTests::get().all3DMeshes(); - for (const auto& named_mesh : mesh_list) { - SECTION(named_mesh.name()) + for (const auto& named_mesh_3d : mesh_3d_list) { + SECTION(named_mesh_3d.name()) { - auto mesh_3d = named_mesh.mesh(); + auto mesh_3d = named_mesh_3d.mesh(); const Connectivity<3>& connectivity_3d = mesh_3d->connectivity(); diff --git a/tests/test_ListAffectationProcessor.cpp b/tests/test_ListAffectationProcessor.cpp index 5910b3b4967acb846c11ff768ae4aa043772be57..73733b9833200f492c5e022ff1b727e57d104640 100644 --- a/tests/test_ListAffectationProcessor.cpp +++ b/tests/test_ListAffectationProcessor.cpp @@ -116,12 +116,6 @@ TEST_CASE("ListAffectationProcessor", "[language]") SECTION("lists with tuples affectation") { - auto stringify = [](auto&& value) { - std::ostringstream os; - os << std::boolalpha << value; - return os.str(); - }; - SECTION("with (B)") { SECTION("from value") diff --git a/tests/test_MathModule.cpp b/tests/test_MathModule.cpp index 2cb3481b1e6cde7561733d8ea03decd46153db9d..f299d1e3678217d4fc6bcb4c08e417264b22a252 100644 --- a/tests/test_MathModule.cpp +++ b/tests/test_MathModule.cpp @@ -71,9 +71,9 @@ TEST_CASE("MathModule", "[language]") { arg = double{-3}; - DataVariant arg_variant = arg; + DataVariant double_arg_variant = arg; - DataVariant result_variant = function_embedder.apply({arg_variant}); + DataVariant result_variant = function_embedder.apply({double_arg_variant}); auto result = std::abs(arg); diff --git a/tests/test_ParallelChecker_read.cpp b/tests/test_ParallelChecker_read.cpp index 497e1729d7ed719749327bcf652cf43a29ecaa4e..233d37e34d1b8b9069d918ade3657f07c3b3ba38 100644 --- a/tests/test_ParallelChecker_read.cpp +++ b/tests/test_ParallelChecker_read.cpp @@ -311,19 +311,19 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArray<double> arrays{connectivity, 1}; - arrays.fill(0); + CellArray<double> double_cell_array{connectivity, 1}; + double_cell_array.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data"); } { - CellArray<double> arrays{connectivity, 2}; - arrays.fill(0); + CellArray<double> double_cell_array{connectivity, 2}; + double_cell_array.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data"); } { @@ -395,16 +395,16 @@ TEST_CASE("ParallelChecker_read", "[dev]") group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) .write_raw<int>(&(numbers[0])); - Table<double> arrays{numbers.size(), 2}; + Table<double> double_table{numbers.size(), 2}; for (size_t i = 0; i < numbers.size(); ++i) { for (size_t j = 0; j < 2; ++j) { - arrays[i][j] = std::sin(2 * numbers[i] + j); + double_table[i][j] = std::sin(2 * numbers[i] + j); } } group - .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), - arrays.numberOfColumns()}}) - .write_raw<double>(&(arrays(0, 0))); + .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(), + double_table.numberOfColumns()}}) + .write_raw<double>(&(double_table(0, 0))); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -418,39 +418,39 @@ TEST_CASE("ParallelChecker_read", "[dev]") ParallelCheckerTester pc_tester; pc_tester.setTag(tag); - CellArray<double> arrays{connectivity, 2}; + CellArray<double> double_cell_array{connectivity, 2}; CellValue<const int> cell_number = connectivity.cellNumber(); for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { for (size_t j = 0; j < 2; ++j) { - arrays[cell_id][j] = std::sin(2 * cell_number[cell_id] + j); + double_cell_array[cell_id][j] = std::sin(2 * cell_number[cell_id] + j); } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(double_cell_array, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - CellArray<double> not_sync = copy(arrays); + CellArray<double> not_sync = copy(double_cell_array); CellValue<const bool> is_owned = connectivity.cellIsOwned(); if (parallel::rank() == 0) { for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { @@ -467,7 +467,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArray<double> different = copy(arrays); + CellArray<double> different = copy(double_cell_array); bool has_difference = false; if (parallel::rank() == 0) { CellValue<const bool> is_owned = connectivity.cellIsOwned(); @@ -495,11 +495,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArray<double> arrays{connectivity, 1}; - arrays.fill(0); + CellArray<double> double_cell_array2{connectivity, 1}; + double_cell_array2.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array2, "sin", source_location), "error: cannot compare data"); } { @@ -630,21 +630,21 @@ TEST_CASE("ParallelChecker_read", "[dev]") group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) .write_raw<int>(&(numbers[0])); - Table<DataType> arrays{numbers.size(), 2}; - for (size_t i = 0; i < arrays.numberOfRows(); ++i) { - for (size_t j = 0; j < arrays.numberOfColumns(); ++j) { + Table<DataType> dt_table{numbers.size(), 2}; + for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { + for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::NumberOfRows; ++k) { for (size_t l = 0; l < DataType::NumberOfColumns; ++l) { - arrays[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l); + dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l); } } } } group .createDataSet(name, - HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}}, + HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}}, test_TinyMatrixDataType<DataType>{}) - .template write_raw<double>(&(arrays[0][0](0, 0)), test_TinyMatrixDataType<DataType>{}); + .template write_raw<double>(&(dt_table[0][0](0, 0)), test_TinyMatrixDataType<DataType>{}); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -658,43 +658,43 @@ TEST_CASE("ParallelChecker_read", "[dev]") ParallelCheckerTester pc_tester; pc_tester.setTag(tag); - FaceArray<DataType> arrays{connectivity, 2}; + FaceArray<DataType> dt_face_array{connectivity, 2}; FaceValue<const int> face_number = connectivity.faceNumber(); for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) { + for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) { for (size_t k = 0; k < DataType::NumberOfRows; ++k) { for (size_t l = 0; l < DataType::NumberOfColumns; ++l) { - arrays[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l); + dt_face_array[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l); } } } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - FaceArray<DataType> not_sync = copy(arrays); + FaceArray<DataType> not_sync = copy(dt_face_array); FaceValue<const bool> is_owned = connectivity.faceIsOwned(); if (parallel::rank() == 0) { for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { @@ -711,7 +711,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> different = copy(arrays); + FaceArray<DataType> different = copy(dt_face_array); bool has_difference = false; if (parallel::rank() == 0) { FaceValue<const bool> is_owned = connectivity.faceIsOwned(); @@ -739,11 +739,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> arrays{connectivity, 1}; - arrays.fill(zero); + FaceArray<DataType> dt_face_array2{connectivity, 1}; + dt_face_array2.fill(zero); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data"); } { @@ -878,19 +878,19 @@ TEST_CASE("ParallelChecker_read", "[dev]") group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) .write_raw<int>(&(numbers[0])); - Table<DataType> arrays{numbers.size(), 2}; - for (size_t i = 0; i < arrays.numberOfRows(); ++i) { - for (size_t j = 0; j < arrays.numberOfColumns(); ++j) { + Table<DataType> dt_table{numbers.size(), 2}; + for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { + for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::Dimension; ++k) { - arrays[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k); + dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k); } } } group .createDataSet(name, - HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}}, + HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}}, test_TinyVectorDataType<DataType>{}) - .template write_raw<double>(&(arrays[0][0][0]), test_TinyVectorDataType<DataType>{}); + .template write_raw<double>(&(dt_table[0][0][0]), test_TinyVectorDataType<DataType>{}); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -904,41 +904,41 @@ TEST_CASE("ParallelChecker_read", "[dev]") ParallelCheckerTester pc_tester; pc_tester.setTag(tag); - FaceArray<DataType> arrays{connectivity, 2}; + FaceArray<DataType> dt_face_array{connectivity, 2}; FaceValue<const int> face_number = connectivity.faceNumber(); for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) { + for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) { for (size_t k = 0; k < DataType::Dimension; ++k) { - arrays[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k); + dt_face_array[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k); } } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - FaceArray<DataType> not_sync = copy(arrays); + FaceArray<DataType> not_sync = copy(dt_face_array); FaceValue<const bool> is_owned = connectivity.faceIsOwned(); if (parallel::rank() == 0) { for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { @@ -955,7 +955,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> different = copy(arrays); + FaceArray<DataType> different = copy(dt_face_array); bool has_difference = false; if (parallel::rank() == 0) { FaceValue<const bool> is_owned = connectivity.faceIsOwned(); @@ -983,11 +983,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> arrays{connectivity, 1}; - arrays.fill(zero); + FaceArray<DataType> dt_face_array2{connectivity, 1}; + dt_face_array2.fill(zero); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data"); } { @@ -1135,11 +1135,12 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArrayPerNode<double> arrays{connectivity, 1}; - arrays.fill(0); + CellArrayPerNode<double> double_cell_array_per_node{connectivity, 1}; + double_cell_array_per_node.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array_per_node, "sin", source_location), + "error: cannot compare data"); } { @@ -1235,19 +1236,19 @@ TEST_CASE("ParallelChecker_read", "[dev]") rows_map.size()}}) .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0])); - Table<double> arrays{rows_map[rows_map.size() - 1], 2}; + Table<double> double_table{rows_map[rows_map.size() - 1], 2}; for (size_t i = 0; i < numbers.size(); ++i) { for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) { const size_t j = i_row - rows_map[i]; for (size_t k = 0; k < 2; ++k) { - arrays[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j); + double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j); } } } group - .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), - arrays.numberOfColumns()}}) - .write_raw<double>(&(arrays(0, 0))); + .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(), + double_table.numberOfColumns()}}) + .write_raw<double>(&(double_table(0, 0))); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -1264,41 +1265,41 @@ TEST_CASE("ParallelChecker_read", "[dev]") auto cell_to_node_matrix = connectivity.cellToNodeMatrix(); - NodeArrayPerCell<double> arrays{connectivity, 2}; + NodeArrayPerCell<double> double_node_array_per_cell{connectivity, 2}; CellValue<const int> cell_number = connectivity.cellNumber(); for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { for (size_t j = 0; j < cell_to_node_matrix[cell_id].size(); ++j) { for (size_t k = 0; k < 2; ++k) { - arrays[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j); + double_node_array_per_cell[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j); } } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - NodeArrayPerCell<double> not_sync = copy(arrays); + NodeArrayPerCell<double> not_sync = copy(double_node_array_per_cell); CellValue<const bool> is_owned = connectivity.cellIsOwned(); if (parallel::rank() == 0) { for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { @@ -1315,7 +1316,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - NodeArrayPerCell<double> different = copy(arrays); + NodeArrayPerCell<double> different = copy(double_node_array_per_cell); bool has_difference = false; if (parallel::rank() == 0) { CellValue<const bool> is_owned = connectivity.cellIsOwned(); @@ -1343,11 +1344,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArray<double> arrays{connectivity, 1}; - arrays.fill(0); + CellArray<double> double_cell_array{connectivity, 1}; + double_cell_array.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data"); } { @@ -1385,21 +1386,21 @@ TEST_CASE("ParallelChecker_read", "[dev]") group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) .write_raw<int>(&(numbers[0])); - Table<DataType> arrays{numbers.size(), 2}; - for (size_t i = 0; i < arrays.numberOfRows(); ++i) { - for (size_t j = 0; j < arrays.numberOfColumns(); ++j) { + Table<DataType> dt_table{numbers.size(), 2}; + for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { + for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::NumberOfRows; ++k) { for (size_t l = 0; l < DataType::NumberOfColumns; ++l) { - arrays[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l); + dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l); } } } } group .createDataSet(name, - HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}}, + HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}}, test_TinyMatrixDataType<DataType>{}) - .template write_raw<double>(&(arrays[0][0](0, 0)), test_TinyMatrixDataType<DataType>{}); + .template write_raw<double>(&(dt_table[0][0](0, 0)), test_TinyMatrixDataType<DataType>{}); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -1413,43 +1414,43 @@ TEST_CASE("ParallelChecker_read", "[dev]") ParallelCheckerTester pc_tester; pc_tester.setTag(tag); - FaceArray<DataType> arrays{connectivity, 2}; + FaceArray<DataType> dt_face_array{connectivity, 2}; FaceValue<const int> face_number = connectivity.faceNumber(); for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) { + for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) { for (size_t k = 0; k < DataType::NumberOfRows; ++k) { for (size_t l = 0; l < DataType::NumberOfColumns; ++l) { - arrays[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l); + dt_face_array[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l); } } } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - FaceArray<DataType> not_sync = copy(arrays); + FaceArray<DataType> not_sync = copy(dt_face_array); FaceValue<const bool> is_owned = connectivity.faceIsOwned(); if (parallel::rank() == 0) { for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { @@ -1466,7 +1467,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> different = copy(arrays); + FaceArray<DataType> different = copy(dt_face_array); bool has_difference = false; if (parallel::rank() == 0) { FaceValue<const bool> is_owned = connectivity.faceIsOwned(); @@ -1494,11 +1495,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> arrays{connectivity, 1}; - arrays.fill(zero); + FaceArray<DataType> dt_face_array2{connectivity, 1}; + dt_face_array2.fill(zero); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data"); } { @@ -1644,11 +1645,12 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArrayPerNode<double> arrays{connectivity, 1}; - arrays.fill(0); + CellArrayPerNode<double> double_cell_array_per_node{connectivity, 1}; + double_cell_array_per_node.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array_per_node, "sin", source_location), + "error: cannot compare data"); } { @@ -1740,19 +1742,19 @@ TEST_CASE("ParallelChecker_read", "[dev]") group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}}) .write_raw<int>(&(numbers[0])); - Table<DataType> arrays{numbers.size(), 2}; - for (size_t i = 0; i < arrays.numberOfRows(); ++i) { - for (size_t j = 0; j < arrays.numberOfColumns(); ++j) { + Table<DataType> dt_table{numbers.size(), 2}; + for (size_t i = 0; i < dt_table.numberOfRows(); ++i) { + for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) { for (size_t k = 0; k < DataType::Dimension; ++k) { - arrays[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k); + dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k); } } } group .createDataSet(name, - HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}}, + HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}}, test_TinyVectorDataType<DataType>{}) - .template write_raw<double>(&(arrays[0][0][0]), test_TinyVectorDataType<DataType>{}); + .template write_raw<double>(&(dt_table[0][0][0]), test_TinyVectorDataType<DataType>{}); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -1766,41 +1768,41 @@ TEST_CASE("ParallelChecker_read", "[dev]") ParallelCheckerTester pc_tester; pc_tester.setTag(tag); - FaceArray<DataType> arrays{connectivity, 2}; + FaceArray<DataType> dt_face_array{connectivity, 2}; FaceValue<const int> face_number = connectivity.faceNumber(); for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { - for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) { + for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) { for (size_t k = 0; k < DataType::Dimension; ++k) { - arrays[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k); + dt_face_array[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k); } } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - FaceArray<DataType> not_sync = copy(arrays); + FaceArray<DataType> not_sync = copy(dt_face_array); FaceValue<const bool> is_owned = connectivity.faceIsOwned(); if (parallel::rank() == 0) { for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) { @@ -1817,7 +1819,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> different = copy(arrays); + FaceArray<DataType> different = copy(dt_face_array); bool has_difference = false; if (parallel::rank() == 0) { FaceValue<const bool> is_owned = connectivity.faceIsOwned(); @@ -1845,11 +1847,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - FaceArray<DataType> arrays{connectivity, 1}; - arrays.fill(zero); + FaceArray<DataType> dt_face_array2{connectivity, 1}; + dt_face_array2.fill(zero); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data"); } { @@ -1890,19 +1892,19 @@ TEST_CASE("ParallelChecker_read", "[dev]") rows_map.size()}}) .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0])); - Table<double> arrays{rows_map[rows_map.size() - 1], 2}; + Table<double> double_table{rows_map[rows_map.size() - 1], 2}; for (size_t i = 0; i < numbers.size(); ++i) { for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) { const size_t j = i_row - rows_map[i]; for (size_t k = 0; k < 2; ++k) { - arrays[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j); + double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j); } } } group - .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), - arrays.numberOfColumns()}}) - .write_raw<double>(&(arrays(0, 0))); + .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(), + double_table.numberOfColumns()}}) + .write_raw<double>(&(double_table(0, 0))); group.createAttribute("filename", source_location.filename()); group.createAttribute("line", source_location.line()); @@ -1919,41 +1921,41 @@ TEST_CASE("ParallelChecker_read", "[dev]") auto cell_to_node_matrix = connectivity.cellToNodeMatrix(); - NodeArrayPerCell<double> arrays{connectivity, 2}; + NodeArrayPerCell<double> double_node_array_per_cell{connectivity, 2}; CellValue<const int> cell_number = connectivity.cellNumber(); for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { for (size_t j = 0; j < cell_to_node_matrix[cell_id].size(); ++j) { for (size_t k = 0; k < 2; ++k) { - arrays[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j); + double_node_array_per_cell[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j); } } } - REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location)); + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different name in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location)); + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "not_sin", source_location)); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source file in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", SourceLocation{"other-source-file", source_location.line(), source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source line in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", SourceLocation{source_location.filename(), source_location.line() + 100, source_location.column(), source_location.function()})); pc_tester.setTag(tag); UNSCOPED_INFO("can have different source function in ref"); - REQUIRE_NOTHROW(parallel_check(arrays, "sin", + REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", SourceLocation{source_location.filename(), source_location.line(), source_location.column(), "foo"})); if (parallel::size() > 1) { - NodeArrayPerCell<double> not_sync = copy(arrays); + NodeArrayPerCell<double> not_sync = copy(double_node_array_per_cell); CellValue<const bool> is_owned = connectivity.cellIsOwned(); if (parallel::rank() == 0) { for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) { @@ -1970,7 +1972,7 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - NodeArrayPerCell<double> different = copy(arrays); + NodeArrayPerCell<double> different = copy(double_node_array_per_cell); bool has_difference = false; if (parallel::rank() == 0) { CellValue<const bool> is_owned = connectivity.cellIsOwned(); @@ -1998,11 +2000,11 @@ TEST_CASE("ParallelChecker_read", "[dev]") } { - CellArray<double> arrays{connectivity, 1}; - arrays.fill(0); + CellArray<double> double_cell_array{connectivity, 1}; + double_cell_array.fill(0); pc_tester.setTag(tag); - REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data"); + REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data"); } { diff --git a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp index 39b5012700f9b8d8293829b4ccff65dad93036f6..f503eaac5865ac213c3140cae9b1afb9b30a33b7 100644 --- a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp +++ b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp @@ -105,11 +105,13 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]") primal_to_dual_connectivity_mapper.toDualCell(primal_edge_value, dual_from_primal_edge_value); - bool is_same = true; - for (CellId cell_id = 0; cell_id < primal_connectivity.numberOfCells(); ++cell_id) { - is_same &= (dual_from_primal_edge_value[cell_id] == dual_from_primal_face_value[cell_id]); + { + bool is_same = true; + for (CellId cell_id = 0; cell_id < primal_connectivity.numberOfCells(); ++cell_id) { + is_same &= (dual_from_primal_edge_value[cell_id] == dual_from_primal_face_value[cell_id]); + } + REQUIRE(is_same); } - REQUIRE(is_same); { bool is_same = true; diff --git a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp index 2950b0d40c9be3330aecc397e228b9e81bb08682..6a753b49fecf2b89f420b28f8c61411b01fe14df 100644 --- a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp +++ b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp @@ -178,13 +178,6 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]") primal_edge_value[edge_id] = 2 + (primal_edge_to_cell_matrix[edge_id].size() == 1); }); - NodeValue<size_t> primal_node_value{primal_connectivity}; - primal_node_value.fill(2); - - NodeValue<size_t> dual_from_primal_value{dual_connectivity}; - primal_to_dual_connectivity_mapper.toDualNode(primal_node_value, primal_edge_value, primal_cell_value, - dual_from_primal_value); - { const auto& dual_node_to_edge_matrix = dual_connectivity.nodeToEdgeMatrix(); auto dual_node_number = dual_connectivity.nodeNumber(); diff --git a/tests/test_SmallArray.cpp b/tests/test_SmallArray.cpp index 2565ac0d7eb82beb828076840fda74d9b3ffbfa5..66191faa55c8890aae7901eacfe96cfd725da149 100644 --- a/tests/test_SmallArray.cpp +++ b/tests/test_SmallArray.cpp @@ -286,67 +286,67 @@ TEST_CASE("SmallArray", "[utils]") SECTION("checking for SmallArray reductions") { - SmallArray<int> a(10); - a[0] = 13; - a[1] = 1; - a[2] = 8; - a[3] = -3; - a[4] = 23; - a[5] = -1; - a[6] = 13; - a[7] = 0; - a[8] = 12; - a[9] = 9; + SmallArray<int> array(10); + array[0] = 13; + array[1] = 1; + array[2] = 8; + array[3] = -3; + array[4] = 23; + array[5] = -1; + array[6] = 13; + array[7] = 0; + array[8] = 12; + array[9] = 9; SECTION("Min") { - REQUIRE(min(a) == -3); + REQUIRE(min(array) == -3); } SECTION("Max") { - REQUIRE(max(a) == 23); + REQUIRE(max(array) == 23); } SECTION("Sum") { - REQUIRE((sum(a) == 75)); + REQUIRE((sum(array) == 75)); } SECTION("TinyVector Sum") { using N2 = TinyVector<2, int>; - SmallArray<N2> b(10); - b[0] = N2{13, 2}; - b[1] = N2{1, 3}; - b[2] = N2{8, -2}; - b[3] = N2{-3, 2}; - b[4] = N2{23, 4}; - b[5] = N2{-1, -3}; - b[6] = N2{13, 17}; - b[7] = N2{0, 9}; - b[8] = N2{12, 13}; - b[9] = N2{9, -17}; - - REQUIRE((sum(b) == N2{75, 28})); + SmallArray<N2> N2_array(10); + N2_array[0] = N2{13, 2}; + N2_array[1] = N2{1, 3}; + N2_array[2] = N2{8, -2}; + N2_array[3] = N2{-3, 2}; + N2_array[4] = N2{23, 4}; + N2_array[5] = N2{-1, -3}; + N2_array[6] = N2{13, 17}; + N2_array[7] = N2{0, 9}; + N2_array[8] = N2{12, 13}; + N2_array[9] = N2{9, -17}; + + REQUIRE((sum(N2_array) == N2{75, 28})); } SECTION("TinyMatrix Sum") { using N22 = TinyMatrix<2, 2, int>; - SmallArray<N22> b(10); - b[0] = N22{13, 2, 0, 1}; - b[1] = N22{1, 3, 6, 3}; - b[2] = N22{8, -2, -1, 21}; - b[3] = N22{-3, 2, 5, 12}; - b[4] = N22{23, 4, 7, 1}; - b[5] = N22{-1, -3, 33, 11}; - b[6] = N22{13, 17, 12, 13}; - b[7] = N22{0, 9, 1, 14}; - b[8] = N22{12, 13, -3, -71}; - b[9] = N22{9, -17, 0, 16}; - - REQUIRE((sum(b) == N22{75, 28, 60, 21})); + SmallArray<N22> N22_array(10); + N22_array[0] = N22{13, 2, 0, 1}; + N22_array[1] = N22{1, 3, 6, 3}; + N22_array[2] = N22{8, -2, -1, 21}; + N22_array[3] = N22{-3, 2, 5, 12}; + N22_array[4] = N22{23, 4, 7, 1}; + N22_array[5] = N22{-1, -3, 33, 11}; + N22_array[6] = N22{13, 17, 12, 13}; + N22_array[7] = N22{0, 9, 1, 14}; + N22_array[8] = N22{12, 13, -3, -71}; + N22_array[9] = N22{9, -17, 0, 16}; + + REQUIRE((sum(N22_array) == N22{75, 28, 60, 21})); } } #endif // NDEBUG diff --git a/tests/test_SmallMatrix.cpp b/tests/test_SmallMatrix.cpp index 9712e13e330ee84adc55afeee1bcf81150312bc9..131b1e1f2fc4ae64622d410ac8e38ea051e9c9a7 100644 --- a/tests/test_SmallMatrix.cpp +++ b/tests/test_SmallMatrix.cpp @@ -364,53 +364,50 @@ TEST_CASE("SmallMatrix", "[algebra]") SECTION("output with signaling NaN") { - SmallMatrix<double> A(2, 3); - A(0, 0) = 1; - A(0, 2) = 3; - A(1, 0) = 2; - std::ostringstream A_ost; - A_ost << A; + SmallMatrix<double> C(2, 3); + C(0, 0) = 1; + C(0, 2) = 3; + C(1, 0) = 2; + std::ostringstream C_ost; + C_ost << C; std::ostringstream ref_ost; ref_ost << "0| 0:1 1:nan 2:3\n"; ref_ost << "1| 0:2 1:nan 2:nan\n"; - REQUIRE(A_ost.str() == ref_ost.str()); + REQUIRE(C_ost.str() == ref_ost.str()); } - // SECTION("checking for bounds violation") - // { - // REQUIRE_THROWS_AS(A(3, 0), AssertError); - // REQUIRE_THROWS_AS(A(0, 4), AssertError); - - // REQUIRE_THROWS_AS(getMinor(A, 3, 0), AssertError); - // REQUIRE_THROWS_AS(getMinor(A, 0, 4), AssertError); - - // const TinyMatrix<3, 4, int>& constA = A; - // REQUIRE_THROWS_AS(constA(3, 0), AssertError); - // REQUIRE_THROWS_AS(constA(0, 4), AssertError); - // } - - // SECTION("checking for nan initialization") - // { - // TinyMatrix<3, 4, double> B; - - // for (size_t i = 0; i < B.numberOfRows(); ++i) { - // for (size_t j = 0; j < B.numberOfColumns(); ++j) { - // REQUIRE(std::isnan(B(i, j))); - // } - // } - // } - - // SECTION("checking for bad initialization") - // { - // TinyMatrix<3, 4, int> B; - - // for (size_t i = 0; i < B.numberOfRows(); ++i) { - // for (size_t j = 0; j < B.numberOfColumns(); ++j) { - // REQUIRE(B(i, j) == std::numeric_limits<int>::max() / 2); - // } - // } - // } + SECTION("checking for bounds violation") + { + REQUIRE_THROWS_AS(A(3, 0), AssertError); + REQUIRE_THROWS_AS(A(0, 4), AssertError); + + const SmallMatrix<int>& constA = A; + REQUIRE_THROWS_AS(constA(3, 0), AssertError); + REQUIRE_THROWS_AS(constA(0, 4), AssertError); + } + + SECTION("checking for nan initialization") + { + SmallMatrix<double> C(3, 4); + + for (size_t i = 0; i < C.numberOfRows(); ++i) { + for (size_t j = 0; j < C.numberOfColumns(); ++j) { + REQUIRE(std::isnan(C(i, j))); + } + } + } + + SECTION("checking for bad initialization") + { + SmallMatrix<int> C(3, 5); + + for (size_t i = 0; i < C.numberOfRows(); ++i) { + for (size_t j = 0; j < C.numberOfColumns(); ++j) { + REQUIRE(C(i, j) == std::numeric_limits<int>::max() / 2); + } + } + } #endif // NDEBUG } diff --git a/tests/test_Socket.cpp b/tests/test_Socket.cpp index 3293f6b8d7fe18db31a0db1aaac0ae30474d8808..a4ca9f6a4186e7edf326b433b80bbd2117ecdee9 100644 --- a/tests/test_Socket.cpp +++ b/tests/test_Socket.cpp @@ -29,10 +29,10 @@ TEST_CASE("Socket", "[utils]") Socket client = acceptClientSocket(server); - size_t vector_size = [&] { - size_t vector_size; - read(client, vector_size); - return vector_size; + const size_t vector_size = [&] { + size_t read_vector_size; + read(client, read_vector_size); + return read_vector_size; }(); REQUIRE(vector_size == 4); diff --git a/tests/test_TinyMatrix.cpp b/tests/test_TinyMatrix.cpp index 03d3bbe5dc0ad69655cda5d3ae764d8e770b0d60..80159a021b54ebb162d339be2bbd5195aec815a0 100644 --- a/tests/test_TinyMatrix.cpp +++ b/tests/test_TinyMatrix.cpp @@ -173,18 +173,18 @@ TEST_CASE("TinyMatrix", "[algebra]") SECTION("checking for cofactors") { - TinyMatrix<3, 3, int> A(1, 2, 3, 4, 5, 6, 7, 8, 9); - REQUIRE(cofactor(A, 0, 0) == (5 * 9 - 8 * 6)); - REQUIRE(cofactor(A, 1, 0) == -(2 * 9 - 8 * 3)); - REQUIRE(cofactor(A, 2, 0) == (2 * 6 - 5 * 3)); - - REQUIRE(cofactor(A, 0, 1) == -(4 * 9 - 7 * 6)); - REQUIRE(cofactor(A, 1, 1) == (1 * 9 - 7 * 3)); - REQUIRE(cofactor(A, 2, 1) == -(1 * 6 - 4 * 3)); - - REQUIRE(cofactor(A, 0, 2) == (4 * 8 - 5 * 7)); - REQUIRE(cofactor(A, 1, 2) == -(1 * 8 - 7 * 2)); - REQUIRE(cofactor(A, 2, 2) == (1 * 5 - 4 * 2)); + TinyMatrix<3, 3, int> square_A(1, 2, 3, 4, 5, 6, 7, 8, 9); + REQUIRE(cofactor(square_A, 0, 0) == (5 * 9 - 8 * 6)); + REQUIRE(cofactor(square_A, 1, 0) == -(2 * 9 - 8 * 3)); + REQUIRE(cofactor(square_A, 2, 0) == (2 * 6 - 5 * 3)); + + REQUIRE(cofactor(square_A, 0, 1) == -(4 * 9 - 7 * 6)); + REQUIRE(cofactor(square_A, 1, 1) == (1 * 9 - 7 * 3)); + REQUIRE(cofactor(square_A, 2, 1) == -(1 * 6 - 4 * 3)); + + REQUIRE(cofactor(square_A, 0, 2) == (4 * 8 - 5 * 7)); + REQUIRE(cofactor(square_A, 1, 2) == -(1 * 8 - 7 * 2)); + REQUIRE(cofactor(square_A, 2, 2) == (1 * 5 - 4 * 2)); } SECTION("checking for determinant calculations") @@ -294,17 +294,17 @@ TEST_CASE("TinyMatrix", "[algebra]") #ifndef NDEBUG SECTION("output with signaling NaN") { - TinyMatrix<2, 3> A; - A(0, 0) = 1; - A(0, 2) = 3; - A(1, 0) = 2; - std::ostringstream A_ost; - A_ost << A; + TinyMatrix<2, 3> C; + C(0, 0) = 1; + C(0, 2) = 3; + C(1, 0) = 2; + std::ostringstream C_ost; + C_ost << C; std::ostringstream ref_ost; ref_ost << "[[1,nan,3],[2,nan,nan]]"; - REQUIRE(A_ost.str() == ref_ost.str()); + REQUIRE(C_ost.str() == ref_ost.str()); } SECTION("checking for bounds violation") @@ -322,22 +322,22 @@ TEST_CASE("TinyMatrix", "[algebra]") SECTION("checking for nan initialization") { - TinyMatrix<3, 4, double> B; + TinyMatrix<3, 4, double> C; - for (size_t i = 0; i < B.numberOfRows(); ++i) { - for (size_t j = 0; j < B.numberOfColumns(); ++j) { - REQUIRE(std::isnan(B(i, j))); + for (size_t i = 0; i < C.numberOfRows(); ++i) { + for (size_t j = 0; j < C.numberOfColumns(); ++j) { + REQUIRE(std::isnan(C(i, j))); } } } SECTION("checking for bad initialization") { - TinyMatrix<3, 4, int> B; + TinyMatrix<3, 4, int> C; - for (size_t i = 0; i < B.numberOfRows(); ++i) { - for (size_t j = 0; j < B.numberOfColumns(); ++j) { - REQUIRE(B(i, j) == std::numeric_limits<int>::max() / 2); + for (size_t i = 0; i < C.numberOfRows(); ++i) { + for (size_t j = 0; j < C.numberOfColumns(); ++j) { + REQUIRE(C(i, j) == std::numeric_limits<int>::max() / 2); } } } diff --git a/tests/test_TinyVector.cpp b/tests/test_TinyVector.cpp index 6a3942e84b1c95680d8c63080b5c8b37330f139b..12abadf46f3952ee8cceb8b4e9aa4b33c4ee88ed 100644 --- a/tests/test_TinyVector.cpp +++ b/tests/test_TinyVector.cpp @@ -89,33 +89,33 @@ TEST_CASE("TinyVector", "[algebra]") SECTION("min/max") { - TinyVector<5, int> u{1, 7, 6, 2, 9}; + TinyVector<5, int> u1{1, 7, 6, 2, 9}; - REQUIRE(min(u) == 1); - REQUIRE(max(u) == 9); - REQUIRE(min(-u) == -9); - REQUIRE(max(-u) == -1); + REQUIRE(min(u1) == 1); + REQUIRE(max(u1) == 9); + REQUIRE(min(-u1) == -9); + REQUIRE(max(-u1) == -1); - TinyVector<5, int> v{1, 11, 6, -2, 9}; + TinyVector<5, int> u2{1, 11, 6, -2, 9}; - REQUIRE(min(v) == -2); - REQUIRE(max(v) == 11); - REQUIRE(min(-v) == -11); - REQUIRE(max(-v) == 2); + REQUIRE(min(u2) == -2); + REQUIRE(max(u2) == 11); + REQUIRE(min(-u2) == -11); + REQUIRE(max(-u2) == 2); } #ifndef NDEBUG SECTION("output with signaling NaN") { - TinyVector<3> x; - x[1] = 1; - std::ostringstream x_ost; - x_ost << x; + TinyVector<3> X; + X[1] = 1; + std::ostringstream X_ost; + X_ost << X; std::ostringstream ref_ost; ref_ost << "[nan,1,nan]"; - REQUIRE(x_ost.str() == ref_ost.str()); + REQUIRE(X_ost.str() == ref_ost.str()); } SECTION("checking for bounds validation")