Update pre-commit config (#270)

* Bump clang-format version in .pre-commit-config.yaml * pre-commit run --all-files
paulsengroup · Sep 30, 2024 · ed11aea · ed11aea
1 parent 124d606
commit ed11aea
Show file tree

Hide file tree

Showing 34 changed files with 189 additions and 153 deletions.
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -46,7 +46,7 @@ repos:
         types_or: [c, c++]
         language: python
         args: ["-i"]
-        additional_dependencies: ["clang-format==18.1.8"]
+        additional_dependencies: ["clang-format==19.1.0"]
       - id: cmake-format
         name: cmake-format
         entry: cmake-format

diff --git a/src/libhictk/balancing/include/hictk/balancing/ice.hpp b/src/libhictk/balancing/include/hictk/balancing/ice.hpp
@@ -79,36 +79,43 @@ class ICE {
                      BS::thread_pool* tpool);
 
   template <typename File>
-  [[nodiscard]] static auto construct_sparse_matrix(
-      const File& f, Type type, std::size_t num_masked_diags) -> internal::SparseMatrixChunked;
+  [[nodiscard]] static auto construct_sparse_matrix(const File& f, Type type,
+                                                    std::size_t num_masked_diags)
+      -> internal::SparseMatrixChunked;
   template <typename File>
   [[nodiscard]] static auto construct_sparse_matrix_gw(const File& f, std::size_t num_masked_diags)
       -> internal::SparseMatrixChunked;
   template <typename File>
-  [[nodiscard]] static auto construct_sparse_matrix_cis(
-      const File& f, const Chromosome& chrom, std::size_t bin_offset,
-      std::size_t num_masked_diags) -> internal::SparseMatrixChunked;
+  [[nodiscard]] static auto construct_sparse_matrix_cis(const File& f, const Chromosome& chrom,
+                                                        std::size_t bin_offset,
+                                                        std::size_t num_masked_diags)
+      -> internal::SparseMatrixChunked;
   template <typename File>
   [[nodiscard]] static auto construct_sparse_matrix_cis(const File& f, std::size_t num_masked_diags)
       -> internal::SparseMatrixChunked;
   template <typename File>
-  [[nodiscard]] static auto construct_sparse_matrix_trans(
-      const File& f, std::size_t num_masked_diags) -> internal::SparseMatrixChunked;
+  [[nodiscard]] static auto construct_sparse_matrix_trans(const File& f,
+                                                          std::size_t num_masked_diags)
+      -> internal::SparseMatrixChunked;
 
   template <typename File>
-  [[nodiscard]] static auto construct_sparse_matrix_chunked(
-      const File& f, Type type, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,
-      std::size_t chunk_size) -> internal::FileBackedSparseMatrix;
+  [[nodiscard]] static auto construct_sparse_matrix_chunked(const File& f, Type type,
+                                                            std::size_t num_masked_diags,
+                                                            const std::filesystem::path& tmpfile,
+                                                            std::size_t chunk_size)
+      -> internal::FileBackedSparseMatrix;
   template <typename File>
-  [[nodiscard]] static auto construct_sparse_matrix_chunked_gw(
-      const File& f, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,
-      std::size_t chunk_size) -> internal::FileBackedSparseMatrix;
+  [[nodiscard]] static auto construct_sparse_matrix_chunked_gw(const File& f,
+                                                               std::size_t num_masked_diags,
+                                                               const std::filesystem::path& tmpfile,
+                                                               std::size_t chunk_size)
+      -> internal::FileBackedSparseMatrix;
 
   template <typename File>
   [[nodiscard]] static auto construct_sparse_matrix_chunked_cis(
       const File& f, const Chromosome& chrom, std::size_t bin_offset, std::size_t num_masked_diags,
-      const std::filesystem::path& tmpfile,
-      std::size_t chunk_size) -> internal::FileBackedSparseMatrix;
+      const std::filesystem::path& tmpfile, std::size_t chunk_size)
+      -> internal::FileBackedSparseMatrix;
   template <typename File>
   [[nodiscard]] static auto construct_sparse_matrix_chunked_cis(
       const File& f, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,

diff --git a/src/libhictk/balancing/include/hictk/balancing/impl/ice_impl.hpp b/src/libhictk/balancing/include/hictk/balancing/impl/ice_impl.hpp
@@ -179,8 +179,8 @@ inline void ICE::balance_cis(const MatrixT& matrix, const Chromosome& chrom, std
 }
 
 template <typename File>
-auto ICE::construct_sparse_matrix(const File& f, Type type,
-                                  std::size_t num_masked_diags) -> internal::SparseMatrixChunked {
+auto ICE::construct_sparse_matrix(const File& f, Type type, std::size_t num_masked_diags)
+    -> internal::SparseMatrixChunked {
   SPDLOG_INFO(FMT_STRING("Reading interactions into memory..."));
   if (type == Type::cis) {
     return construct_sparse_matrix_cis(f, num_masked_diags);
@@ -206,9 +206,10 @@ inline auto ICE::construct_sparse_matrix_gw(const File& f, std::size_t num_maske
 }
 
 template <typename File>
-[[nodiscard]] inline auto ICE::construct_sparse_matrix_cis(
-    const File& f, const Chromosome& chrom, std::size_t bin_offset,
-    std::size_t num_masked_diags) -> internal::SparseMatrixChunked {
+[[nodiscard]] inline auto ICE::construct_sparse_matrix_cis(const File& f, const Chromosome& chrom,
+                                                           std::size_t bin_offset,
+                                                           std::size_t num_masked_diags)
+    -> internal::SparseMatrixChunked {
   internal::SparseMatrixChunked m{};
 
   const auto sel = f.fetch(chrom.name());
@@ -224,8 +225,9 @@ template <typename File>
 }
 
 template <typename File>
-[[nodiscard]] inline auto ICE::construct_sparse_matrix_cis(
-    const File& f, std::size_t num_masked_diags) -> internal::SparseMatrixChunked {
+[[nodiscard]] inline auto ICE::construct_sparse_matrix_cis(const File& f,
+                                                           std::size_t num_masked_diags)
+    -> internal::SparseMatrixChunked {
   internal::SparseMatrixChunked m{};
 
   for (const auto& chrom : f.chromosomes()) {
@@ -246,8 +248,9 @@ template <typename File>
 }
 
 template <typename File>
-[[nodiscard]] inline auto ICE::construct_sparse_matrix_trans(
-    const File& f, std::size_t num_masked_diags) -> internal::SparseMatrixChunked {
+[[nodiscard]] inline auto ICE::construct_sparse_matrix_trans(const File& f,
+                                                             std::size_t num_masked_diags)
+    -> internal::SparseMatrixChunked {
   using SelectorT = decltype(f.fetch("chr1", "chr2"));
   using PixelIt = decltype(f.fetch("chr1", "chr2").template begin<double>());
 
@@ -298,9 +301,10 @@ template <typename File>
 }
 
 template <typename File>
-auto ICE::construct_sparse_matrix_chunked(
-    const File& f, Type type, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,
-    std::size_t chunk_size) -> internal::FileBackedSparseMatrix {
+auto ICE::construct_sparse_matrix_chunked(const File& f, Type type, std::size_t num_masked_diags,
+                                          const std::filesystem::path& tmpfile,
+                                          std::size_t chunk_size)
+    -> internal::FileBackedSparseMatrix {
   SPDLOG_INFO(FMT_STRING("Writing interactions to temporary file {}..."), tmpfile);
   if (type == Type::cis) {
     return construct_sparse_matrix_chunked_cis(f, num_masked_diags, tmpfile, chunk_size);
@@ -309,9 +313,10 @@ auto ICE::construct_sparse_matrix_chunked(
 }
 
 template <typename File>
-inline auto ICE::construct_sparse_matrix_chunked_gw(
-    const File& f, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,
-    std::size_t chunk_size) -> internal::FileBackedSparseMatrix {
+inline auto ICE::construct_sparse_matrix_chunked_gw(const File& f, std::size_t num_masked_diags,
+                                                    const std::filesystem::path& tmpfile,
+                                                    std::size_t chunk_size)
+    -> internal::FileBackedSparseMatrix {
   internal::FileBackedSparseMatrix m(tmpfile, chunk_size);
 
   const auto sel = f.fetch();
@@ -326,10 +331,12 @@ inline auto ICE::construct_sparse_matrix_chunked_gw(
 }
 
 template <typename File>
-inline auto ICE::construct_sparse_matrix_chunked_cis(
-    const File& f, const Chromosome& chrom, std::size_t bin_offset, std::size_t num_masked_diags,
-    const std::filesystem::path& tmpfile,
-    std::size_t chunk_size) -> internal::FileBackedSparseMatrix {
+inline auto ICE::construct_sparse_matrix_chunked_cis(const File& f, const Chromosome& chrom,
+                                                     std::size_t bin_offset,
+                                                     std::size_t num_masked_diags,
+                                                     const std::filesystem::path& tmpfile,
+                                                     std::size_t chunk_size)
+    -> internal::FileBackedSparseMatrix {
   internal::FileBackedSparseMatrix m(tmpfile, chunk_size);
 
   const auto sel = f.fetch(chrom.name());
@@ -344,9 +351,10 @@ inline auto ICE::construct_sparse_matrix_chunked_cis(
 }
 
 template <typename File>
-inline auto ICE::construct_sparse_matrix_chunked_cis(
-    const File& f, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,
-    std::size_t chunk_size) -> internal::FileBackedSparseMatrix {
+inline auto ICE::construct_sparse_matrix_chunked_cis(const File& f, std::size_t num_masked_diags,
+                                                     const std::filesystem::path& tmpfile,
+                                                     std::size_t chunk_size)
+    -> internal::FileBackedSparseMatrix {
   internal::FileBackedSparseMatrix m(tmpfile, chunk_size);
 
   for (const Chromosome& chrom : f.chromosomes()) {
@@ -366,9 +374,10 @@ inline auto ICE::construct_sparse_matrix_chunked_cis(
 }
 
 template <typename File>
-inline auto ICE::construct_sparse_matrix_chunked_trans(
-    const File& f, std::size_t num_masked_diags, const std::filesystem::path& tmpfile,
-    std::size_t chunk_size) -> internal::FileBackedSparseMatrix {
+inline auto ICE::construct_sparse_matrix_chunked_trans(const File& f, std::size_t num_masked_diags,
+                                                       const std::filesystem::path& tmpfile,
+                                                       std::size_t chunk_size)
+    -> internal::FileBackedSparseMatrix {
   using SelectorT = decltype(f.fetch("chr1", "chr2"));
   using PixelIt = decltype(f.fetch("chr1", "chr2").template begin<double>());
 

diff --git a/src/libhictk/balancing/include/hictk/balancing/impl/scale_impl.hpp b/src/libhictk/balancing/include/hictk/balancing/impl/scale_impl.hpp
@@ -219,8 +219,8 @@ inline balancing::Weights SCALE::get_weights(bool rescale) const {
 inline const std::vector<double>& SCALE::get_scale() const noexcept { return _scale; }
 
 template <typename File>
-inline auto SCALE::compute_cis(const File& f,
-                               const hictk::balancing::SCALE::Params& params) -> Result {
+inline auto SCALE::compute_cis(const File& f, const hictk::balancing::SCALE::Params& params)
+    -> Result {
   std::vector<std::uint64_t> offsets{};
   std::vector<double> scales{};
   std::vector<double> weights{};
@@ -475,8 +475,8 @@ inline auto SCALE::handle_convergenece(const Matrix& m, std::vector<double>& dr,
 template <typename Matrix>
 inline auto SCALE::handle_almost_converged(const Matrix& m, const std::vector<double>& b0,
                                            std::vector<double>& dr, std::vector<double>& dc,
-                                           internal::VectorOfAtomicDecimals& row,
-                                           double tolerance) -> ControlFlow {
+                                           internal::VectorOfAtomicDecimals& row, double tolerance)
+    -> ControlFlow {
   for (std::size_t i = 0; i < size(); ++i) {
     if (_bad[i]) {
       continue;

diff --git a/src/libhictk/balancing/include/hictk/balancing/weights.hpp b/src/libhictk/balancing/include/hictk/balancing/weights.hpp
@@ -95,16 +95,16 @@ class Weights {
       constexpr auto operator++() noexcept(ndebug_defined()) -> ConstIt &;
       [[nodiscard]] constexpr auto operator++(int) noexcept(ndebug_defined()) -> ConstIt;
       constexpr auto operator+=(std::ptrdiff_t i_) noexcept(ndebug_defined()) -> ConstIt &;
-      [[nodiscard]] constexpr auto operator+(std::ptrdiff_t i_) const
-          noexcept(ndebug_defined()) -> ConstIt;
+      [[nodiscard]] constexpr auto operator+(std::ptrdiff_t i_) const noexcept(ndebug_defined())
+          -> ConstIt;
 
       constexpr auto operator--() noexcept(ndebug_defined()) -> ConstIt &;
       [[nodiscard]] constexpr auto operator--(int) noexcept(ndebug_defined()) -> ConstIt;
       constexpr auto operator-=(std::ptrdiff_t i_) noexcept(ndebug_defined()) -> ConstIt &;
-      [[nodiscard]] constexpr auto operator-(std::ptrdiff_t i_) const
-          noexcept(ndebug_defined()) -> ConstIt;
-      [[nodiscard]] constexpr auto operator-(const ConstIt &other) const
-          noexcept(ndebug_defined()) -> std::ptrdiff_t;
+      [[nodiscard]] constexpr auto operator-(std::ptrdiff_t i_) const noexcept(ndebug_defined())
+          -> ConstIt;
+      [[nodiscard]] constexpr auto operator-(const ConstIt &other) const noexcept(ndebug_defined())
+          -> std::ptrdiff_t;
 
      private:
       constexpr void bound_check(std::ptrdiff_t offset, bool end_ok = true) const;

diff --git a/src/libhictk/bin_table/include/hictk/bin_table.hpp b/src/libhictk/bin_table/include/hictk/bin_table.hpp
@@ -65,13 +65,15 @@ class BinTable {
 
   [[nodiscard]] auto find_overlap(const GenomicInterval &query) const
       -> std::pair<BinTable::iterator, BinTable::iterator>;
-  [[nodiscard]] auto find_overlap(const Chromosome &chrom, std::uint32_t start, std::uint32_t end)
-      const -> std::pair<BinTable::iterator, BinTable::iterator>;
+  [[nodiscard]] auto find_overlap(const Chromosome &chrom, std::uint32_t start,
+                                  std::uint32_t end) const
+      -> std::pair<BinTable::iterator, BinTable::iterator>;
   [[nodiscard]] auto find_overlap(std::string_view chrom_name, std::uint32_t start,
                                   std::uint32_t end) const
       -> std::pair<BinTable::iterator, BinTable::iterator>;
-  [[nodiscard]] auto find_overlap(std::uint32_t chrom_id, std::uint32_t start, std::uint32_t end)
-      const -> std::pair<BinTable::iterator, BinTable::iterator>;
+  [[nodiscard]] auto find_overlap(std::uint32_t chrom_id, std::uint32_t start,
+                                  std::uint32_t end) const
+      -> std::pair<BinTable::iterator, BinTable::iterator>;
 
   // Map bin_id to Bin
   [[nodiscard]] Bin at(std::uint64_t bin_id) const;

diff --git a/src/libhictk/bin_table/include/hictk/bin_table_fixed.hpp b/src/libhictk/bin_table/include/hictk/bin_table_fixed.hpp
@@ -54,13 +54,15 @@ class BinTableFixed {
 
   [[nodiscard]] auto find_overlap(const GenomicInterval &query) const
       -> std::pair<BinTableFixed::iterator, BinTableFixed::iterator>;
-  [[nodiscard]] auto find_overlap(const Chromosome &chrom, std::uint32_t start, std::uint32_t end)
-      const -> std::pair<BinTableFixed::iterator, BinTableFixed::iterator>;
+  [[nodiscard]] auto find_overlap(const Chromosome &chrom, std::uint32_t start,
+                                  std::uint32_t end) const
+      -> std::pair<BinTableFixed::iterator, BinTableFixed::iterator>;
   [[nodiscard]] auto find_overlap(std::string_view chrom_name, std::uint32_t start,
                                   std::uint32_t end) const
       -> std::pair<BinTableFixed::iterator, BinTableFixed::iterator>;
-  [[nodiscard]] auto find_overlap(std::uint32_t chrom_id, std::uint32_t start, std::uint32_t end)
-      const -> std::pair<BinTableFixed::iterator, BinTableFixed::iterator>;
+  [[nodiscard]] auto find_overlap(std::uint32_t chrom_id, std::uint32_t start,
+                                  std::uint32_t end) const
+      -> std::pair<BinTableFixed::iterator, BinTableFixed::iterator>;
 
   // Map bin_id to Bin
   [[nodiscard]] Bin at(std::uint64_t bin_id) const;

diff --git a/src/libhictk/bin_table/include/hictk/bin_table_variable.hpp b/src/libhictk/bin_table/include/hictk/bin_table_variable.hpp
@@ -49,13 +49,15 @@ class BinTableVariable {
 
   [[nodiscard]] auto find_overlap(const GenomicInterval &query) const
       -> std::pair<BinTableVariable::iterator, BinTableVariable::iterator>;
-  [[nodiscard]] auto find_overlap(const Chromosome &chrom, std::uint32_t start, std::uint32_t end)
-      const -> std::pair<BinTableVariable::iterator, BinTableVariable::iterator>;
+  [[nodiscard]] auto find_overlap(const Chromosome &chrom, std::uint32_t start,
+                                  std::uint32_t end) const
+      -> std::pair<BinTableVariable::iterator, BinTableVariable::iterator>;
   [[nodiscard]] auto find_overlap(std::string_view chrom_name, std::uint32_t start,
                                   std::uint32_t end) const
       -> std::pair<BinTableVariable::iterator, BinTableVariable::iterator>;
-  [[nodiscard]] auto find_overlap(std::uint32_t chrom_id, std::uint32_t start, std::uint32_t end)
-      const -> std::pair<BinTableVariable::iterator, BinTableVariable::iterator>;
+  [[nodiscard]] auto find_overlap(std::uint32_t chrom_id, std::uint32_t start,
+                                  std::uint32_t end) const
+      -> std::pair<BinTableVariable::iterator, BinTableVariable::iterator>;
 
   // Map bin_id to Bin
   [[nodiscard]] Bin at(std::uint64_t bin_id) const;

diff --git a/src/libhictk/bin_table/include/hictk/impl/bin_table_impl.hpp b/src/libhictk/bin_table/include/hictk/impl/bin_table_impl.hpp
@@ -109,8 +109,9 @@ inline auto BinTable::find_overlap(const GenomicInterval &query) const
       _table);
 }
 
-inline auto BinTable::find_overlap(const Chromosome &chrom, std::uint32_t start, std::uint32_t end)
-    const -> std::pair<BinTable::iterator, BinTable::iterator> {
+inline auto BinTable::find_overlap(const Chromosome &chrom, std::uint32_t start,
+                                   std::uint32_t end) const
+    -> std::pair<BinTable::iterator, BinTable::iterator> {
   return find_overlap(GenomicInterval{chrom, start, end});
 }
 
@@ -120,8 +121,9 @@ inline auto BinTable::find_overlap(std::string_view chrom_name, std::uint32_t st
   return find_overlap(chromosomes().at(chrom_name), start, end);
 }
 
-inline auto BinTable::find_overlap(std::uint32_t chrom_id, std::uint32_t start, std::uint32_t end)
-    const -> std::pair<BinTable::iterator, BinTable::iterator> {
+inline auto BinTable::find_overlap(std::uint32_t chrom_id, std::uint32_t start,
+                                   std::uint32_t end) const
+    -> std::pair<BinTable::iterator, BinTable::iterator> {
   return find_overlap(chromosomes().at(chrom_id), start, end);
 }
 

diff --git a/src/libhictk/cooler/include/hictk/cooler/cooler.hpp b/src/libhictk/cooler/include/hictk/cooler/cooler.hpp
@@ -319,12 +319,12 @@ class File {
   [[nodiscard]] static HighFive::File open_file(std::string_view uri, unsigned int mode,
                                                 bool validate);
 
-  [[nodiscard]] static auto open_or_create_root_group(HighFive::File f,
-                                                      std::string_view uri) -> RootGroup;
+  [[nodiscard]] static auto open_or_create_root_group(HighFive::File f, std::string_view uri)
+      -> RootGroup;
 
   // Open/read groups, datasets and attributes
-  [[nodiscard]] static auto open_root_group(const HighFive::File &f,
-                                            std::string_view uri) -> RootGroup;
+  [[nodiscard]] static auto open_root_group(const HighFive::File &f, std::string_view uri)
+      -> RootGroup;
   [[nodiscard]] static auto open_groups(const RootGroup &root_grp) -> GroupMap;
   [[nodiscard]] static auto open_datasets(const RootGroup &root_grp, std::size_t cache_size_bytes,
                                           double w0) -> DatasetMap;
@@ -335,8 +335,8 @@ class File {
   [[nodiscard]] static auto create_root_group(HighFive::File &f, std::string_view uri,
                                               bool write_sentinel_attr = true) -> RootGroup;
   [[nodiscard]] static auto create_groups(RootGroup &root_grp) -> GroupMap;
-  [[nodiscard]] static auto create_groups(RootGroup &root_grp, Group chroms_grp,
-                                          Group bins_grp) -> GroupMap;
+  [[nodiscard]] static auto create_groups(RootGroup &root_grp, Group chroms_grp, Group bins_grp)
+      -> GroupMap;
   template <typename PixelT>
   [[nodiscard]] static auto create_datasets(RootGroup &root_grp, const Reference &chroms,
                                             std::size_t cache_size_bytes,