superintervals 0.2.0__tar.gz → 0.2.2__tar.gz

superintervals-0.2.2/MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include src/superintervals *.pyx
+recursive-include src/superintervals *.pxd

{superintervals-0.2.0/src/superintervals.egg-info → superintervals-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: superintervals
-Version: 0.2.0
+Version: 0.2.2
 Summary: Rapid interval intersections
 Author: Kez Cleal
 Author-email: Kez Cleal <clealk@cardiff.ac.uk>

superintervals-0.2.2/README.md

@@ -0,0 +1,282 @@
+SuperIntervals
+==============
+
+A fast, memory-efficient data structure for interval intersection queries.
+SuperIntervals uses a novel superset-index approach that maintains 
+intervals in position-sorted order, enabling cache-friendly searches and SIMD-optimized counting.
+
+### Features:
+
+- Linear-time index construction from sorted intervals
+- Cache-friendly querying
+- SIMD acceleration (AVX2/Neon) for counting operations
+- Minimal memory overhead (one size_t per interval)
+- Available for C++, Rust, Python, and C
+- Optional Eytzinger memory layout for slightly faster queries (C++/Rust only)
+- No dependencies, header only
+
+
+## Quick Start
+
+- Intervals are considered end-inclusive 
+- The index() function must be called before any queries
+- Found intervals are returned in reverse position-sorted order
+
+### 🐍 Python
+
+```python
+from superintervals import IntervalSet
+
+iset = IntervalSet()
+iset.add(10, 20, 'A')
+iset.index()
+overlaps = iset.find_overlaps(8, 20)
+```
+
+### ⚙️ C++
+```cpp
+#include "SuperIntervals.hpp"
+
+SuperIntervals<int, std::string> intervals;
+intervals.add(1, 5, "A");
+intervals.index();
+std::vector<std::string> results;
+intervals.findOverlaps(4, 9, results);
+```
+
+### 🦀 Rust
+
+```rust
+use super_intervals::SuperIntervals;
+
+let mut intervals = SuperIntervals::new();
+intervals.add(1, 5, "A");
+intervals.index();
+let mut results = Vec::new();
+intervals.find_overlaps(4, 11, &mut results);
+```
+
+
+## Test programs
+Test programs expect plain text BED files and only assess chr1 records - other chromosomes are ignored.
+
+C++ program compares SuperIntervals, ImplicitIntervalTree, IntervalTree and NCLS:
+```
+cd test; make
+./run-cpp-libs a.bed b.bed
+```
+
+Rust program:
+```
+RUSTFLAGS="-Ctarget-cpu=native" cargo run --release --example bed-intersect-si
+cargo run --release --example bed-intersect-si a.bed b.bed
+```
+
+## Benchmark
+
+Benchmark
+
+SuperIntervals (SI) was compared with:
+
+    Coitrees (Rust: https://github.com/dcjones/coitrees)
+    Implicit Interval Tree (C++: https://github.com/lh3/cgranges)
+    Interval Tree (C++: https://github.com/ekg/intervaltree)
+    Nested Containment List (C: https://github.com/pyranges/ncls/tree/master/ncls/src)
+
+Main results:
+
+- Finding interval intersections is roughly ~1.5-3x faster than the next best library (Coitrees for Rust, Implicit Interval Tree for C++), with some 
+exceptions. Coitrees-s was faster for one test (ONT reads, sorted DB53 reads).
+- The SIMD counting performance of coitrees and superintervals is similar.
+
+Datasets:
+
+    1. `rna / anno` RNA-seq reads and annotations from cgranges repository
+    2. `ONT reads` nanopore alignments from sample PAO33946 chr1, converted to bed format
+    3. `DB53 reads` paired-end reads from sample DB53, NCBI BioProject PRJNA417592, chr1, converted to bed format
+    4. `mito-b, mito-a` paired-end reads from sample DB53 chrM, converted to bed format (mito-b and mito-a are the same)
+    5. `genes` UCSC genes from hg19
+
+Test programs use internal timers and print data to stdout, measuring the index time, and time to find all intersections. Other steps such as file IO are ignored. Test programs also only assess chr1 bed records - other chromosomes are ignored. For 'chrM' records, the M was replaced with 1 using sed. Data were assessed in position sorted and random order. Datasets can be found on the Releases page, and the test/run_tools.sh script has instructions for how to repeat the benchmark.
+
+Timings were in microseconds using an i9-11900K, 64 GB, 2TB NVMe machine.
+## Finding interval intersections
+
+    Coitrees-s uses the SortedQuerent version of coitrees
+    SI = superintervals. Eytz refers to the eytzinger layout. -rs is the Rust implementation.
+
+### Intervals in sorted order
+
+|                       | Coitrees | Coitrees-s | SuperIntervals-rs | SuperIntervalsEytz-rs | ImplicitITree-C++ | IntervalTree-C++ | NCLS-C | SuperIntervals-C++ | SuperIntervalsEytz-C++ |
+| --------------------- | -------- | ---------- |-------------------| --------------------- | ----------------- | ---------------- | ------ | ------------------ | ---------------------- |
+| DB53 reads, ONT reads | 1668     | 3179       | **757**             | **757**                   | 3831              | 44404            | 10642  | **1315**               | 1358                   |
+| DB53 reads, genes     | 55       | 84         | **21**                | **21**                    | 122               | 109              | 291    | 42                 | **40**                     |
+| ONT reads, DB53 reads | 6504     | **3354**       | 3859              | 3854                  | 17949             | 12280            | 30772  | 5290               | **4462**                   |
+| anno, rna             | 50       | 35         | **18**                | **18**                    | 127               | 90               | 208    | 29                 | **22**                     |
+| genes, DB53 reads     | 1171     | 1018       | 301               | **296**                   | 3129              | 1315             | 1780   | 442                | **323**                    |
+| mito-b, mito-a        | 34769    | 34594      | 16971             | **16952**                 | 93900             | 107660           | 251707 | 33177              | **32985**                  |
+| rna, anno             | 31       | 23         | 21                | **20**                    | 70                | 55               | 233    | 28                 | **27**                     |
+
+### Intervals in random order
+
+|                       | Coitrees | Coitrees-s | SuperIntervals-rs | SuperIntervalsEytz-rs | ImplicitITree-C++ | IntervalTree-C++ | NCLS-C | SuperIntervals-C++ | SuperIntervalsEytz-C++ |
+| --------------------- | -------- | ---------- | ----------------- | --------------------- | ----------------- | ---------------- | ------ | ------------------ | ---------------------- |
+| DB53 reads, ONT reads | 2943     | 4663       | 1356              | **1355**                  | 6505              | 46743            | 11947  | 2491               | **2169**                   |
+| DB53 reads, genes     | 78       | 130        | 27                | **26**                    | 170               | 125              | 305    | 58                 | **51**                     |
+| ONT reads, DB53 reads | 16650    | 18931      | 16116             | **16037**                 | 38677             | 27832            | 53452  | **23003**              | 23232                  |
+| anno, rna             | 89       | 105        | **54**                | **54**                    | 188               | 143              | 294    | **58**                 | 60                     |
+| genes, DB53 reads     | 2222     | 2424       | 1693              | **1684**                  | 4490              | 2701             | 3605   | **1251**               | 1749                   |
+| mito-b, mito-a        | 38030    | 86309      | **18326**             | 18368                 | 125336            | 118321           | 256293 | 42195              | **41695**                  |
+| rna, anno             | 53       | 73         | **45**                | **45**                    | 137               | 83               | 311    | **52**                 | **52**                     |
+
+## Counting interval intersections
+
+### Intervals in sorted order
+
+|                       | Coitrees | SuperIntervals-rs | SuperIntervalsEytz-rs | SuperIntervals-C++ | SuperIntervalsEytz-C++ |
+| --------------------- | -------- | ----------------- | --------------------- | ------------------ | ---------------------- |
+| DB53 reads, ONT reads | 551      | 370               | 371                   | **241**                | 263                    |
+| DB53 reads, genes     | 28       | 12                | 12                    | 8                  | **7**                      |
+| ONT reads, DB53 reads | 2478     | 1909              | 1890                  | 2209               | **1312**                   |
+| anno, rna             | 26       | 14                | 14                    | 22                 | **11**                     |
+| genes, DB53 reads     | 747      | 321               | 336                   | 446                | **290**                    |
+| mito-b, mito-a        | 6894     | 6727              | 6746                  | 3088               | **2966**                   |
+| rna, anno             | **9**        | 13                | 13                    | 12                 | 10                     |
+
+### Intervals in random order
+
+|                       | Coitrees | SuperIntervals-rs | SuperIntervalsEytz-rs | SuperIntervals-C++ | SuperIntervalsEytz-C++ |
+| --------------------- | -------- | ----------------- | --------------------- | ------------------ | ---------------------- |
+| DB53 reads, ONT reads | 1988     | 972               | 969                   | 1016               | **778**                    |
+| DB53 reads, genes     | 53       | 20                | 20                    | 16                 | **13**                     |
+| ONT reads, DB53 reads | 6692     | 8864              | 8733                  | **8182**               | 9523                   |
+| anno, rna             | 52       | 49                | 48                    | **47**                 | 50                     |
+| genes, DB53 reads     | 1503     | 1628              | 1592                  | **1120**               | 1623                   |
+| mito-b, mito-a        | 14354    | 7579              | 7600                  | 4442               | **4383**                   |
+| rna, anno             | 22       | 30                | 29                    | **25**                 | **25**                     |
+
+## Python
+
+Install using `pip install superintervals`
+
+```
+from superintervals import IntervalSet
+
+iset = IntervalSet()
+
+# Add interval start, end, identifier. Integer values are supported
+iset.add(10, 20, 0)
+iset.add(19, 18, 1)
+iset.add(8, 11, 2)
+
+# Index method must be called before queries
+iset.index()
+
+iset.any_overlaps(8, 20)
+# >>> True
+
+iset.count_overlaps(8, 20)
+# >>> 3
+
+iset.find_overlaps(8, 20)
+# >>> [1, 0, 2]
+
+iset.set_search_interval(8, 20)
+for itv in iset:
+    print(itv)
+
+# >>> (19, 18, 1) 
+# >>> (10, 20, 0) 
+# >>> (8, 11, 2)
+
+```
+
+## Cpp
+
+```cpp
+#include <iostream>
+#include <vector>
+#include "SuperIntervals.hpp"
+
+int main() {
+    // Create a SuperIntervals instance for integer intervals with string data
+    // Specify with S, T template types
+    SuperIntervals<int, std::string> intervals;
+
+    // Add some intervals
+    intervals.add(1, 5, "Interval A");
+    intervals.add(3, 7, "Interval B");
+    intervals.add(6, 10, "Interval C");
+    intervals.add(8, 12, "Interval D");
+
+    // Index the intervals (must be called before querying)
+    intervals.index();
+
+    // Find overlaps for the range [4, 9]
+    std::vector<std::string> overlaps;
+    intervals.findOverlaps(4, 9, overlaps);
+
+    // Print the overlapping intervals
+    for (const auto& interval : overlaps) {
+        std::cout << interval << std::endl;
+    }
+    
+    // Count the intervals instead
+    std::cout << "Count: " << intervals.countOverlaps(4, 9) << std::endl;
+    
+    // Count stabbed intervals at point 7
+    std::cout << "Number of intervals containing point 7: " << intervals.countStabbed(7) << std::endl;
+
+    return 0;
+}
+```
+There is also a `SuperIntervalsEytz` subclasses that can be used. `SuperIntervalsEytz` 
+uses an Eytzinger memory layout that can sometimes offer faster query times at the cost of higher memory
+usage and slower indexing time.
+
+## Rust
+
+Fetch using cargo add.
+
+```
+use super_intervals::SuperIntervals;
+
+fn main() {
+    // Create a new instance of SuperIntervals
+    let mut intervals = SuperIntervals::new();
+
+    // Add some intervals with associated data of type T
+    intervals.add(1, 5, "Interval A");
+    intervals.add(10, 15, "Interval B");
+    intervals.add(7, 12, "Interval C");
+
+    // Call index() to prepare the intervals for queries
+    intervals.index();
+
+    // Query for overlapping intervals with a range (4, 11)
+    let mut found_intervals = Vec::new();
+    intervals.find_overlaps(4, 11, &mut found_intervals);
+    
+    // Display found intervals
+    for interval in found_intervals {
+        println!("Found overlapping interval: {}", interval);
+    }
+
+    // Count overlaps with a range (4, 11)
+    let overlap_count = intervals.count_overlaps(4, 11);
+    println!("Number of overlapping intervals: {}", overlap_count);
+}
+```
+There is also `SuperIntervalsEytz` implementation. `SuperIntervalsEytz` 
+uses an Eytzinger memory layout that can sometimes offer faster query times at the cost of higher memory
+usage and slower indexing time.
+
+## Acknowledgements
+
+- The rust test program borrows heavily from the coitrees package
+- The superset-index implemented here exploits a similar interval ordering as described in
+Schmidt 2009 "Interval Stabbing Problems in Small Integer Ranges". However, the superset-index has several advantages including
+  1. An implicit memory layout
+  1. General purpose implementation (not just small integer ranges)
+  1. SIMD counting algorithm 
+- The Eytzinger layout was adapted from Sergey Slotin, Algorithmica

{superintervals-0.2.0 → superintervals-0.2.2}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "superintervals"
-version = "0.2.0"
+version = "0.2.2"
 description = "Rapid interval intersections"
 dependencies = ['Cython']
 authors = [{name = "Kez Cleal", email = "clealk@cardiff.ac.uk"}]

superintervals-0.2.2/src/superintervals/intervalset.pxd

@@ -0,0 +1,56 @@
+# distutils: language = c++
+from libcpp.vector cimport vector
+
+cdef extern from "superintervals.hpp":
+
+    struct IntervalItem:
+        int start, end
+        int data
+
+    cdef cppclass SuperIntervals[int, int]:
+        SuperIntervals() except +
+
+        vector[int] starts, ends, data
+        size_t idx
+
+        void add(int start, int end, int value)
+        void index()
+        void searchInterval(int start, int end)
+        void clear()
+        void reserve(size_t n)
+        size_t size()
+        bint anyOverlaps(int start, int end)
+        size_t countOverlaps(int start, int end)
+        void findOverlaps(int start, int end, vector[int]& found)
+
+        cppclass const_iterator
+        cppclass Iterator:
+            Iterator(const SuperIntervals * list, size_t index)
+            IntervalItem operator *() const
+            Iterator& operator++()
+            bint operator !=(const Iterator& other) const
+            bint operator ==(const Iterator& other) const
+            Iterator begin() const
+            Iterator end() const
+
+            size_t it_index
+
+        Iterator begin() const
+        Iterator end() const
+
+
+cdef class IntervalSet:
+    cdef SuperIntervals* thisptr
+    cdef vector[int] found
+    cdef bint with_data
+    cdef list data
+    cdef int n_intervals
+    cpdef add(self, int start, int end, value=*)
+    cpdef index(self)
+    cpdef set_search_interval(self, int start, int end)
+    cpdef clear(self)
+    cpdef reserve(self, size_t n)
+    cpdef size(self)
+    cpdef any_overlaps(self, int start, int end)
+    cpdef count_overlaps(self, int start, int end)
+    cpdef find_overlaps(self, int start, int end)

superintervals-0.2.2/src/superintervals/intervalset.pyx

@@ -0,0 +1,78 @@
+
+from cython.operator cimport dereference, postincrement, preincrement
+
+
+__all__ = ["IntervalSet"]
+
+cdef class IntervalSet:
+    def __cinit__(self, with_data=False):
+        self.thisptr = new SuperIntervals()
+        self.n_intervals = 0
+        self.with_data = with_data
+    def __dealloc__(self):
+        if self.thisptr:
+            del self.thisptr
+
+    cpdef add(self, int start, int end, value=None):
+        self.thisptr.add(start, end, self.n_intervals)
+        if self.with_data:
+            self.data.append(value)
+        self.n_intervals += 1
+
+    cpdef index(self):
+        if self.with_data:
+            assert self.data == self.n_intervals
+        self.thisptr.index()
+
+    cpdef set_search_interval(self, int start, int end):
+        self.thisptr.searchInterval(start, end)
+
+    cpdef clear(self):
+        self.thisptr.clear()
+        self.n_intervals = 0
+
+    cpdef reserve(self, size_t n):
+        self.thisptr.reserve(n)
+
+    cpdef size(self):
+        return self.thisptr.size()
+
+    cpdef any_overlaps(self, int start, int end):
+        return self.thisptr.anyOverlaps(start, end)
+
+    cpdef count_overlaps(self, int start, int end):
+        return self.thisptr.countOverlaps(start, end)
+
+    cpdef find_overlaps(self, int start, int end):
+        self.found.clear()
+        self.thisptr.findOverlaps(start, end, self.found)
+        return self.found
+
+    def __iter__(self):
+        return IteratorWrapper(self)
+
+
+cdef class IteratorWrapper:
+    cdef SuperIntervals.Iterator * _cpp_iterator
+    cdef SuperIntervals * _si
+
+    def __cinit__(self, IntervalSet interval_set):
+        self._si = interval_set.thisptr
+        self._cpp_iterator = new SuperIntervals.Iterator.Iterator(interval_set.thisptr, interval_set.thisptr.idx)
+
+    def __dealloc__(self):
+        del self._cpp_iterator
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._cpp_iterator[0] == self._cpp_iterator[0].end():
+            raise StopIteration
+
+        cdef int start = self._si.starts[self._cpp_iterator.it_index]
+        cdef int end = self._si.ends[self._cpp_iterator.it_index]
+        cdef int data = self._si.data[self._cpp_iterator.it_index]
+
+        preincrement(self._cpp_iterator[0])
+        return start, end, data

{superintervals-0.2.0 → superintervals-0.2.2/src/superintervals.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: superintervals
-Version: 0.2.0
+Version: 0.2.2
 Summary: Rapid interval intersections
 Author: Kez Cleal
 Author-email: Kez Cleal <clealk@cardiff.ac.uk>

{superintervals-0.2.0 → superintervals-0.2.2}/src/superintervals.egg-info/SOURCES.txt

@@ -1,10 +1,13 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 setup.py
 src/superintervals.hpp
 src/superintervals/__init__.py
 src/superintervals/intervalset.cpp
+src/superintervals/intervalset.pxd
+src/superintervals/intervalset.pyx
 src/superintervals.egg-info/PKG-INFO
 src/superintervals.egg-info/SOURCES.txt
 src/superintervals.egg-info/dependency_links.txt

{superintervals-0.2.0 → superintervals-0.2.2}/src/superintervals.hpp

@@ -209,15 +209,15 @@ class SuperIntervals {
     virtual inline void upperBound(const S value) noexcept {  // https://github.com/mh-dm/sb_lower_bound/blob/master/sbpm_lower_bound.h
         size_t length = starts.size() - 1;
         idx = 0;
-        constexpr int num_per_cache_line = 3 * hardware_constructive_interference_size;
-        while (length >= num_per_cache_line) {
-            size_t half = length / 2;
-//                __builtin_prefetch(&starts[idx + half / 2]);
-//            size_t first_half1 = idx + (length - half);
-//                __builtin_prefetch(&starts[first_half1 + half / 2]);
-            idx += (starts[idx + half] <= value) * (length - half);
-            length = half;
-        }
+//        constexpr int num_per_cache_line = 3 * hardware_constructive_interference_size;
+//        while (length >= num_per_cache_line) {
+//            size_t half = length / 2;
+////                __builtin_prefetch(&starts[idx + half / 2]);
+////            size_t first_half1 = idx + (length - half);
+////                __builtin_prefetch(&starts[first_half1 + half / 2]);
+//            idx += (starts[idx + half] <= value) * (length - half);
+//            length = half;
+//        }
 
         while (length > 0) {
             size_t half = length / 2;
@@ -623,80 +623,3 @@ private:
         return eytzinger_helper(arr, n, 0, 0);
     }
 };
-
-
-template<typename S, typename T>
-class SuperIntervalsDense : public SuperIntervals<S, T> {
-public:
-
-    void index() override {
-        if (this->starts.size() == 0) {
-            return;
-        }
-        if (this->starts.size() == 1) {
-            dense.resize(1, 0);
-        }
-        this->starts.shrink_to_fit();
-        this->ends.shrink_to_fit();
-        this->data.shrink_to_fit();
-        this->sortIntervals();
-
-        // Could probably use a queue here to make dense vector in O(n) time
-        min_value = this->starts.front();
-        max_value = *std::max_element(this->ends.begin(), this->ends.end());
-        S max_size = max_value - min_value;
-        dense.resize((size_t)max_size, INT_MAX);
-        size_t index, end_index;
-        for (int i = this->starts.size() - 1; i >= 0; --i) {
-            index = (size_t)((this->starts[i] - min_value));
-            end_index = (size_t)(this->ends[i] - min_value);
-            for (size_t j=index; j < end_index + 1; ++j) {
-                if (dense[j] == INT_MAX) {
-                    dense[j] = i;
-                }
-            }
-            ++end_index;
-            while (end_index < dense.size() && dense[end_index] == INT_MAX) {
-                dense[end_index] = i;
-                ++end_index;
-            }
-        }
-
-        this->branch.resize(this->starts.size(), SIZE_MAX);
-        std::vector<std::pair<S, size_t>> br;
-        br.reserve(1000);
-        br.emplace_back() = {this->ends[0], 0};
-        for (size_t i=1; i < this->ends.size(); ++i) {
-            while (!br.empty() && br.back().first < this->ends[i]) {
-                br.pop_back();
-            }
-            if (!br.empty()) {
-                this->branch[i] = br.back().second;
-            }
-            br.emplace_back() = {this->ends[i], i};
-        }
-        this->idx = 0;
-    }
-
-    inline void upperBound(const S x) noexcept override {
-        size_t i = 0;
-        if (min_value > x) {
-            this->idx = 0;
-            return;
-        } else if (x > max_value) {
-            this->idx = this->starts.size() - 1;
-            return;
-        }
-        size_t target_idx = (size_t)(x - min_value);
-
-        this->idx = (size_t)dense[target_idx];
-        if (this->idx > this->starts.size()) {
-            this->idx = 0;
-        }
-    }
-
-private:
-    std::vector<uint32_t> dense;
-
-    S min_value, max_value;
-};

superintervals-0.2.0/README.md

@@ -1,279 +0,0 @@
-SuperIntervals
-==============
-
-A fast, memory-efficient data structure for interval intersection queries.
-SuperIntervals uses a novel superset-index approach that maintains 
-intervals in position-sorted order, enabling cache-friendly searches and SIMD-optimized counting.
-
-### Features:
-
-- Linear-time index construction from sorted intervals
-- Cache-friendly querying
-- SIMD acceleration (AVX2/Neon) for counting operations
-- Minimal memory overhead (one size_t per interval)
-- Available for C++, Rust, Python, and C
-- Optional Eytzinger memory layout for slightly faster queries (C++/Rust only)
-- No dependencies, header only
-
-
-## Quick Start
-
-- Intervals are considered end-inclusive 
-- The index() function must be called before any queries
-- Found intervals are returned in reverse position-sorted order
-
-### 🐍 Python
-
-```python
-from superintervals import IntervalSet
-
-iset = IntervalSet()
-iset.add(10, 20, 'A')
-iset.index()
-overlaps = iset.find_overlaps(8, 20)
-```
-
-### ⚙️ C++
-```cpp
-#include "SuperIntervals.hpp"
-
-SuperIntervals<int, std::string> intervals;
-intervals.add(1, 5, "A");
-intervals.index();
-std::vector<std::string> results;
-intervals.findOverlaps(4, 9, results);
-```
-
-### 🦀 Rust
-
-```rust
-use super_intervals::SuperIntervals;
-
-let mut intervals = SuperIntervals::new();
-intervals.add(1, 5, "A");
-intervals.index();
-let mut results = Vec::new();
-intervals.find_overlaps(4, 11, &mut results);
-```
-
-
-## Test programs
-Test programs expect plain text BED files and only assess chr1 records - other chromosomes are ignored.
-
-C++ program compares SuperIntervals, ImplicitIntervalTree, IntervalTree and NCLS:
-```
-cd test; make
-./run-cpp-libs a.bed b.bed
-```
-
-Rust program:
-```
-RUSTFLAGS="-Ctarget-cpu=native" cargo run --release --example bed-intersect-si
-cargo run --release --example bed-intersect-si a.bed b.bed
-```
-
-## Benchmark
-
-SuperIntervals (SI) was compared with:
-- Coitrees (Rust: https://github.com/dcjones/coitrees)
-- Implicit Interval Tree (C++: https://github.com/lh3/cgranges)
-- Interval Tree (C++: https://github.com/ekg/intervaltree)
-- Nested Containment List (C: https://github.com/pyranges/ncls/tree/master/ncls/src)
-
-Main results:
-- Roughly ~2-3x faster than the next best library (Coitrees for Rust, Implicit Interval Tree for C++)
-
-### Datasets:
-1. Random regions generated using bedtools
-2. RNA-seq reads and annotations from cgranges repository
-3. ONT reads from sample PAO33946 (chr1, chrM)
-4. Paired-end reads from sample DB53, NCBI BioProject PRJNA417592, (chr1, chrM)
-5. UCSC genes from hg19
-
-Test programs use internal timers and print data to stdout, measuring the 
-index time, and time to find all intersections. Other steps such as file IO are ignored. Test programs also 
-only assess chr1 bed records - other chromosomes are ignored. For 'chrM' records,
-the M was replaced with 1 using sed. Data were assessed in position sorted and random order.
-Datasets can be found on the Releases page, and the `test/run_tools.sh` script has instructions
-for how to repeat the benchmark.
-
-Timings were in microseconds using an i9-11900K, 64 GB, 2TB NVMe machine.
-
-
-### 1. Finding interval intersections
-
-- Coitrees-s uses the `SortedQuerent` version of coitrees
-- SI = superintervals. Eytz refers to the eytzinger layout. `-rs` is the Rust implementation.
-
-#### Intervals in sorted order
-
-|                       | Coitrees | Coitrees-s | SI-rs       | SI-rs     | ImplicitITree-C++ | IntervalTree-C++ | NCLS-C   | SI-C++  | SI-Eytz-C++ |
-| --------------------- | -------- | ---------- |-------------|-----------| ----------------- | ---------------- | -------- |---------|-------------|
-| DB53 reads, ONT reads | 1649.6   | 3169       | 732         | **729**   | 3802.6            | 46393.8          | 10833.6  | 1391.6  | **1365.6**  |
-| DB53 reads, genes     | 54.2     | 82.8       | **21**      | **21**    | 121.6             | 108              | 292.8    | 43      | **40.2**    |
-| ONT reads, DB53 reads | 6487.2   | 3437.2     | 534.6       | **533.6** | 18067.4           | 12448            | 31466.2  | 5333.2  | **4545.2**  |
-| anno, rna             | 49.6     | 33.6       | 17.2        | **17**    | 127.2             | 91.2             | 210.6    | 31.2    | **21.2**    |
-| genes, DB53 reads     | 1171     | 992.8      | 270         | **269.2** | 3141              | 1339.8           | 1768     | 441.8   | **315**     |
-| mito-b, mito-a        | 35046.2  | 35134      | **13115.2** | 13117.2   | 95137.4           | 108567.8         | 250671.8 | 33703.8 | **33298.6** |
-| rna, anno             | 31.8     | 22.6       | **4**       | **4**     | 71.2              | 54               | 238.8    | 29.4    | **27.2**    |
-
-#### Intervals in random order
-
-|                       | Coitrees | Coitrees-s | SI-rs     | SI-Eytz-rs | ImplicitITree-C++ | IntervalTree-C++ | NCLS-C   | SI-C++     | SI-Eytz-C++ |
-| --------------------- | -------- | ---------- |-----------|------------| ----------------- | ---------------- | -------- |------------|-------------|
-| DB53 reads, ONT reads | 2939.6   | 4746.6     | 1323      | **1273**   | 6654.6            | 46771.8          | 12082.4  | 2544.4     | **2180.2**  |
-| DB53 reads, genes     | 75.2     | 131        | 26.6      | **26**     | 168.2             | 122.8            | 308.2    | 56.4       | **51.4**    |
-| ONT reads, DB53 reads | 17100.6  | 19309.2    | 3815      | **3714.6** | 40490.8           | 28633.2          | 55317.6  | 24047      | **23664**   |
-| anno, rna             | 89.6     | 110        | 42.2      | **41.8**   | 188.8             | 150.2            | 299.4    | **58**     | **58**      |
-| genes, DB53 reads     | 2217.6   | 2448.8     | 1343.8    | **1331.6** | 4495.8            | 2747.2           | 3632.2   | **1265.2** | 1730.8      |
-| mito-b, mito-a        | 39002.8  | 88901.8    | **13540** | 13541.8    | 128507.2          | 120712           | 261409.2 | 43682      | **42576.8** |
-| rna, anno             | 51       | 69.2       | 12        | **11.8**   | 140.4             | 84.4             | 323.8    | 54.2       | **53**      |
-
-### 2. Counting interval intersections
-
-#### Intervals in sorted order
-
-|                       | Coitrees | SI-rs     | SI-Eytz-rs | SI-C++    | SI-Eytz-C++ |
-| --------------------- | -------- |-----------|------------|-----------|-------------|
-| DB53 reads, ONT reads | 551.4    | 337.6     | 338        | **239.4** | 265         |
-| DB53 reads, genes     | 26       | 10.6      | 10.8       | 8         | **7**       |
-| ONT reads, DB53 reads | 2517.2   | **795.4** | 796.6      | 2234.2    | 1414.2      |
-| anno, rna             | 26.8     | 13.4      | 13.2       | 22.6      | **12**      |
-| genes, DB53 reads     | 737.4    | **292.6** | 294.6      | 459.6     | 338.2       |
-| mito-b, mito-a        | 7030     | 6634.6    | 6633.4     | 3065.6    | **2991.8**  |
-| rna, anno             | 9        | **4**     | **4**      | 12        | 10          |
-
-#### Intervals in random order
-
-|                       | Coitrees | SI-rs  | SI-Eytz-rs | SI-C++ | SI-Eytz-C++ |
-| --------------------- | -------- | ------ | ---------- | ------ | ----------- |
-| DB53 reads, ONT reads | 1990     | 937.2  | 883.4      | 1018.8 | **789.6**       |
-| DB53 reads, genes     | 49.2     | 16     | 15         | 15.2   | **13.4**        |
-| ONT reads, DB53 reads | 6835     | 4037.8 | **3964.4**     | 8547.8 | 10153.8     |
-| anno, rna             | 52       | 39     | **38.6**       | 47     | 46          |
-| genes, DB53 reads     | 1523.6   | 1261   | 1269       | **1119.4** | 1519.6      |
-| mito-b, mito-a        | 15001.2  | 7290.6 | 7298.4     | 4493.6 | **4452.4**      |
-| rna, anno             | 22       | **12**     | **12**         | 25.2   | 25.4        |
-
-## Python
-
-Install using `pip install .`
-
-```
-from superintervals import IntervalSet
-
-iset = IntervalSet()
-
-# Add interval start, end, identifier. Integer values are supported
-iset.add(10, 20, 0)
-iset.add(19, 18, 1)
-iset.add(8, 11, 2)
-
-# Index method must be called before queries
-iset.index()
-
-iset.any_overlaps(8, 20)
-# >>> True
-
-iset.count_overlaps(8, 20)
-# >>> 3
-
-iset.find_overlaps(8, 20)
-# >>> [1, 0, 2]
-
-iset.set_search_interval(8, 20)
-for itv in iset:
-    print(itv)
-
-# >>> (19, 18, 1) 
-# >>> (10, 20, 0) 
-# >>> (8, 11, 2)
-
-```
-
-## Cpp
-
-```cpp
-#include <iostream>
-#include <vector>
-#include "SuperIntervals.hpp"
-
-int main() {
-    // Create a SuperIntervals instance for integer intervals with string data
-    // Specify with S, T template types
-    SuperIntervals<int, std::string> intervals;
-
-    // Add some intervals
-    intervals.add(1, 5, "Interval A");
-    intervals.add(3, 7, "Interval B");
-    intervals.add(6, 10, "Interval C");
-    intervals.add(8, 12, "Interval D");
-
-    // Index the intervals (must be called before querying)
-    intervals.index();
-
-    // Find overlaps for the range [4, 9]
-    std::vector<std::string> overlaps;
-    intervals.findOverlaps(4, 9, overlaps);
-
-    // Print the overlapping intervals
-    for (const auto& interval : overlaps) {
-        std::cout << interval << std::endl;
-    }
-    
-    // Count the intervals instead
-    std::cout << "Count: " << intervals.countOverlaps(4, 9) << std::endl;
-    
-    // Count stabbed intervals at point 7
-    std::cout << "Number of intervals containing point 7: " << intervals.countStabbed(7) << std::endl;
-
-    return 0;
-}
-```
-There is also a `SuperIntervalsEytz` subclasses that can be used. `SuperIntervalsEytz` 
-uses an Eytzinger memory layout that can sometimes offer faster query times at the cost of higher memory
-usage and slower indexing time.
-
-## Rust
-
-```
-use super_intervals::SuperIntervals;
-
-fn main() {
-    // Create a new instance of SuperIntervals
-    let mut intervals = SuperIntervals::new();
-
-    // Add some intervals with associated data of type T
-    intervals.add(1, 5, "Interval A");
-    intervals.add(10, 15, "Interval B");
-    intervals.add(7, 12, "Interval C");
-
-    // Call index() to prepare the intervals for queries
-    intervals.index();
-
-    // Query for overlapping intervals with a range (4, 11)
-    let mut found_intervals = Vec::new();
-    intervals.find_overlaps(4, 11, &mut found_intervals);
-    
-    // Display found intervals
-    for interval in found_intervals {
-        println!("Found overlapping interval: {}", interval);
-    }
-
-    // Count overlaps with a range (4, 11)
-    let overlap_count = intervals.count_overlaps(4, 11);
-    println!("Number of overlapping intervals: {}", overlap_count);
-}
-```
-There is also `SuperIntervalsEytz` implementation. `SuperIntervalsEytz` 
-uses an Eytzinger memory layout that can sometimes offer faster query times at the cost of higher memory
-usage and slower indexing time.
-
-## Acknowledgements
-
-- The rust test program borrows heavily from the coitrees package
-- The superset-index implemented here exploits a similar interval ordering as described in
-Schmidt 2009 "Interval Stabbing Problems in Small Integer Ranges". However, the superset-index has several advantages including
-  1. An implicit memory layout
-  1. General purpose implementation (not just small integer ranges)
-  1. SIMD counting algorithm