clang-tidy: Address cppcoreguidelines-missing-std-forward

include/libcommute/expression/expression.hpp

@@ -25,6 +25,7 @@
 #include <memory>
 #include <tuple>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace libcommute {
@@ -178,7 +179,7 @@ template <typename ScalarType, typename... IndexTypes> class expression {
     expression_t<NewScalarType> res;
     auto& res_mons = res.get_monomials();
     for(auto const& m : expr.monomials_) {
-      auto val = f(m.first, m.second);
+      auto val = std::forward<F>(f)(m.first, m.second);
       if(!scalar_traits<NewScalarType>::is_zero(val))
         res_mons.emplace_hint(res_mons.end(), m.first, val);
     }
@@ -741,6 +742,7 @@ template <typename ScalarType, typename... IndexTypes> class expression {
   // Multiplication by scalar (postfix form)
   // mul_type<ScalarType, S> == ScalarType
   template <typename S>
+  // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
   inline expression mul_const_postfix_impl(S&& alpha, std::true_type) const {
     expression res(*this);
     for(auto& p : res.monomials_)
@@ -752,6 +754,7 @@ template <typename ScalarType, typename... IndexTypes> class expression {
   // mul_type<ScalarType, S> != ScalarType
   template <typename S>
   inline expression_t<mul_type<ScalarType, S>>
+  // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
   mul_const_postfix_impl(S&& alpha, std::false_type) const {
     expression_t<mul_type<ScalarType, S>> res;
     auto& res_mons = res.get_monomials();
@@ -763,6 +766,7 @@ template <typename ScalarType, typename... IndexTypes> class expression {
   // Multiplication by scalar (prefix form)
   // mul_type<S, ScalarType> == ScalarType
   template <typename S>
+  // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
   inline expression mul_const_prefix_impl(S&& alpha, std::true_type) const {
     expression res(*this);
     for(auto& p : res.monomials_)
@@ -774,6 +778,7 @@ template <typename ScalarType, typename... IndexTypes> class expression {
   // mul_type<S, ScalarType> != ScalarType
   template <typename S>
   inline expression_t<mul_type<S, ScalarType>>
+  // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
   mul_const_prefix_impl(S&& alpha, std::false_type) const {
     expression_t<mul_type<S, ScalarType>> res;
     auto& res_mons = res.get_monomials();

include/libcommute/expression/factories.hpp

@@ -60,7 +60,7 @@ DEFINE_FACTORY(c_dag, (static_indices::make_fermion(true, INDICES)))
 // Annihilation operator
 DEFINE_FACTORY(c, (static_indices::make_fermion(false, INDICES)))
 // Number of fermions
-DEFINE_FACTORY(n,
+DEFINE_FACTORY(n, // NOLINT(cppcoreguidelines-missing-std-forward)
                (static_indices::make_fermion(true, indices...)),
                (static_indices::make_fermion(false, indices...)))
 
@@ -109,26 +109,26 @@ DEFINE_FACTORY_SPIN(S_z,
 
 template <typename... IndexTypes>
 inline expression<std::complex<double>, c_str_to_string_t<IndexTypes>...>
-S_x(IndexTypes&&... indices) {
+S_x(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0.5) *
          (static_indices::S_p(indices...) + static_indices::S_m(indices...));
 }
 template <typename... IndexTypes>
 inline expression<std::complex<double>, c_str_to_string_t<IndexTypes>...>
-S_y(IndexTypes&&... indices) {
+S_y(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0, -0.5) *
          (static_indices::S_p(indices...) - static_indices::S_m(indices...));
 }
 
 template <int Mult, typename... IndexTypes>
 inline expression<std::complex<double>, c_str_to_string_t<IndexTypes>...>
-S_x(IndexTypes&&... indices) {
+S_x(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0.5) * (static_indices::S_p<Mult>(indices...) +
                                       static_indices::S_m<Mult>(indices...));
 }
 template <int Mult, typename... IndexTypes>
 inline expression<std::complex<double>, c_str_to_string_t<IndexTypes>...>
-S_y(IndexTypes&&... indices) {
+S_y(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0, -0.5) *
          (static_indices::S_p<Mult>(indices...) -
           static_indices::S_m<Mult>(indices...));

include/libcommute/expression/factories_dyn.hpp

@@ -62,7 +62,7 @@ DEFINE_FACTORY(c_dag, (dynamic_indices::make_fermion(true, INDICES)))
 // Annihilation operator
 DEFINE_FACTORY(c, (dynamic_indices::make_fermion(false, INDICES)))
 // Number of fermions
-DEFINE_FACTORY(n,
+DEFINE_FACTORY(n, // NOLINT(cppcoreguidelines-missing-std-forward)
                (dynamic_indices::make_fermion(true, indices...)),
                (dynamic_indices::make_fermion(false, indices...)))
 
@@ -112,26 +112,26 @@ DEFINE_FACTORY_SPIN(S_z,
 
 template <typename... IndexTypes>
 inline expression<std::complex<double>, dyn_indices>
-S_x(IndexTypes&&... indices) {
+S_x(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0.5) *
          (dynamic_indices::S_p(indices...) + dynamic_indices::S_m(indices...));
 }
 template <typename... IndexTypes>
 inline expression<std::complex<double>, dyn_indices>
-S_y(IndexTypes&&... indices) {
+S_y(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0, -0.5) *
          (dynamic_indices::S_p(indices...) - dynamic_indices::S_m(indices...));
 }
 
 template <int Mult, typename... IndexTypes>
 inline expression<std::complex<double>, dyn_indices>
-S_x(IndexTypes&&... indices) {
+S_x(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0.5) * (dynamic_indices::S_p<Mult>(indices...) +
                                       dynamic_indices::S_m<Mult>(indices...));
 }
 template <int Mult, typename... IndexTypes>
 inline expression<std::complex<double>, dyn_indices>
-S_y(IndexTypes&&... indices) {
+S_y(IndexTypes&&... indices) { // NOLINT(cppcoreguidelines-missing-std-forward)
   return std::complex<double>(0, -0.5) *
          (dynamic_indices::S_p<Mult>(indices...) -
           dynamic_indices::S_m<Mult>(indices...));

include/libcommute/expression/monomial.hpp

@@ -41,7 +41,8 @@ template <typename... IndexTypes> class monomial {
   template <typename GenType1, typename... GenTypesTail>
   void constructor_impl(GenType1&& generator, GenTypesTail&&... more_gens) {
     using gen1_t = typename std::remove_reference<GenType1>::type;
-    generators_.emplace_back(make_unique<gen1_t>(generator));
+    generators_.emplace_back(
+        make_unique<gen1_t>(std::forward<GenType1>(generator)));
     constructor_impl(std::forward<GenTypesTail>(more_gens)...);
   }
   void constructor_impl() {}
@@ -211,7 +212,7 @@ template <typename... IndexTypes> class monomial {
   friend monomial concatenate(PartTypes&&... parts) {
     monomial res;
     res.generators_.reserve(concat_parts_total_size(parts...));
-    res.concat_impl(parts...);
+    res.concat_impl(std::forward<PartTypes>(parts)...);
     return res;
   }
 
@@ -286,10 +287,12 @@ template <typename... IndexTypes> class monomial {
   // Append generators from a mixed list of monomials and monomial ranges
   template <typename P1, typename... PTail>
   void concat_impl(P1&& p1, PTail&&... p_tail) {
-    append(p1);
+    append(std::forward<P1>(p1));
     concat_impl(std::forward<PTail>(p_tail)...);
   }
-  template <typename P1> void concat_impl(P1&& p1) { append(p1); }
+  template <typename P1> void concat_impl(P1&& p1) {
+    append(std::forward<P1>(p1));
+  }
 
   std::vector<gen_ptr_type> generators_;
 };

include/libcommute/loperator/hilbert_space.hpp

@@ -127,7 +127,8 @@ template <typename... IndexTypes> class hilbert_space {
                          ESConstructor&& es_constr = {}) {
     for(auto const& m : expr) {
       for(auto const& g : m.monomial) {
-        elementary_spaces_.emplace(es_constr(g), bit_range_t(0, 0));
+        elementary_spaces_.emplace(std::forward<ESConstructor>(es_constr)(g),
+                                   bit_range_t(0, 0));
       }
     }
     recompute_bit_ranges();
@@ -234,7 +235,7 @@ template <typename... IndexTypes> class hilbert_space {
   inline friend void foreach(hilbert_space const& hs, Functor&& f) {
     sv_index_type d = hs.dim();
     for(sv_index_type i = 0; i < d; ++i) {
-      f(i);
+      std::forward<Functor>(f)(i);
     }
   }
 

include/libcommute/loperator/loperator.hpp

@@ -123,13 +123,14 @@ class loperator : public loperator_base<ScalarType, AlgebraIDs...> {
 private:
   // Implementation details of operator()
   template <typename SrcStateVector, typename DstStateVector>
+  // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
   inline void act_impl(SrcStateVector&& src, DstStateVector&& dst) const {
 
     // A workaround for GCC Bug 58972
     // (base::m_actions() would be inaccessible from within the lambda below)
     auto const& m_act = base::m_actions();
 
-    foreach(src,
+    foreach(std::forward<SrcStateVector>(src),
             [&](sv_index_type in_index,
                 element_type_t<remove_cvref_t<SrcStateVector>> const& a) {
               for(auto const& ma : m_act) {

include/libcommute/loperator/mapped_basis_view.hpp

@@ -78,9 +78,10 @@ inline void update_add_element(mapped_basis_view<StateVector, Ref>& view,
 
 // update_add_element() is not defined for constant views
 template <typename StateVector, bool Ref, typename T>
-inline void update_add_element(mapped_basis_view<StateVector const, Ref>&,
-                               sv_index_type,
-                               T&&) {
+inline void
+update_add_element(mapped_basis_view<StateVector const, Ref>&,
+                   sv_index_type,
+                   T&&) { // NOLINT(cppcoreguidelines-missing-std-forward)
   static_assert(!std::is_same<StateVector, StateVector>::value,
                 "update_add_element() is not supported for constant views");
 }
@@ -119,7 +120,7 @@ inline void foreach(mapped_basis_view<StateVector, Ref> const& view,
     if(scalar_traits<T>::is_zero(a))
       continue;
     else
-      f(p.first, a);
+      std::forward<Functor>(f)(p.first, a);
   }
 }
 

include/libcommute/loperator/n_fermion_sector_view.hpp

@@ -177,7 +177,7 @@ struct for_each_composition {
   // Apply 'f' to each composition
   template <typename F> void operator()(F&& f) const {
     if(params.N_counted == 0) {
-      f(lambdas);
+      std::forward<F>(f)(lambdas);
       return;
     }
 
@@ -336,9 +336,10 @@ inline void update_add_element(n_fermion_sector_view<StateVector, Ref>& view,
 
 // update_add_element() is not defined for constant views
 template <typename StateVector, bool Ref, typename T>
-inline void update_add_element(n_fermion_sector_view<StateVector const, Ref>&,
-                               sv_index_type,
-                               T&&) {
+inline void
+update_add_element(n_fermion_sector_view<StateVector const, Ref>&,
+                   sv_index_type,
+                   T&&) { // NOLINT(cppcoreguidelines-missing-std-forward)
   static_assert(!std::is_same<StateVector, StateVector>::value,
                 "update_add_element() is not supported for constant views");
 }
@@ -366,8 +367,9 @@ inline void set_zeros(n_fermion_sector_view<StateVector const, Ref>&) {
 // Apply functor `f` to all index/non-zero amplitude pairs
 // in the adapted StateVector object
 template <typename StateVector, bool Ref, typename Functor>
-inline void foreach(n_fermion_sector_view<StateVector, Ref> const& view,
-                    Functor&& f) {
+inline void
+foreach(n_fermion_sector_view<StateVector, Ref> const& view,
+        Functor&& f) { // NOLINT(cppcoreguidelines-missing-std-forward)
   if(view.M == 0 && view.M_nonfermion == 0) return;
 
   auto dim_nonfermion = detail::pow2(view.M_nonfermion);
@@ -385,7 +387,7 @@ inline void foreach(n_fermion_sector_view<StateVector, Ref> const& view,
       if(scalar_traits<T>::is_zero(a))
         continue;
       else
-        f(view.comp_to_index(lambdas, index_nf), a);
+        std::forward<Functor>(f)(view.comp_to_index(lambdas, index_nf), a);
     }
   });
 }
@@ -551,7 +553,7 @@ struct for_each_composition_multi {
   // Apply 'f' to each composition
   template <typename F> void operator()(F&& f) const {
     if(s_min == -1) { // All compositions are empty
-      f(lambdas);
+      std::forward<F>(f)(lambdas);
       return;
     }
 
@@ -580,7 +582,7 @@ struct for_each_composition_multi {
 
       if(s == s_max &&
          static_cast<unsigned int>(i + 1) == sector_params[s].N_counted) {
-        f(lambdas);
+        std::forward<F>(f)(lambdas);
       } else {
         ++i;
         if(i == static_cast<int>(sector_params[s].N_counted)) {
@@ -918,7 +920,7 @@ template <typename StateVector, bool Ref, typename T>
 inline void
 update_add_element(n_fermion_multisector_view<StateVector const, Ref>&,
                    sv_index_type,
-                   T&&) {
+                   T&&) { // NOLINT(cppcoreguidelines-missing-std-forward)
   static_assert(!std::is_same<StateVector, StateVector>::value,
                 "update_add_element() is not supported for constant views");
 }
@@ -947,8 +949,9 @@ inline void set_zeros(n_fermion_multisector_view<StateVector const, Ref>&) {
 // Apply functor `f` to all index/non-zero amplitude pairs
 // in the adapted StateVector object
 template <typename StateVector, bool Ref, typename Functor>
-inline void foreach(n_fermion_multisector_view<StateVector, Ref> const& view,
-                    Functor&& f) {
+inline void
+foreach(n_fermion_multisector_view<StateVector, Ref> const& view,
+        Functor&& f) { // NOLINT(cppcoreguidelines-missing-std-forward)
   if(view.sector_params.size() == 0 && view.M_nonmultisector == 0) return;
 
   auto dim_nonmultisector = detail::pow2(view.M_nonmultisector);
@@ -969,7 +972,7 @@ inline void foreach(n_fermion_multisector_view<StateVector, Ref> const& view,
       if(scalar_traits<T>::is_zero(a))
         continue;
       else
-        f(view.comp_to_index(lambdas, index_nms), a);
+        std::forward<Functor>(f)(view.comp_to_index(lambdas, index_nms), a);
     }
   });
 }

include/libcommute/loperator/space_partition.hpp

@@ -300,7 +300,7 @@ class space_partition {
   // and index of the subspace this basis state belongs to.
   template <typename F> friend void foreach(space_partition const& sp, F&& f) {
     for(sv_index_type n = 0; n < sp.dim(); ++n) {
-      f(n, sp[n]);
+      std::forward<F>(f)(n, sp[n]);
     }
   }
 

include/libcommute/loperator/sparse_state_vector.hpp

@@ -18,6 +18,7 @@
 
 #include <cassert>
 #include <unordered_map>
+#include <utility>
 
 namespace libcommute {
 
@@ -59,9 +60,10 @@ template <typename ScalarType> class sparse_state_vector {
   update_add_element(sparse_state_vector& sv, sv_index_type n, T&& value) {
     auto it = sv.data_.find(n);
     if(it == sv.data_.end()) {
-      if(!scalar_traits<ScalarType>::is_zero(value)) sv.data_[n] = value;
+      if(!scalar_traits<ScalarType>::is_zero(value))
+        sv.data_[n] = std::forward<T>(value);
     } else {
-      it->second += value;
+      it->second += std::forward<T>(value);
       if(scalar_traits<ScalarType>::is_zero(it->second)) sv.data_.erase(it);
     }
   }
@@ -78,7 +80,7 @@ template <typename ScalarType> class sparse_state_vector {
   template <typename Functor>
   inline friend void foreach(sparse_state_vector const& sv, Functor&& f) {
     for(auto const& p : sv.data_)
-      f(p.first, p.second);
+      std::forward<Functor>(f)(p.first, p.second);
   }
 
   // Force removal of all zero amplitudes from the storage
@@ -94,7 +96,7 @@ template <typename ScalarType> class sparse_state_vector {
   // Force removal of all amplitudes meeting a specified criterion
   template <typename UnaryPredicate> inline void prune(UnaryPredicate&& p) {
     for(auto it = data_.begin(); it != data_.end();) {
-      if(p(it->second))
+      if(std::forward<UnaryPredicate>(p)(it->second))
         it = data_.erase(it);
       else
         ++it;

include/libcommute/loperator/state_vector.hpp

@@ -17,6 +17,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <utility>
 #include <vector>
 
 namespace libcommute {
@@ -74,7 +75,7 @@ inline void foreach(std::vector<T> const& sv, Functor&& f) {
     if(scalar_traits<T>::is_zero(a))
       continue;
     else
-      f(n, a);
+      std::forward<Functor>(f)(n, a);
   }
 }