ratschlab · karasikov · May 16, 2025 · May 16, 2025 · May 16, 2025 · May 16, 2025
diff --git a/metagraph/src/annotation/annotation_converters.cpp b/metagraph/src/annotation/annotation_converters.cpp
@@ -420,7 +420,7 @@ void convert_to_row_diff<RowDiffRowSparseAnnotator>(
 
 std::unique_ptr<MultiBRWTAnnotator>
 convert_to_BRWT(
-        const std::vector<std::vector<uint64_t>> &linkage,
+        const std::vector<std::vector<uint32_t>> &linkage,
         size_t num_parallel_nodes,
         size_t num_threads,
         const fs::path &tmp_path,
@@ -456,7 +456,7 @@ convert_to_BRWT(
 template <>
 std::unique_ptr<MultiBRWTAnnotator> convert_to_BRWT<MultiBRWTAnnotator>(
         const std::vector<std::string> &annotation_files,
-        const std::vector<std::vector<uint64_t>> &linkage,
+        const std::vector<std::vector<uint32_t>> &linkage,
         size_t num_parallel_nodes,
         size_t num_threads,
         const fs::path &tmp_path) {
@@ -487,7 +487,7 @@ std::unique_ptr<MultiBRWTAnnotator> convert_to_BRWT<MultiBRWTAnnotator>(
 template<>
 std::unique_ptr<RowDiffBRWTAnnotator>
 convert_to_BRWT<RowDiffBRWTAnnotator>(const std::vector<std::string> &annotation_files,
-                         const std::vector<std::vector<uint64_t>> &linkage,
+                         const std::vector<std::vector<uint32_t>> &linkage,
                          size_t num_parallel_nodes,
                          size_t num_threads,
                          const fs::path &tmp_path) {

diff --git a/metagraph/src/annotation/annotation_converters.hpp b/metagraph/src/annotation/annotation_converters.hpp
@@ -60,7 +60,7 @@ convert_to_greedy_BRWT(RowDiffColumnAnnotator &&annotation,
 template <class StaticAnnotation>
 std::unique_ptr<StaticAnnotation>
 convert_to_BRWT(const std::vector<std::string> &annotation_files,
-                const std::vector<std::vector<uint64_t>> &linkage_matrix,
+                const std::vector<std::vector<uint32_t>> &linkage_matrix,
                 size_t num_parallel_nodes = 1,
                 size_t num_threads = 1,
                 const std::filesystem::path &tmp_dir = "");

diff --git a/metagraph/src/annotation/binary_matrix/base/binary_matrix.hpp b/metagraph/src/annotation/binary_matrix/base/binary_matrix.hpp
@@ -18,9 +18,9 @@ namespace matrix {
 class BinaryMatrix {
   public:
     typedef uint64_t Row;
-    typedef uint64_t Column;
+    typedef uint32_t Column;
 
-    typedef Vector<Column> SetBitPositions;
+    typedef SmallVector<Column> SetBitPositions;
     typedef std::function<void(const SetBitPositions &)> RowCallback;
     typedef std::function<void(Row, Column)> ValueCallback;
 

diff --git a/metagraph/src/annotation/binary_matrix/column_sparse/column_major.cpp b/metagraph/src/annotation/binary_matrix/column_sparse/column_major.cpp
@@ -156,7 +156,7 @@ ColumnMajor::sum_rows(const std::vector<std::pair<Row, size_t>> &index_counts,
     if (total_sum_count < min_count)
         return {};
 
-    std::vector<std::pair<uint64_t, size_t>> result;
+    std::vector<std::pair<Column, size_t>> result;
     result.reserve(num_columns());
 
     for (size_t j = 0; j < num_columns(); ++j) {

diff --git a/metagraph/src/annotation/binary_matrix/multi_brwt/brwt_builders.cpp b/metagraph/src/annotation/binary_matrix/multi_brwt/brwt_builders.cpp
@@ -63,7 +63,7 @@ BRWT BRWTBottomUpBuilder::concatenate(std::vector<BRWT>&& submatrices,
     uint64_t num_columns = 0;
     Partition partition;
     for (const BRWT &submatrix : submatrices) {
-        partition.push_back(utils::arange(num_columns, submatrix.num_columns()));
+        partition.push_back(utils::arange<BRWT::Column, std::vector<BRWT::Column>>(num_columns, submatrix.num_columns()));
         num_columns += submatrix.num_columns();
     }
     parent.assignments_ = RangePartition(std::move(partition));
@@ -130,7 +130,7 @@ BRWT BRWTBottomUpBuilder::concatenate_sparse(std::vector<BRWT>&& submatrices,
     uint64_t num_columns = 0;
     Partition partition;
     for (const BRWT &submatrix : submatrices) {
-        partition.push_back(utils::arange(num_columns, submatrix.num_columns()));
+        partition.push_back(utils::arange<BRWT::Column, std::vector<BRWT::Column>>(num_columns, submatrix.num_columns()));
         num_columns += submatrix.num_columns();
     }
     parent.assignments_ = RangePartition(std::move(partition));
@@ -162,7 +162,7 @@ BRWT BRWTBottomUpBuilder::concatenate_sparse(std::vector<BRWT>&& submatrices,
 
 template <typename T>
 std::vector<T> subset(std::vector<T> *vector,
-                      const std::vector<uint64_t> indexes) {
+                      const std::vector<BRWT::Column> indexes) {
     assert(vector);
 
     std::vector<T> result;
@@ -195,7 +195,7 @@ BRWT BRWTBottomUpBuilder::build(std::vector<std::unique_ptr<bit_vector>>&& colum
 // linkage[c] = {} for each c < num_columns
 BRWT BRWTBottomUpBuilder::build(
         const std::function<void(const CallColumn &)> &get_columns,
-        const std::vector<std::vector<uint64_t>> &linkage,
+        const std::vector<std::vector<BRWT::Column>> &linkage,
         const std::filesystem::path &tmp_path,
         size_t num_nodes_parallel,
         size_t num_threads) {
@@ -322,7 +322,7 @@ BRWT BRWTBottomUpBuilder::build(
 
     ThreadPool thread_pool(num_threads, 100'000 * num_threads);
 
-    std::vector<std::vector<uint64_t>> stored_columns(linkage.size());
+    std::vector<std::vector<BRWT::Column>> stored_columns(linkage.size());
 
     #pragma omp parallel for num_threads(num_nodes_parallel) schedule(dynamic)
     for (size_t i = num_leaves; i < linkage.size(); ++i) {
@@ -454,7 +454,7 @@ BRWT BRWTBottomUpBuilder::merge(std::vector<BRWT>&& nodes,
     uint64_t num_columns_total = 0;
     Partition current_partition;
     for (const BRWT &node : nodes) {
-        current_partition.push_back(utils::arange(num_columns_total, node.num_columns()));
+        current_partition.push_back(utils::arange<BRWT::Column, std::vector<BRWT::Column>>(num_columns_total, node.num_columns()));
         num_columns_total += node.num_columns();
     }
 
@@ -572,7 +572,7 @@ void BRWTOptimizer::reassign(size_t node_rank, BRWT *parent, size_t num_threads)
 
     BRWT &node = dynamic_cast<BRWT&>(*parent->child_nodes_.at(node_rank));
 
-    std::vector<uint64_t> column_arrangement;
+    std::vector<BRWT::Column> column_arrangement;
     std::vector<size_t> group_sizes;
     for (size_t g = 0; g < parent->assignments_.num_groups(); ++g) {
         if (g == node_rank)

diff --git a/metagraph/src/annotation/binary_matrix/multi_brwt/brwt_builders.hpp b/metagraph/src/annotation/binary_matrix/multi_brwt/brwt_builders.hpp
@@ -33,7 +33,7 @@ class BRWTBottomUpBuilder {
         = std::function<void(uint64_t, std::unique_ptr<bit_vector>&&)>;
 
     static BRWT build(const std::function<void(const CallColumn &)> &get_columns,
-                      const std::vector<std::vector<uint64_t>> &linkage,
+                      const std::vector<std::vector<BRWT::Column>> &linkage,
                       const std::filesystem::path &tmp_dir,
                       size_t num_nodes_parallel = 1,
                       size_t num_threads = 1);

diff --git a/metagraph/src/annotation/binary_matrix/multi_brwt/clustering.cpp b/metagraph/src/annotation/binary_matrix/multi_brwt/clustering.cpp
@@ -16,7 +16,7 @@ namespace matrix {
 
 using mtg::common::logger;
 
-typedef std::vector<std::vector<uint64_t>> Partition;
+typedef std::vector<std::vector<uint32_t>> Partition;
 typedef std::vector<const bit_vector *> VectorPtrs;
 
 
@@ -258,7 +258,7 @@ Partition greedy_matching(const std::vector<T> &columns, size_t num_threads) {
         ++progress_bar;
     }
 
-    for (size_t i = 0; i < columns.size(); ++i) {
+    for (uint32_t i = 0; i < columns.size(); ++i) {
         if (!matched[i])
             partition.push_back({ i });
     }

diff --git a/metagraph/src/annotation/binary_matrix/multi_brwt/clustering.hpp b/metagraph/src/annotation/binary_matrix/multi_brwt/clustering.hpp
@@ -25,7 +25,7 @@ struct SparseColumn {
 // `SparseColumn` storing the column size and the positions of its set bits.
 // Output: a set of greedily matched column pairs.
 template <class T>
-std::vector<std::vector<uint64_t>>
+std::vector<std::vector<uint32_t>>
 greedy_matching(const std::vector<T> &columns, size_t num_threads = 1);
 
 // Format resembling the Z matrix from scipy.cluster.hierarchy.linkage

diff --git a/metagraph/src/annotation/binary_matrix/row_diff/row_diff.hpp b/metagraph/src/annotation/binary_matrix/row_diff/row_diff.hpp
@@ -108,7 +108,7 @@ class RowDiff : public IRowDiff, public BinaryMatrix {
     BaseMatrix& diffs() { return diffs_; }
 
   private:
-    static void add_diff(const Vector<uint64_t> &diff, Vector<uint64_t> *row);
+    static void add_diff(const SetBitPositions &diff, SetBitPositions *row);
 
     BaseMatrix diffs_;
 };
@@ -210,14 +210,14 @@ void RowDiff<BaseMatrix>::serialize(std::ostream &f) const {
 }
 
 template <class BaseMatrix>
-void RowDiff<BaseMatrix>::add_diff(const Vector<uint64_t> &diff, Vector<uint64_t> *row) {
+void RowDiff<BaseMatrix>::add_diff(const SetBitPositions &diff, SetBitPositions *row) {
     assert(std::is_sorted(row->begin(), row->end()));
     assert(std::is_sorted(diff.begin(), diff.end()));
 
     if (diff.empty())
         return;
 
-    Vector<uint64_t> result;
+    SetBitPositions result;
     result.reserve(row->size() + diff.size());
     std::set_symmetric_difference(row->begin(), row->end(),
                                   diff.begin(), diff.end(),

diff --git a/metagraph/src/cli/query.cpp b/metagraph/src/cli/query.cpp
@@ -945,7 +945,8 @@ construct_query_graph(const AnnotatedDBG &anno_graph,
                                },
                                num_threads,
                                // pull only primary contigs when building canonical query graph
-                               full_dbg.get_mode() == DeBruijnGraph::CANONICAL);
+                               full_dbg.get_mode() == DeBruijnGraph::CANONICAL,
+                               false);
 
     logger->trace("[Query graph construction] Contig extraction took {} sec", timer.elapsed());
     timer.reset();

diff --git a/metagraph/src/cli/transform_annotation.cpp b/metagraph/src/cli/transform_annotation.cpp
@@ -168,11 +168,11 @@ matrix::LinkageMatrix compute_linkage(const std::vector<std::string> &files,
     }
 }
 
-std::vector<std::vector<uint64_t>>
+std::vector<std::vector<uint32_t>>
 parse_linkage_matrix(const std::string &filename) {
     std::ifstream in(filename);
 
-    std::vector<std::vector<uint64_t>> linkage;
+    std::vector<std::vector<uint32_t>> linkage;
     std::string line;
     while (std::getline(in, line)) {
         std::vector<std::string> parts = utils::split_string(line, " ");
@@ -858,8 +858,7 @@ int transform_annotation(Config *config) {
                     logger->trace("Generated new linkage and saved to {}",
                                   config->linkage_file);
                 }
-                std::vector<std::vector<uint64_t>> linkage
-                        = parse_linkage_matrix(config->linkage_file);
+                auto linkage = parse_linkage_matrix(config->linkage_file);
                 logger->trace("Linkage loaded from {}", config->linkage_file);
 
                 auto brwt_annotator = convert_to_BRWT<RowDiffBRWTAnnotator>(

diff --git a/metagraph/src/common/range_partition.cpp b/metagraph/src/common/range_partition.cpp
@@ -5,7 +5,7 @@
 #include "common/serialization.hpp"
 
 
-RangePartition::RangePartition(const std::vector<uint64_t> &arrangement,
+RangePartition::RangePartition(const std::vector<T> &arrangement,
                                const std::vector<size_t> &group_sizes) {
     size_t offset = 0;
     for (size_t group_size : group_sizes) {
@@ -19,15 +19,11 @@ RangePartition::RangePartition(const std::vector<uint64_t> &arrangement,
     initialize_groups_and_ranks();
 }
 
-RangePartition::RangePartition(std::vector<std::vector<uint64_t>>&& partition) {
-    partition_.reserve(partition.size());
-    for (auto &group : partition) {
-        assert(group.size() && "partition blocks must not be empty");
-        partition_.emplace_back(group.begin(), group.end());
-        group.clear();
-    }
-    partition.clear();
-
+RangePartition::RangePartition(std::vector<std::vector<T>>&& partition)
+    : partition_(std::move(partition)) {
+    assert(std::all_of(partition_.begin(), partition_.end(),
+                       [](const auto &group) { return !group.empty(); })
+        && "partition blocks must not be empty");
     assert(initialize_groups_and_ranks());
     initialize_groups_and_ranks();
 }

diff --git a/metagraph/src/common/range_partition.hpp b/metagraph/src/common/range_partition.hpp
@@ -16,9 +16,9 @@ class RangePartition {
     typedef uint32_t R;
 
     RangePartition() {}
-    RangePartition(const std::vector<uint64_t> &arrangement,
+    RangePartition(const std::vector<T> &arrangement,
                    const std::vector<size_t> &group_sizes);
-    explicit RangePartition(std::vector<std::vector<uint64_t>>&& partition);
+    explicit RangePartition(std::vector<std::vector<T>>&& partition);
 
     // get group that contains value
     inline G group(T value) const;

diff --git a/metagraph/src/graph/alignment/aligner_labeled.cpp b/metagraph/src/graph/alignment/aligner_labeled.cpp
@@ -17,7 +17,7 @@ typedef AnnotationBuffer::Columns Columns;
 typedef DeBruijnGraph::node_index node_index;
 
 // dummy index for an unfetched annotations
-static constexpr size_t nannot = std::numeric_limits<size_t>::max();
+static constexpr Column nannot = std::numeric_limits<Column>::max();
 
 template <class T1, class T2>
 bool overlap_with_diff(const T1 &tuple1, const T2 &tuple2, int64_t diff) {

diff --git a/metagraph/src/graph/alignment/annotation_buffer.cpp b/metagraph/src/graph/alignment/annotation_buffer.cpp
@@ -181,7 +181,7 @@ void AnnotationBuffer::fetch_queued_annotations() {
     } else {
         for (auto&& labels : annotator_.get_matrix().get_rows(queued_rows)) {
             std::sort(labels.begin(), labels.end());
-            push_node_labels(node_it++, row_it++, std::move(labels));
+            push_node_labels(node_it++, row_it++, Columns(labels.begin(), labels.end()));
         }
     }
 

diff --git a/metagraph/src/graph/annotated_graph_algorithm.cpp b/metagraph/src/graph/annotated_graph_algorithm.cpp
@@ -365,7 +365,7 @@ construct_diff_label_count_vector(const AnnotatedDBG &anno_graph,
         code_to_indicator[label_encoder.encode(label_out)] |= 2;
     }
 
-    std::vector<uint64_t> label_codes;
+    std::vector<annot::matrix::BinaryMatrix::Column> label_codes;
     label_codes.reserve(code_to_indicator.size());
     for (const auto &[code, indicator] : code_to_indicator) {
         label_codes.push_back(code);

diff --git a/metagraph/src/graph/representation/base/sequence_graph.cpp b/metagraph/src/graph/representation/base/sequence_graph.cpp
@@ -341,7 +341,8 @@ void call_sequences(const DeBruijnGraph &graph,
                     size_t num_threads,
                     bool call_unitigs,
                     uint64_t min_tip_size,
-                    bool kmers_in_single_form) {
+                    bool kmers_in_single_form,
+                    bool verbose = common::get_verbose()) {
     // TODO: port over the implementation from BOSS
     std::ignore = num_threads;
 
@@ -351,7 +352,7 @@ void call_sequences(const DeBruijnGraph &graph,
 
     ProgressBar progress_bar(visited.size() - sdsl::util::cnt_one_bits(visited),
                              "Traverse graph",
-                             std::cerr, !common::get_verbose());
+                             std::cerr, !verbose);
 
     auto call_paths_from = [&](node_index node) {
         call_sequences_from(graph,
@@ -417,8 +418,9 @@ void call_sequences(const DeBruijnGraph &graph,
 
 void DeBruijnGraph::call_sequences(const CallPath &callback,
                                    size_t num_threads,
-                                   bool kmers_in_single_form) const {
-    ::mtg::graph::call_sequences(*this, callback, num_threads, false, 0, kmers_in_single_form);
+                                   bool kmers_in_single_form,
+                                   bool verbose) const {
+    ::mtg::graph::call_sequences(*this, callback, num_threads, false, 0, kmers_in_single_form, verbose);
 }
 
 void DeBruijnGraph::call_unitigs(const CallPath &callback,

diff --git a/metagraph/src/graph/representation/base/sequence_graph.hpp b/metagraph/src/graph/representation/base/sequence_graph.hpp
@@ -191,7 +191,8 @@ class DeBruijnGraph : public SequenceGraph {
      */
     virtual void call_sequences(const CallPath &callback,
                                 size_t num_threads = 1,
-                                bool kmers_in_single_form = false) const;
+                                bool kmers_in_single_form = false,
+                                bool verbose = common::get_verbose()) const;
     /**
      * Call all unitigs except short tips, where tips are
      * the unitigs with InDegree(first) + OutDegree(last) < 2.

diff --git a/metagraph/src/graph/representation/canonical_dbg.cpp b/metagraph/src/graph/representation/canonical_dbg.cpp
@@ -424,12 +424,13 @@ size_t CanonicalDBG::indegree(node_index node) const {
 
 void CanonicalDBG::call_sequences(const CallPath &callback,
                                   size_t num_threads,
-                                  bool kmers_in_single_form) const {
+                                  bool kmers_in_single_form,
+                                  bool verbose) const {
     if (kmers_in_single_form) {
-        graph_->call_sequences(callback, num_threads, true);
+        graph_->call_sequences(callback, num_threads, true, verbose);
     } else {
         // TODO: port over implementation from DBGSuccinct to DeBruijnGraph
-        DeBruijnGraph::call_sequences(callback, num_threads, false);
+        DeBruijnGraph::call_sequences(callback, num_threads, false, verbose);
     }
 }
 

diff --git a/metagraph/src/graph/representation/canonical_dbg.hpp b/metagraph/src/graph/representation/canonical_dbg.hpp
@@ -84,7 +84,8 @@ class CanonicalDBG : public DBGWrapper<DeBruijnGraph> {
 
     virtual void call_sequences(const CallPath &callback,
                                 size_t num_threads = 1,
-                                bool kmers_in_single_form = false) const override final;
+                                bool kmers_in_single_form = false,
+                                bool verbose = common::get_verbose()) const override final;
 
     virtual void call_unitigs(const CallPath &callback,
                               size_t num_threads = 1,

diff --git a/metagraph/src/graph/representation/masked_graph.cpp b/metagraph/src/graph/representation/masked_graph.cpp
@@ -106,7 +106,8 @@ bit_vector_stat get_boss_mask(const DBGSuccinct &dbg_succ,
 
 void MaskedDeBruijnGraph::call_sequences(const CallPath &callback,
                                          size_t num_threads,
-                                         bool kmers_in_single_form) const {
+                                         bool kmers_in_single_form,
+                                         bool verbose) const {
     if (auto *dbg_succ = dynamic_cast<const DBGSuccinct*>(graph_.get())) {
         bit_vector_stat mask = get_boss_mask(*dbg_succ, *kmers_in_graph_,
                                              only_valid_nodes_in_mask_);
@@ -117,10 +118,10 @@ void MaskedDeBruijnGraph::call_sequences(const CallPath &callback,
             }
             callback(sequence, path);
 
-        }, num_threads, kmers_in_single_form, &mask);
+        }, num_threads, kmers_in_single_form, verbose, &mask);
 
     } else {
-        DeBruijnGraph::call_sequences(callback, num_threads, kmers_in_single_form);
+        DeBruijnGraph::call_sequences(callback, num_threads, kmers_in_single_form, verbose);
     }
 }
 

diff --git a/metagraph/src/graph/representation/masked_graph.hpp b/metagraph/src/graph/representation/masked_graph.hpp
@@ -75,7 +75,8 @@ class MaskedDeBruijnGraph : public DBGWrapper<DeBruijnGraph> {
 
     virtual void call_sequences(const CallPath &callback,
                                 size_t num_threads = 1,
-                                bool kmers_in_single_form = false) const override;
+                                bool kmers_in_single_form = false,
+                                bool verbose = common::get_verbose()) const override;
 
     virtual void call_unitigs(const CallPath &callback,
                               size_t num_threads = 1,