Rename PersistentCompactIntMatrix to PersistentIntMatrix

Update all matrix type references, imports, and instantiations across
the codebase to use the new PersistentIntMatrix name. The change also
includes standardizing code formatting, such as multi-line statements
and import ordering, without altering any behavioral logic or public
API contracts.

src/obikindex/src/layer/content_layer.rs

@@ -26,7 +26,7 @@ use std::path::{Path, PathBuf};
 
 use crate::layer::utils::LAYERNAME_SUFFIX;
 
-use obicompactvec::{PersistentBitMatrix, PersistentCompactIntMatrix};
+use obicompactvec::{PersistentBitMatrix, PersistentIntMatrix};
 use obikseq::CanonicalKmer;
 
 use crate::index::error::OKIResult;
@@ -63,7 +63,7 @@ pub enum KmerLayer {
     Count {
         dir: PathBuf,
         id: usize,
-        layer: TypedLayer<PersistentCompactIntMatrix>,
+        layer: TypedLayer<PersistentIntMatrix>,
     },
     Presence {
         dir: PathBuf,
@@ -99,7 +99,7 @@ impl KmerLayer {
             already_open => return Ok(already_open),
         };
         if dir.join(COUNTS_DIR).exists() {
-            let layer = TypedLayer::<PersistentCompactIntMatrix>::open(&dir)?;
+            let layer = TypedLayer::<PersistentIntMatrix>::open(&dir)?;
             Ok(KmerLayer::Count { dir, id, layer })
         } else {
             let layer = TypedLayer::<PersistentBitMatrix>::open(&dir)?;
@@ -221,7 +221,10 @@ impl KmerLayer {
     /// format-agnostic column-major fetch, delegating to whichever matrix
     /// this layer actually holds (see `obicompactvec::PersistentBitMatrix`/
     /// `PersistentCompactIntMatrix::nonzero_iter`).
-    pub fn nonzero_iter<'a>(&'a self, slots: &'a [usize]) -> Box<dyn Iterator<Item = (usize, usize, u32)> + 'a> {
+    pub fn nonzero_iter<'a>(
+        &'a self,
+        slots: &'a [usize],
+    ) -> Box<dyn Iterator<Item = (usize, usize, u32)> + 'a> {
         match self {
             KmerLayer::Presence { layer, .. } => layer.nonzero_iter(slots),
             KmerLayer::Count { layer, .. } => layer.nonzero_iter(slots),

src/obikindex/src/layer/tests/typed_layer.rs

@@ -1,6 +1,6 @@
 use super::*;
 use obicompactvec::PersistentSparseBitMatrixBuilder;
-use obikseq::{set_k, Unitig};
+use obikseq::{Unitig, set_k};
 use obiskio::DEFAULT_BLOCK_BITS;
 use tempfile::tempdir;
 
@@ -13,7 +13,8 @@ fn write_unitigs(dir: &Path, seqs: &[&[u8]]) {
 }
 
 fn all_canonical_kmers(dir: &Path) -> Vec<CanonicalKmer> {
-    UnitigFileReader::open_sequential(&dir.join(UNITIGS_FILE)).unwrap()
+    UnitigFileReader::open_sequential(&dir.join(UNITIGS_FILE))
+        .unwrap()
         .iter_indexed_canonical_kmers()
         .map(|(kmer, _, _)| kmer)
         .collect()
@@ -34,13 +35,17 @@ fn canonical_kmer_iter_matches_reader() {
     let dir = tempdir().unwrap();
     write_unitigs(dir.path(), &[b"AAAACGT", b"TTTTGCA"]);
 
-    let from_iter: Vec<CanonicalKmer> = obiskio::CanonicalKmerIter::new(&dir.path().join(UNITIGS_FILE))
-        .unwrap()
-        .collect();
+    let from_iter: Vec<CanonicalKmer> =
+        obiskio::CanonicalKmerIter::new(&dir.path().join(UNITIGS_FILE))
+            .unwrap()
+            .collect();
     let from_reader: Vec<CanonicalKmer> = all_canonical_kmers(dir.path());
 
     assert_eq!(from_iter.len(), from_reader.len(), "different kmer counts");
-    assert_eq!(from_iter, from_reader, "CanonicalKmerIter and UnitigFileReader disagree");
+    assert_eq!(
+        from_iter, from_reader,
+        "CanonicalKmerIter and UnitigFileReader disagree"
+    );
 }
 
 // ── Generic `TypedLayer<D>` over dense vs. sparse presence storage ───────────────
@@ -64,9 +69,14 @@ fn presence_layer_generic_over_sparse_matches_dense() {
     // kmer iff `(kmer's raw bits + g)` is even. Doesn't need to be
     // biologically meaningful, just the same on both sides of the
     // dense/sparse comparison below.
-    TypedLayer::<PersistentBitMatrix>::build_presence(dir.path(), DEFAULT_BLOCK_BITS, &mode, n_genomes, |kmer, g| {
-        (kmer.raw().wrapping_add(g as u64)) % 2 == 0
-    }).unwrap();
+    TypedLayer::<PersistentBitMatrix>::build_presence(
+        dir.path(),
+        DEFAULT_BLOCK_BITS,
+        &mode,
+        n_genomes,
+        |kmer, g| (kmer.raw().wrapping_add(g as u64)) % 2 == 0,
+    )
+    .unwrap();
 
     let dense_layer = TypedLayer::<PersistentBitMatrix>::open(dir.path()).unwrap();
     assert!(dense_layer.n_cols() >= 1);
@@ -76,10 +86,13 @@ fn presence_layer_generic_over_sparse_matches_dense() {
     // same directory, distinct filenames — see
     // `DevDocMD/architecture/siblings.md`'s sparse-matrix section).
     let dense_matrix = obicompactvec::PersistentBitMatrix::open(dir.path()).unwrap();
-    PersistentSparseBitMatrixBuilder::build_from_dense(&dense_matrix, &dir.path().join(PRESENCE_DIR))
-        .unwrap()
-        .close()
-        .unwrap();
+    PersistentSparseBitMatrixBuilder::build_from_dense(
+        &dense_matrix,
+        &dir.path().join(PRESENCE_DIR),
+    )
+    .unwrap()
+    .close()
+    .unwrap();
 
     let sparse_layer = TypedLayer::<PersistentSparseBitMatrix>::open(dir.path()).unwrap();
 
@@ -88,7 +101,10 @@ fn presence_layer_generic_over_sparse_matches_dense() {
     let n = dense_layer.n();
     assert_eq!(n, sparse_layer.n());
     let slots: Vec<usize> = (0..n).collect();
-    assert_eq!(dense_layer.sub_matrix(&slots), sparse_layer.sub_matrix(&slots));
+    assert_eq!(
+        dense_layer.sub_matrix(&slots),
+        sparse_layer.sub_matrix(&slots)
+    );
 
     // The matrix-agnostic, MPHF-only surface (from the generic
     // `impl<D: LayerData> TypedLayer<D>`) must also agree: same kmer set,
@@ -124,15 +140,25 @@ fn count_layer_transparently_reads_sparse_after_pack() {
     // Deterministic, arbitrary count function — same shape as the presence
     // test's arbitrary predicate, just producing a small count instead of a
     // bool.
-    TypedLayer::<()>::build_with_matrix(dir.path(), DEFAULT_BLOCK_BITS, &mode, false, n_genomes, |kmer| {
-        (0..n_genomes)
-            .map(|g| ((kmer.raw().wrapping_add(g as u64)) % 5) as u32)
-            .collect()
-    })
+    TypedLayer::<()>::build_with_matrix(
+        dir.path(),
+        DEFAULT_BLOCK_BITS,
+        &mode,
+        false,
+        n_genomes,
+        |kmer| {
+            (0..n_genomes)
+                .map(|g| ((kmer.raw().wrapping_add(g as u64)) % 5) as u32)
+                .collect()
+        },
+    )
     .unwrap();
 
-    let dense_layer = TypedLayer::<PersistentCompactIntMatrix>::open(dir.path()).unwrap();
-    assert_eq!(dense_layer.storage_kind(), obicompactvec::StorageKind::Columnar);
+    let dense_layer = TypedLayer::<PersistentIntMatrix>::open(dir.path()).unwrap();
+    assert_eq!(
+        dense_layer.storage_kind(),
+        obicompactvec::StorageKind::Columnar
+    );
     let n = dense_layer.n();
     let slots: Vec<usize> = (0..n).collect();
     let dense_sub = dense_layer.sub_matrix(&slots);
@@ -146,8 +172,11 @@ fn count_layer_transparently_reads_sparse_after_pack() {
     // in production.
     obicompactvec::pack_sparse_compact_int_matrix(&dir.path().join(COUNTS_DIR)).unwrap();
 
-    let sparse_layer = TypedLayer::<PersistentCompactIntMatrix>::open(dir.path()).unwrap();
-    assert_eq!(sparse_layer.storage_kind(), obicompactvec::StorageKind::Sparse);
+    let sparse_layer = TypedLayer::<PersistentIntMatrix>::open(dir.path()).unwrap();
+    assert_eq!(
+        sparse_layer.storage_kind(),
+        obicompactvec::StorageKind::Sparse
+    );
     assert_eq!(sparse_layer.n(), n);
     assert_eq!(sparse_layer.n_cols(), dense_layer.n_cols());
     assert_eq!(sparse_layer.sub_matrix(&slots), dense_sub);
@@ -167,13 +196,20 @@ fn count_layer_reports_count_content_and_columnar_storage() {
     set_k(4);
     let dir = tempdir().unwrap();
     write_unitigs(dir.path(), &[b"AAAACGT"]);
-    TypedLayer::<PersistentCompactIntMatrix>::build(dir.path(), DEFAULT_BLOCK_BITS, &IndexMode::Exact, |_| 1)
-        .unwrap();
-    let layer = TypedLayer::<PersistentCompactIntMatrix>::open(dir.path()).unwrap();
+    TypedLayer::<PersistentIntMatrix>::build(dir.pat
+        h(), DEFAUL
+       T_BLOCK_BITS, &Index
+       Mode::Exact, |_| 1)
+       ,
+    ).unwrap();
+    let layer = TypedLayer::<PersistentIntMatrix>::open(dir.path()).unwrap();
 
     assert_eq!(layer.content(), LayerContent::Count);
     assert_eq!(layer.storage_kind(), obicompactvec::StorageKind::Columnar);
-    assert_eq!(layer.evidence_kind(), crate::layer::mphf_layer::EvidenceKind::Exact);
+    assert_eq!(
+        layer.evidence_kind(),
+        crate::layer::mphf_layer::EvidenceKind::Exact
+    );
 }
 
 #[test]
@@ -181,9 +217,14 @@ fn presence_layer_reports_presence_content_and_columnar_storage() {
     set_k(4);
     let dir = tempdir().unwrap();
     write_unitigs(dir.path(), &[b"AAATCTA", b"CTTCGCC", b"TGATACG"]);
-    TypedLayer::<PersistentBitMatrix>::build_presence(dir.path(), DEFAULT_BLOCK_BITS, &IndexMode::Exact, 2, |kmer, g| {
-        (kmer.raw().wrapping_add(g as u64)) % 2 == 0
-    }).unwrap();
+    TypedLayer::<PersistentBitMatrix>::build_presence(
+        dir.path(),
+        DEFAULT_BLOCK_BITS,
+        &IndexMode::Exact,
+        2,
+        |kmer, g| (kmer.raw().wrapping_add(g as u64)) % 2 == 0,
+    )
+    .unwrap();
     let layer = TypedLayer::<PersistentBitMatrix>::open(dir.path()).unwrap();
 
     assert_eq!(layer.content(), LayerContent::Presence);

src/obikindex/src/layer/typed_layer.rs

@@ -1,7 +1,7 @@
 // use crate::layer::utils::layer_dir;
 use obicompactvec::{
     BinaryMatrix, ColBuilder, MatrixBuilder, PersistentBitMatrix, PersistentBitMatrixBuilder,
-    PersistentCompactIntMatrix, PersistentCompactIntMatrixBuilder, PersistentSparseBitMatrix,
+    PersistentCompactIntMatrixBuilder, PersistentIntMatrix, PersistentSparseBitMatrix,
 };
 use obikseq::CanonicalKmer;
 use obiskio::{UnitigFileReader, UnitigFileWriter};
@@ -47,10 +47,10 @@ impl LayerData for () {
     fn read(&self, _slot: usize) {}
 }
 
-impl LayerData for PersistentCompactIntMatrix {
+impl LayerData for PersistentIntMatrix {
     type Item = Box<[u32]>;
     fn open(layer_dir: &Path) -> OKIResult<Self> {
-        PersistentCompactIntMatrix::open(layer_dir).map_err(OKIError::Io)
+        PersistentIntMatrix::open(layer_dir).map_err(OKIError::Io)
     }
     fn read(&self, slot: usize) -> Box<[u32]> {
         self.row(slot)
@@ -112,7 +112,7 @@ pub trait HasLayerContent {
     const CONTENT: LayerContent;
 }
 
-impl HasLayerContent for PersistentCompactIntMatrix {
+impl HasLayerContent for PersistentIntMatrix {
     const CONTENT: LayerContent = LayerContent::Count;
 }
 
@@ -135,9 +135,9 @@ pub trait HasStorageKind {
     fn storage_kind(&self) -> obicompactvec::StorageKind;
 }
 
-impl HasStorageKind for PersistentCompactIntMatrix {
+impl HasStorageKind for PersistentIntMatrix {
     fn storage_kind(&self) -> obicompactvec::StorageKind {
-        PersistentCompactIntMatrix::storage_kind(self)
+        PersistentIntMatrix::storage_kind(self)
     }
 }
 
@@ -342,7 +342,7 @@ impl TypedLayer<()> {
 
 // ── Mode 2 — count matrix ─────────────────────────────────────────────────────
 
-impl TypedLayer<PersistentCompactIntMatrix> {
+impl TypedLayer<PersistentIntMatrix> {
     pub fn build(
         out_dir: &Path,
         block_bits: u8,
@@ -377,12 +377,12 @@ impl TypedLayer<PersistentCompactIntMatrix> {
 
 // ── Mode 2 — count matrix column append ──────────────────────────────────────
 
-impl TypedLayer<PersistentCompactIntMatrix> {
+impl TypedLayer<PersistentIntMatrix> {
     pub fn append_genome_column(
         layer_dir: &Path,
         value_of: impl Fn(usize) -> u32,
     ) -> OKIResult<()> {
-        PersistentCompactIntMatrix::append_column(&layer_dir.join(COUNTS_DIR), value_of)
+        PersistentIntMatrix::append_column(&layer_dir.join(COUNTS_DIR), value_of)
             .map_err(OKIError::Io)
     }
 
@@ -418,7 +418,10 @@ impl TypedLayer<PersistentCompactIntMatrix> {
 
     /// Every nonzero `(idx into slots, col, value)` triple among `slots` —
     /// delegates to `PersistentCompactIntMatrix::nonzero_iter`.
-    pub fn nonzero_iter<'a>(&'a self, slots: &'a [usize]) -> Box<dyn Iterator<Item = (usize, usize, u32)> + 'a> {
+    pub fn nonzero_iter<'a>(
+        &'a self,
+        slots: &'a [usize],
+    ) -> Box<dyn Iterator<Item = (usize, usize, u32)> + 'a> {
         self.data.nonzero_iter(slots)
     }
 }
@@ -477,7 +480,10 @@ impl<D: LayerData<Item = Box<[bool]>> + BinaryMatrix + obicompactvec::ColumnWeig
 impl TypedLayer<PersistentBitMatrix> {
     /// Every nonzero `(idx into slots, col, value)` triple among `slots` —
     /// delegates to `PersistentBitMatrix::nonzero_iter`.
-    pub fn nonzero_iter<'a>(&'a self, slots: &'a [usize]) -> Box<dyn Iterator<Item = (usize, usize, u32)> + 'a> {
+    pub fn nonzero_iter<'a>(
+        &'a self,
+        slots: &'a [usize],
+    ) -> Box<dyn Iterator<Item = (usize, usize, u32)> + 'a> {
         self.data.nonzero_iter(slots)
     }