Fix performance-unnecessary-value-param

Author: schnellerhase

cpp/basix/dof-transformations.cpp

@@ -368,8 +368,8 @@ std::pair<std::vector<T>, std::array<std::size_t, 2>> compute_transformation(
     std::array<std::vector<mdspan_t<const T, 4>>, 4> M,
     mdspan_t<const T, 2> coeffs, const mdarray_t<T, 2>& J, T detJ,
     const mdarray_t<T, 2>& K,
-    std::function<std::array<T, 3>(std::span<const T>)> map_point, int degree,
-    int tdim, int entity, std::size_t vs, const maps::type map_type,
+    const std::function<std::array<T, 3>(std::span<const T>)>& map_point,
+    int degree, int tdim, int entity, std::size_t vs, const maps::type map_type,
     const polyset::type ptype)
 {
   if (x[tdim].size() == 0 or x[tdim][entity].extent(0) == 0)
@@ -500,9 +500,8 @@ template <std::floating_point T>
 std::map<cell::type, std::pair<std::vector<T>, std::array<std::size_t, 3>>>
 doftransforms::compute_entity_transformations(
     cell::type cell_type,
-    std::array<std::vector<md::mdspan<const T, md::dextents<std::size_t, 2>>>,
-               4>
-        x,
+    const std::array<
+        std::vector<md::mdspan<const T, md::dextents<std::size_t, 2>>>, 4>& x,
     std::array<std::vector<md::mdspan<const T, md::dextents<std::size_t, 4>>>,
                4>
         M,
@@ -540,8 +539,8 @@ template std::map<cell::type,
                   std::pair<std::vector<float>, std::array<std::size_t, 3>>>
 doftransforms::compute_entity_transformations(
     cell::type,
-    std::array<
-        std::vector<md::mdspan<const float, md::dextents<std::size_t, 2>>>, 4>,
+    const std::array<
+        std::vector<md::mdspan<const float, md::dextents<std::size_t, 2>>>, 4>&,
     std::array<
         std::vector<md::mdspan<const float, md::dextents<std::size_t, 4>>>, 4>,
     md::mdspan<const float, md::dextents<std::size_t, 2>>, int, std::size_t,
@@ -551,8 +550,9 @@ template std::map<cell::type,
                   std::pair<std::vector<double>, std::array<std::size_t, 3>>>
 doftransforms::compute_entity_transformations(
     cell::type,
-    std::array<
-        std::vector<md::mdspan<const double, md::dextents<std::size_t, 2>>>, 4>,
+    const std::array<
+        std::vector<md::mdspan<const double, md::dextents<std::size_t, 2>>>,
+        4>&,
     std::array<
         std::vector<md::mdspan<const double, md::dextents<std::size_t, 4>>>, 4>,
     md::mdspan<const double, md::dextents<std::size_t, 2>>, int, std::size_t,

cpp/basix/dof-transformations.h

@@ -40,9 +40,8 @@ template <std::floating_point T>
 std::map<cell::type, std::pair<std::vector<T>, std::array<std::size_t, 3>>>
 compute_entity_transformations(
     cell::type cell_type,
-    std::array<std::vector<md::mdspan<const T, md::dextents<std::size_t, 2>>>,
-               4>
-        x,
+    const std::array<
+        std::vector<md::mdspan<const T, md::dextents<std::size_t, 2>>>, 4>& x,
     std::array<std::vector<md::mdspan<const T, md::dextents<std::size_t, 4>>>,
                4>
         M,

cpp/basix/e-lagrange.cpp

@@ -437,7 +437,7 @@ template <std::floating_point T>
 FiniteElement<T>
 basix::element::create_lagrange(cell::type celltype, int degree,
                                 lagrange_variant variant, bool discontinuous,
-                                std::vector<int> dof_ordering)
+                                const std::vector<int>& dof_ordering)
 {
   if (celltype == cell::type::point)
   {
@@ -765,10 +765,10 @@ FiniteElement<T> basix::element::create_iso(cell::type celltype, int degree,
 //-----------------------------------------------------------------------------
 template FiniteElement<float> element::create_lagrange(cell::type, int,
                                                        lagrange_variant, bool,
-                                                       std::vector<int>);
-template FiniteElement<double> element::create_lagrange(cell::type, int,
-                                                        lagrange_variant, bool,
-                                                        std::vector<int>);
+                                                       const std::vector<int>&);
+template FiniteElement<double>
+element::create_lagrange(cell::type, int, lagrange_variant, bool,
+                         const std::vector<int>&);
 template FiniteElement<float> element::create_iso(cell::type, int,
                                                   lagrange_variant, bool);
 template FiniteElement<double> element::create_iso(cell::type, int,

cpp/basix/e-lagrange.h

@@ -21,7 +21,7 @@ namespace basix::element
 template <std::floating_point T>
 FiniteElement<T> create_lagrange(cell::type celltype, int degree,
                                  lagrange_variant variant, bool discontinuous,
-                                 std::vector<int> dof_ordering = {});
+                                 const std::vector<int>& dof_ordering = {});
 
 /// @brief Create an iso macro element on cell with given degree
 /// @param[in] celltype The element cell type

cpp/basix/finite-element.cpp

@@ -190,7 +190,7 @@ FiniteElement<T>
 basix::create_element(element::family family, cell::type cell, int degree,
                       element::lagrange_variant lvariant,
                       element::dpc_variant dvariant, bool discontinuous,
-                      std::vector<int> dof_ordering)
+                      const std::vector<int>& dof_ordering)
 {
   if (family == element::family::custom)
   {
@@ -316,11 +316,11 @@ basix::create_element(element::family family, cell::type cell, int degree,
 template basix::FiniteElement<float>
 basix::create_element(element::family, cell::type, int,
                       element::lagrange_variant, element::dpc_variant, bool,
-                      std::vector<int>);
+                      const std::vector<int>&);
 template basix::FiniteElement<double>
 basix::create_element(element::family, cell::type, int,
                       element::lagrange_variant, element::dpc_variant, bool,
-                      std::vector<int>);
+                      const std::vector<int>&);
 //-----------------------------------------------------------------------------
 template <std::floating_point T>
 FiniteElement<T>

cpp/basix/finite-element.h

@@ -1611,7 +1611,7 @@ FiniteElement<T> create_element(element::family family, cell::type cell,
                                 int degree, element::lagrange_variant lvariant,
                                 element::dpc_variant dvariant,
                                 bool discontinuous,
-                                std::vector<int> dof_ordering = {});
+                                const std::vector<int>& dof_ordering = {});
 
 /// Get the tensor product DOF ordering for an element
 /// @param[in] family The element family