fix: improve perf of count with smarter handling of half-open range

The BITS paper uses fully inclusive ranges. When this was written
I'm not sure I understood that. To get things to match the naive
version of count (find -> count) I had a while loop in the bits
count method to advance the cursor past the matched start/stop
index.

This change was found while porting mojo-lapper and removes the
while loop. It also has a more effecient branchless binary search.

Benchmarks for count improve 24-30% (see PR).

Author: sstadick

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust-lapper"
-version = "1.1.0"
+version = "1.2.0"
 authors = ["Seth Stadick <sstadick@gmail.com>"]
 edition = "2018"
 license = "MIT"

Cargo.toml

@@ -350,7 +350,7 @@ where
         if let Some(first) = ivs.next() {
             stack.push_back(first);
             for interval in ivs {
-                let mut top = stack.pop_back().unwrap();
+                let top = stack.pop_back().unwrap();
                 if top.stop < interval.start {
                     stack.push_back(top);
                     stack.push_back(interval);
@@ -422,24 +422,20 @@ where
     where
         K: PartialEq + PartialOrd,
     {
-        if elems.is_empty() {
+        if elems.is_empty() || elems[0] >= *key {
             return 0;
+        } else if elems[elems.len() - 1] < *key {
+            return elems.len();
         }
-        if elems[0] > *key {
-            return 0;
-        }
-        let mut high = elems.len();
-        let mut low = 0;
 
-        while high - low > 1 {
-            let mid = (high + low) / 2;
-            if elems[mid] < *key {
-                low = mid;
-            } else {
-                high = mid;
-            }
+        let mut cursor = 0;
+        let mut length = elems.len();
+        while length > 1 {
+            let half = length >> 1;
+            length -= half;
+            cursor += (usize::from(elems[usize::from(cursor + half - 1)] < *key)) * half;
         }
-        high
+        cursor
     }
 
     /// Find the union and the intersect of two lapper objects.
@@ -587,23 +583,11 @@ where
     #[inline]
     pub fn count(&self, start: I, stop: I) -> usize {
         let len = self.intervals.len();
-        let mut first = Self::bsearch_seq(start, &self.stops);
+        // Plus one to account for half-openness of lapper intervals compared to BITS paper
+        let first = Self::bsearch_seq(start + one::<I>(), &self.stops);
         let last = Self::bsearch_seq(stop, &self.starts);
-        //println!("{}/{}", start, stop);
-        //println!("pre start found in stops: {}: {}", first, self.stops[first]);
-        //println!("pre stop found in starts: {}", last);
-        //while last < len && self.starts[last] == stop {
-        //last += 1;
-        //}
-        while first < len && self.stops[first] == start {
-            first += 1;
-        }
         let num_cant_after = len - last;
         len - first - num_cant_after
-        //println!("{:#?}", self.starts);
-        //println!("{:#?}", self.stops);
-        //println!("start found in stops: {}", first);
-        //println!("stop found in starts: {}", last);
     }
 
     /// Find all intervals that overlap start .. stop
@@ -1022,6 +1006,7 @@ mod tests {
     fn test_query_start_interval_stop() {
         let lapper = setup_nonoverlapping();
         let mut cursor = 0;
+        println!("{:?}",lapper);
         assert_eq!(None, lapper.find(30, 35).next());
         assert_eq!(None, lapper.seek(30, 35, &mut cursor).next());
         assert_eq!(lapper.find(30, 35).count(), lapper.count(30, 35));