Fix bugs in feature-gated rank and expose more mmap guts

Author: Roderick Bovee

Cargo.toml

@@ -9,6 +9,7 @@ murmurhash3 = "0.0.5"
 
 [features]
 backward_bytes = []
+rank_lookup = []
 
 [dev-dependencies]
 bencher = "0.1.5"

src/combinatorial.rs

@@ -14,23 +14,29 @@ pub fn rank(value: usize, k: u8) -> u128 {
     // `RUST_TEST_THREADS=1 cargo test` or else you'll get tons of
     // errors because of data races between threads with different k's
 
-    // also some tests (i.e. ones with k=1) fail because there are fewer
-    // than 200000 possible values for the table
     unsafe {
         // clear out the lookup table if we have a new k and fill
         // it with values for the new k
         if MARKER_BITS != k {
+            let mut table_size = MARKER_TABLE_SIZE;
+            if k == 1 {
+                table_size = 128;
+            } else if k == 2 {
+                table_size = 8128;
+            }
             MARKER_TABLE = [0; MARKER_TABLE_SIZE];
-            MARKER_TABLE[0] = (1 << k) - 1 as BitVecSlice;
-            for i in 1..MARKER_TABLE_SIZE {
-                MARKER_TABLE[i] = next_marker(MARKER_TABLE[i - 1]);
+            MARKER_TABLE[0] = (1 << k) - 1;
+            for i in 1..table_size {
+                MARKER_TABLE[i] = next_rank(MARKER_TABLE[i - 1]);
             }
             MARKER_BITS = k;
         }
+        // it's possible this may overflow if value > (128 choose k) or return
+        // a bad value (0) if value > (128 choose k) and k == 1 or 2
         if value as usize >= MARKER_TABLE_SIZE {
             let mut marker = MARKER_TABLE[MARKER_TABLE_SIZE - 1];
             for _ in 0..(value as usize - MARKER_TABLE_SIZE) {
-                marker = next_marker(marker);
+                marker = next_rank(marker);
             }
             marker
         } else {
@@ -156,7 +162,7 @@ pub fn choose(n: u64, k: u8) -> u64 {
                 }
             }
             TryFrom::try_from(num / denom)
-                .expect(&format!("{} choose {} is greater than 2**64", n, k))
+                .unwrap_or_else(|_| panic!("{} choose {} is greater than 2**64", n, k))
             // (or recursively) choose(n - 1, k - 1) + choose(n-1, k)
             // for floats, this should work since they handle fractions:
             // (1..u64::from(k)).map(|i| (n + 1 - i) / i).product(),

src/mmap_bitvec.rs

@@ -11,22 +11,22 @@ use bitvec::BitVector;
 
 /// Really annoying we have to mock over both of these rather than memmap
 /// just providing support.
-enum CommonMmap {
+pub enum CommonMmap {
     MmapMut(MmapMut),
     Mmap(Mmap),
 }
 
 impl CommonMmap {
     #[inline]
-    fn as_ptr(&self) -> *const u8 {
+    pub fn as_ptr(&self) -> *const u8 {
         match self {
             CommonMmap::MmapMut(x) => x.as_ptr(),
             CommonMmap::Mmap(x) => x.as_ptr(),
         }
     }
 
     #[inline]
-    fn as_mut_ptr(&mut self) -> *mut u8 {
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
         // maybe we should override the original type signature and return
         // a Result<*mut u8, io::Error> here with the read-only failure?
         match self {
@@ -36,7 +36,7 @@ impl CommonMmap {
     }
 
     #[inline]
-    fn flush(&mut self) -> Result<(), io::Error> {
+    pub fn flush(&mut self) -> Result<(), io::Error> {
         match self {
             CommonMmap::MmapMut(x) => x.flush(),
             CommonMmap::Mmap(_) => Ok(()),
@@ -56,7 +56,7 @@ impl CommonMmap {
 /// assert_eq!(bv.get_range(2..12), 0b1001101101);
 /// ```
 pub struct MmapBitVec {
-    mmap: CommonMmap,
+    pub mmap: CommonMmap,
     pub size: usize,
     header: Box<[u8]>,
 }
@@ -122,7 +122,10 @@ impl MmapBitVec {
         // we have to open with write=true to satisfy MmapMut (which we're
         // using because there's no generic over both MmapMut and Mmap so
         // picking one simplifies the types)
-        let mut file = OpenOptions::new().read(true).write(!read_only).open(filename)?;
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(!read_only)
+            .open(filename)?;
 
         // read the magic bytes and (optionally) check if it matches
         let mut file_magic = [0; 2];