Struct SparseVec 

pub struct SparseVec<T: Real = f64> { /* private fields */ }

Work vector with a dense value array and an optional nonzero pattern.

See the module documentation for the representation and invariants.

Implementations

impl<T: Real> SparseVec<T>

pub fn new(size: usize) -> Self

The zero vector of length size, in sparse mode with an empty pattern.

Panics

If size > u32::MAX.

pub fn from_dense(values: &[T]) -> Self

A vector equal to values, in sparse mode with the exact support as pattern (in increasing order).

pub fn size(&self) -> usize

Length of the vector.

pub fn count(&self) -> usize

Number of positions that may be nonzero: |P| in sparse mode, size in dense mode.

pub fn density(&self) -> f64

Fraction count / size (zero for an empty vector).

pub fn is_sparse(&self) -> bool

true iff the vector is in sparse mode (it keeps a pattern).

pub fn pattern(&self) -> Option<&[u32]>

The pattern P in sparse mode (in insertion order), None in dense mode.

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

The dense value array.

pub fn values_mut(&mut self) -> &mut [T]

Mutable access to the dense value array. Since arbitrary writes invalidate the pattern, this switches the vector to dense mode; call SparseVec::rebuild_pattern afterwards to return to sparse mode.

pub fn get(&self, i: u32) -> T

Entry y_i.

pub fn set(&mut self, i: u32, v: T)

Sets y_i ← v.

pub fn add(&mut self, i: u32, delta: T)

Algorithm S: y_i ← y_i + δ.

pub fn clear(&mut self)

Sets y ← 0 and returns to sparse mode with an empty pattern. Costs O(count) when count ≤ 0.3·size, O(size) otherwise.

pub fn scatter(&mut self, alpha: T, idx: &[u32], val: &[T])

Scatter: y ← y + α Σ_k ν_k e_{ι_k} for the packed vector (idx, val). Repeated indices accumulate.

Panics

If the slices differ in length or an index is ≥ size.

pub fn axpy(&mut self, alpha: T, x: &SparseVec<T>)

y ← y + α x. Uses the pattern of x when it has one, and a dense sweep of x otherwise; both paths update exactly the positions with x_i ≠ 0, so the results are identical. The pattern of y is kept if y is in sparse mode.

Panics

If the sizes differ.

pub fn gather(&self, idx: &mut Vec<u32>, val: &mut Vec<T>)

Gather: writes the nonzero entries as a packed vector into idx and val (both cleared first), in pattern order in sparse mode and in increasing index order in dense mode.

pub fn dot(&self, z: &[T]) -> T

Inner product yᵀ z with a dense vector z.

Panics

If z.len() != size.

pub fn tidy(&mut self, drop_tol: T)

Drops negligible entries: every y_i with |y_i| ≤ drop_tol is set to exactly zero and, in sparse mode, removed from the pattern (the solver passes Tolerances::zero).

pub fn iter(&self) -> impl Iterator<Item = (u32, T)> + '_

The entries (i, y_i) of the pattern in sparse mode (in insertion order, explicit zeros included), of every position in dense mode.

pub fn make_dense(&mut self)

Switches to dense mode, discarding the pattern (O(count)).

pub fn rebuild_pattern(&mut self)

Switches to sparse mode with the pattern set to the exact support of y, in increasing order (O(size)).

pub fn check_invariants(&self) -> Result<(), SparseError>

Checks invariants (V1)–(V3).

Trait Implementations

impl<T: Clone + Real> Clone for SparseVec<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Real> Debug for SparseVec<T>

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

Formats the value using the given formatter.