Struct RleBatch 

pub struct RleBatch<K, V> { /* private fields */ }

Many run-length encoded sequences, each identified by a key.

The sequences are stored back to back in shared arrays, like an Arrow list column: sequence i is runs offsets[i]..offsets[i + 1] of ends and values, and its ends restart at 0. Keys can be any hashable type; use a tuple for keys made of several parts. Key order is preserved.

Operations over the whole batch run in parallel across sequences.

Implementations

impl<K, V> RleBatch<K, V>

pub fn new() -> Self

An empty batch.

pub fn len(&self) -> usize

The number of sequences.

pub fn is_empty(&self) -> bool

pub fn keys(&self) -> &[K]

pub fn offsets(&self) -> &[usize]

Run boundaries per sequence; len() + 1 entries.

pub fn ends(&self) -> &[i64]

The run ends of all sequences, back to back.

pub fn values(&self) -> &[V]

The run values of all sequences, back to back.

pub fn get_index(&self, position: usize) -> Option<RleRef<'_, V>>

The sequence at position, or None if out of range.

pub fn iter(&self) -> impl Iterator<Item = (&K, RleRef<'_, V>)>

Iterates over (key, sequence) in key order.

pub fn into_parts(self) -> (Vec<K>, Vec<usize>, Vec<i64>, Vec<V>)

Splits the batch into keys, offsets, ends and values.

pub fn reduce<T, F>(&self, f: F) -> Vec<T>

where K: Send + Sync, V: Sync, T: Send, F: Fn(RleRef<'_, V>) -> T + Sync,

Computes f for every sequence in parallel, in key order.

pub fn map_rles<W, F>(&self, f: F) -> RleBatch<K, W>

where K: Clone + Send + Sync, V: Sync, W: Send, F: Fn(RleRef<'_, V>) -> Rle<W> + Sync,

Transforms every sequence in parallel, keeping the keys.

pub fn shift(&self, distance: i64, fill: V) -> RleBatch<K, V>

where K: Clone + Send + Sync, V: Clone + Identical + Send + Sync,

Shifts every sequence; see RleLike::shift.

pub fn reversed(&self) -> RleBatch<K, V>

where K: Clone + Send + Sync, V: Clone + Send + Sync,

Reverses every sequence; see RleLike::reversed.

impl<K, V> RleBatch<K, V>

pub fn collapse<K2, F, G>( &self, key: F, fill: Option<&V>, f: G, ) -> Result<RleBatch<K2, V>>

where K: Send + Sync, K2: Hash + Eq + Clone + Send + Sync, V: Clone + Identical + Send + Sync, F: Fn(&K) -> K2, G: Fn(&V, &V) -> V + Sync,

Combines the sequences whose keys map to the same new key, folding each group with f in key order, in parallel across groups.

For example, batch.collapse(|(chrom, _strand)| chrom.clone(), Some(&0), |a, b| a + b) adds the strands of each chromosome together. New keys appear in order of first appearance. Sequences of different lengths are padded with fill; with no fill value that is an error.

impl<K: Hash + Eq + Clone, V> RleBatch<K, V>

pub fn from_rles<I: IntoIterator<Item = (K, Rle<V>)>>(rles: I) -> Result<Self>

Builds a batch from (key, sequence) pairs. Duplicate keys are an error.

pub fn from_parts( keys: Vec<K>, offsets: Vec<usize>, ends: Vec<i64>, values: Vec<V>, ) -> Result<Self>

Builds a batch from its flat parts, validating them.

pub fn push(&mut self, key: K, rle: Rle<V>) -> Result<()>

Appends a sequence under a new key.

pub fn position<Q>(&self, key: &Q) -> Option<usize>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

The position of key, if present.

pub fn get<Q>(&self, key: &Q) -> Option<RleRef<'_, V>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

The sequence for key, if present.

pub fn getitems<Q>( &self, keys: &[Q], starts: &[i64], ends: &[i64], ) -> Result<RleBatch<usize, V>>

where K: Borrow<Q>, Q: Hash + Eq, V: Clone,

Many slices at once: slice k is keys[k]’s sequence at starts[k]..ends[k], clamped. A missing key gives an empty slice. The result is keyed by slice number.

pub fn slice_reduce<'a, Q, T, F>( &'a self, keys: &[Q], starts: &[i64], ends: &[i64], f: F, ) -> Result<Vec<T>>

where K: Borrow<Q> + Send + Sync, Q: Hash + Eq + Sync, V: Sync, T: Send, F: Fn(SliceView<'a, V>) -> T + Sync,

Reduces many slices with f without copying them, in parallel: slice k is keys[k]’s sequence at starts[k]..ends[k], clamped. A missing key gives an empty slice.

pub fn concat(batches: &[&RleBatch<K, V>]) -> RleBatch<K, V>

where K: Send + Sync, V: Clone + Identical + Send + Sync,

Joins the batches end to end key by key, in parallel: each key’s sequences are concatenated in batch order, and a batch without the key contributes nothing. Keys appear in order of first appearance.

pub fn zip_with<B, C, F>( &self, other: &RleBatch<K, B>, how: How, fill_a: Option<&V>, fill_b: Option<&B>, f: F, ) -> Result<RleBatch<K, C>>

where K: Send + Sync, V: Sync, B: Sync, C: Identical + Send, F: Fn(&V, &B) -> C + Sync,

Combines the sequences of two batches key by key with f, in parallel, merging identical neighbours in each result.

how picks the keys; keys appear in the left batch’s order, followed by keys only in the right batch. Sequences of different lengths, and keys missing on one side, are padded with that side’s fill value; with no fill value that is an error naming the output position.

Trait Implementations

impl<K, V> Add<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: Add<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the + operator.

fn add(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the + operation.

impl<K, V> BitAnd<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: BitAnd<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the & operator.

fn bitand(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the & operation.

impl<K, V> BitOr<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: BitOr<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the | operator.

fn bitor(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the | operation.

impl<K, V> BitXor<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: BitXor<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the ^ operation.

impl<K: Clone, V: Clone> Clone for RleBatch<K, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for RleBatch<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> Default for RleBatch<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V> Div<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: Div<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the / operator.

fn div(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the / operation.

impl<K, V> Mul<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: Mul<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the * operator.

fn mul(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the * operation.

impl<K: PartialEq, V: Identical> PartialEq for RleBatch<K, V>

Same keys in the same order, and each pair of sequences equals.

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<K, V> Sub<&RleBatch<K, V>> for &RleBatch<K, V>

where K: Hash + Eq + Clone + Send + Sync, V: Sub<Output = V> + Clone + Default + Identical + Send + Sync,

type Output = RleBatch<K, V>

The resulting type after applying the - operator.

fn sub(self, rhs: &RleBatch<K, V>) -> RleBatch<K, V>

Performs the - operation.