Struct SparseContainer 

pub struct SparseContainer<T: Clone> { /* private fields */ }

A sparse container stores contiguous vertical slices of data

Implementations

impl<T: Clone> SparseContainer<T>

pub fn new() -> SparseContainer<T>

pub fn all_missing(n: usize) -> SparseContainer<T>

create an n-length container will all missing data

pub fn present_iter(&self) -> impl Iterator<Item = &T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn n_present(&self) -> usize

Return the number of present data

pub fn n_missing(&self) -> usize

Return the number of missing data

pub fn is_present(&self, ix: usize) -> bool

Returns true if the value at ix is present.

Notes

Will panic id ix is out of bounds

pub fn is_missing(&self, ix: usize) -> bool

Returns true if the value at ix is missing.

Notes

Will panic id ix is out of bounds

pub fn defragment(&mut self) -> usize

Ensure all adjacent data slices are joined. Reduces indirection. Returns the number of slice merge operations performed.

pub fn pop_front(&mut self, n: usize) -> Vec<Option<T>>

pub fn set_missing(&mut self, ix: usize) -> Option<T>

Set the datum at index ix as missing and return the entry that we there if it existed.

pub fn extract(&mut self, ix: usize) -> Option<T>

Completely remove the datum at index ix and return it if it exists.

This operation decrements the total number of data by one.

pub fn break_slices(&mut self, max_slice_len: usize)

Breaks any slice greater than max_slice_len to be between (max_slice_len + 1) / 2 and max_slice_len. This is designed to help parallelism.

Trait Implementations

impl<T: Clone> AccumScore<T> for SparseContainer<T>

fn accum_score<F: Fn(&T) -> f64>(&self, scores: &mut [f64], ln_f: &F)

Compute scores on the data using score_fn and add them to scores

impl<T: Clone + Clone> Clone for SparseContainer<T>

fn clone(&self) -> SparseContainer<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + TryFrom<Datum>> Container<T> for SparseContainer<T>

fn get_slices(&self) -> Vec<(usize, &[T])>

get the data slices and the start indices

fn get(&self, ix: usize) -> Option<T>

Get the entry at ix if it exists

fn present_cloned(&self) -> Vec<T>

Get as cloned vector containing only the present data

fn push(&mut self, xopt: Option<T>)

Append a new datum to the end of the container

fn insert_overwrite(&mut self, ix: usize, x: T)

Insert or overwrite an entry at ix

fn remove(&mut self, ix: usize) -> Option<T>

Remove and return the entry at ix if it exists. Used to mark a present datum as missing, not to completely remove a record. Does not decrease the length.

fn upsize(&mut self, n: usize)

Append n new empty entries to the container

fn push_datum(&mut self, x: Datum)

fn insert_datum(&mut self, row_ix: usize, x: Datum)

impl<T: Debug + Clone> Debug for SparseContainer<T>

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

Formats the value using the given formatter.

impl<T: Clone> Default for SparseContainer<T>

fn default() -> SparseContainer<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for SparseContainer<T>

where T: Deserialize<'de> + Default + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Clone> From<Vec<(T, bool)>> for SparseContainer<T>

fn from(xs: Vec<(T, bool)>) -> SparseContainer<T>

Converts to this type from the input type.

impl<T: Clone> From<Vec<Option<T>>> for SparseContainer<T>

fn from(xs: Vec<Option<T>>) -> SparseContainer<T>

Converts to this type from the input type.

impl<T: Clone> From<Vec<T>> for SparseContainer<T>

fn from(xs: Vec<T>) -> SparseContainer<T>

Converts to this type from the input type.

impl<T: PartialEq + Clone> PartialEq for SparseContainer<T>

fn eq(&self, other: &SparseContainer<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for SparseContainer<T>

where T: Serialize + Clone,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Clone> StructuralPartialEq for SparseContainer<T>