Refactor function signatures to use trailing return type syntax for improved readability

Author: Q-Minh

source/pbat/common/ArgSort.h

@@ -29,7 +29,7 @@ namespace common {
  * @return Eigen::Vector<TIndex, Eigen::Dynamic>
  */
 template <std::integral TIndex, class FLess>
-Eigen::Vector<TIndex, Eigen::Dynamic> ArgSort(TIndex n, FLess less)
+auto ArgSort(TIndex n, FLess less) -> Eigen::Vector<TIndex, Eigen::Dynamic>
 {
     using IndexVectorType = Eigen::Vector<TIndex, Eigen::Dynamic>;
     IndexVectorType inds(n);

source/pbat/common/Eigen.h

@@ -25,7 +25,8 @@ namespace common {
  * @return Eigen vector adaptor
  */
 template <CContiguousArithmeticRange R>
-Eigen::Map<Eigen::Vector<std::ranges::range_value_t<R>, Eigen::Dynamic> const> ToEigen(R&& r)
+auto ToEigen(R&& r)
+    -> Eigen::Map<Eigen::Vector<std::ranges::range_value_t<R>, Eigen::Dynamic> const>
 {
     namespace rng = std::ranges;
     return Eigen::Map<Eigen::Vector<std::ranges::range_value_t<R>, Eigen::Dynamic> const>(
@@ -40,11 +41,10 @@ Eigen::Map<Eigen::Vector<std::ranges::range_value_t<R>, Eigen::Dynamic> const> T
  * @return Eigen matrix adaptor
  */
 template <CContiguousArithmeticMatrixRange R>
-Eigen::Map<Eigen::Matrix<
+auto ToEigen(R&& r) -> Eigen::Map<Eigen::Matrix<
     typename std::ranges::range_value_t<R>::Scalar,
     Eigen::Dynamic,
     Eigen::Dynamic> const>
-ToEigen(R&& r)
 {
     namespace rng   = std::ranges;
     using ValueType = rng::range_value_t<R>;

source/pbat/common/Hash.h

@@ -52,46 +52,86 @@ std::size_t HashCombine(const Types&... args)
 
 namespace std {
 
+/**
+ * @brief Hash function for pair of Index
+ */
 template <>
 struct hash<pair<pbat::Index, pbat::Index>>
 {
+    /**
+     * @brief Hash function for pair of Index
+     * @param inds Pair of indices
+     * @return std::size_t Hash value
+     */
     [[maybe_unused]] std::size_t operator()(pair<pbat::Index, pbat::Index> const& inds) const
     {
         return pbat::common::HashCombine(inds.first, inds.second);
     }
 };
 
+/**
+ * @brief Hash function for 2-tuple of Index
+ */
 template <>
 struct hash<tuple<pbat::Index, pbat::Index>>
 {
+    /**
+     * @brief Hash function for 2-tuple of Index
+     * @param inds 2-tuple of indices
+     * @return std::size_t Hash value
+     */
     [[maybe_unused]] std::size_t operator()(tuple<pbat::Index, pbat::Index> const& inds) const
     {
         return pbat::common::HashCombine(get<0>(inds), get<1>(inds));
     }
 };
 
+/**
+ * @brief Hash function for 3-tuple of Index
+ */
 template <>
 struct hash<tuple<pbat::Index, pbat::Index, pbat::Index>>
 {
+    /**
+     * @brief Hash function for 3-tuple of Index
+     * @param inds 3-tuple of indices
+     * @return std::size_t Hash value
+     */
     [[maybe_unused]] std::size_t
     operator()(tuple<pbat::Index, pbat::Index, pbat::Index> const& inds) const
     {
         return pbat::common::HashCombine(get<0>(inds), get<1>(inds), get<2>(inds));
     }
 };
 
+/**
+ * @brief Hash function for pbat::IndexVector<2>
+ */
 template <>
 struct hash<pbat::IndexVector<2>>
 {
+    /**
+     * @brief Hash function for pbat::IndexVector<2>
+     * @param inds Index vector
+     * @return std::size_t Hash value
+     */
     [[maybe_unused]] std::size_t operator()(pbat::IndexVector<2> const& inds) const
     {
         return pbat::common::HashCombine(inds(0), inds(1));
     }
 };
 
+/**
+ * @brief Hash function for pbat::IndexVector<3>
+ */
 template <>
 struct hash<pbat::IndexVector<3>>
 {
+    /**
+     * @brief Hash function for pbat::IndexVector<3>
+     * @param inds Index vector
+     * @return std::size_t Hash value
+     */
     [[maybe_unused]] std::size_t operator()(pbat::IndexVector<3> const& inds) const
     {
         return pbat::common::HashCombine(inds(0), inds(1), inds(2));

source/pbat/common/Indexing.cpp

@@ -5,13 +5,11 @@
 #include <doctest/doctest.h>
 #include <ranges>
 
-namespace pbat {
-namespace common {
-
 TEST_CASE("[common] Cumulative sums are computable from any integral range type")
 {
+    using namespace pbat;
     std::array<Index, 3> v{5, 10, 15};
-    auto const cs = CumSum(v);
+    auto const cs = common::CumSum(v);
     IndexVectorX csExpected(4);
     csExpected << 0, 5, 15, 30;
     CHECK_EQ(cs, csExpected);
@@ -34,7 +32,4 @@ TEST_CASE("[common] Repeat on Eigen vectors works as expected")
     CHECK_EQ(result.size(), expected.size());
     bool const bAreEqual = (result.array() == expected.array()).all();
     CHECK(bAreEqual);
-}
-
-} // namespace common
-} // namespace pbat
+}

source/pbat/common/Indexing.h

@@ -31,7 +31,7 @@ namespace common {
  * @return Eigen::Vector<TIndex, Eigen::Dynamic> Cumulative sum of the range
  */
 template <CIndexRange R, std::integral TIndex = std::ranges::range_value_t<R>>
-Eigen::Vector<TIndex, Eigen::Dynamic> CumSum(R&& sizes)
+auto CumSum(R&& sizes) -> Eigen::Vector<TIndex, Eigen::Dynamic>
 {
     namespace rng         = std::ranges;
     using IndexVectorType = Eigen::Vector<TIndex, Eigen::Dynamic>;
@@ -54,7 +54,7 @@ Eigen::Vector<TIndex, Eigen::Dynamic> CumSum(R&& sizes)
  * @return Eigen::Vector<TIndex, Eigen::Dynamic> Counts of each integer in the range
  */
 template <std::integral TIndex>
-Eigen::Vector<TIndex, Eigen::Dynamic> Counts(auto begin, auto end, TIndex ncounts)
+auto Counts(auto begin, auto end, TIndex ncounts) -> Eigen::Vector<TIndex, Eigen::Dynamic>
 {
     using IndexVectorType = Eigen::Vector<TIndex, Eigen::Dynamic>;
     IndexVectorType counts(ncounts);
@@ -73,7 +73,7 @@ Eigen::Vector<TIndex, Eigen::Dynamic> Counts(auto begin, auto end, TIndex ncount
  * @return Eigen::Vector<TIndex, Eigen::Dynamic> Shuffled range of integers
  */
 template <std::integral TIndex>
-Eigen::Vector<TIndex, Eigen::Dynamic> Shuffle(TIndex begin, TIndex end)
+auto Shuffle(TIndex begin, TIndex end) -> Eigen::Vector<TIndex, Eigen::Dynamic>
 {
     auto iota = std::views::iota(begin, end);
     Eigen::Vector<TIndex, Eigen::Dynamic> inds(end - begin);
@@ -101,7 +101,7 @@ template <
     std::integral TIndexE,
     class Func,
     class TIndex = std::common_type_t<TIndexB, TIndexE>>
-Eigen::Vector<TIndex, Eigen::Dynamic> Filter(TIndexB begin, TIndexE end, Func&& f)
+auto Filter(TIndexB begin, TIndexE end, Func&& f) -> Eigen::Vector<TIndex, Eigen::Dynamic>
 {
     auto filteredView = std::views::iota(static_cast<TIndex>(begin), static_cast<TIndex>(end)) |
                         std::views::filter(f);
@@ -129,8 +129,8 @@ template <
     class TDerivedR,
     class TScalar        = typename TDerivedX::Scalar,
     std::integral TIndex = typename TDerivedR::Scalar>
-Eigen::Vector<TScalar, Eigen::Dynamic>
-Repeat(Eigen::DenseBase<TDerivedX> const& x, Eigen::DenseBase<TDerivedR> const& r)
+auto Repeat(Eigen::DenseBase<TDerivedX> const& x, Eigen::DenseBase<TDerivedR> const& r)
+    -> Eigen::Vector<TScalar, Eigen::Dynamic>
 {
     using VectorType = Eigen::Vector<TScalar, Eigen::Dynamic>;
     VectorType y(r.sum());