Trait SparseVector 

pub trait SparseVector<T, I>: Clone + IntoIterator<Item = (T, I)> {
    // Required methods
    fn new() -> Self;
    fn unsafe_insert(&mut self, index: I, value: T);
    fn add_or_insert(&mut self, index: I, value: T);
    fn get(&self, index: &I) -> T;
    fn len(&self) -> usize;
    fn is_empty(&self) -> bool;
    fn mul_by(&mut self, factor: T);
    fn mul_element_by(&mut self, index: I, factor: T);
    fn trim(&mut self, cutoff: T);
    fn retain(&mut self, f: impl FnMut(&(T, I)) -> bool);
    fn normalize(&mut self);
    fn iter<'a>(&'a self) -> impl Iterator<Item = &'a (T, I)>
       where T: 'a,
             I: 'a;

    // Provided method
    fn reserve(&mut self, _additional: usize) { ... }
}

A sparse vector keyed by index type I with values of type T.

Used by GeneralizedTableau to store the coefficient over each branching bitstring. The default implementation is Vec<(T, I)>; alternative backings (BTreeMap, HashMap, etc.) can be provided by downstream code.

Required Methods

fn new() -> Self

Construct an empty sparse vector.

fn unsafe_insert(&mut self, index: I, value: T)

Inserts an element without checking whether the index already exists.

fn add_or_insert(&mut self, index: I, value: T)

Add value into the entry at index, creating it if absent.

fn get(&self, index: &I) -> T

Retrieve the value at index, or zero if absent.

fn len(&self) -> usize

Number of stored entries.

fn is_empty(&self) -> bool

true if no entries are stored.

fn mul_by(&mut self, factor: T)

Multiply every entry’s value by factor.

fn mul_element_by(&mut self, index: I, factor: T)

Multiply the value at index by factor. No-op if absent.

fn trim(&mut self, cutoff: T)

Drop entries whose magnitude is at most |cutoff|.

fn retain(&mut self, f: impl FnMut(&(T, I)) -> bool)

Drop entries failing the predicate f.

fn normalize(&mut self)

L2-normalize the vector in place. Panics on zero norm.

fn iter<'a>(&'a self) -> impl Iterator<Item = &'a (T, I)>

where T: 'a, I: 'a,

Borrow the stored entries as an iterator without consuming the vector.

Provided Methods

fn reserve(&mut self, _additional: usize)

Reserve capacity for at least additional more entries. Backings that don’t support pre-allocation can leave this as a no-op.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T, I> SparseVector<T, I> for Vec<(T, I)>

where T: AddAssign + MulAssign + One + ComplexFloat + Zero, f64: Div<<T as ComplexFloat>::Real>, I: PartialEq + Clone,

fn new() -> Self

fn unsafe_insert(&mut self, index: I, value: T)

fn add_or_insert(&mut self, index: I, value: T)

fn get(&self, index: &I) -> T

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn mul_by(&mut self, factor: T)

fn mul_element_by(&mut self, index: I, factor: T)

fn trim(&mut self, cutoff: T)

fn retain(&mut self, f: impl FnMut(&(T, I)) -> bool)

fn reserve(&mut self, additional: usize)

fn iter<'a>(&'a self) -> impl Iterator<Item = &'a (T, I)>

where T: 'a, I: 'a,

fn normalize(&mut self)

Implementors