Struct Compressed

pub struct Compressed<T: Element> {
    pub rows: usize,
    pub columns: usize,
    pub nonzeros: usize,
    pub variant: Variant,
    pub values: Vec<T>,
    pub indices: Vec<usize>,
    pub offsets: Vec<usize>,
}

A compressed matrix.

Fields

rows: usize

The number of rows.

columns: usize

The number of columns.

nonzeros: usize

The number of nonzero elements.

variant: Variant

The format variant.

values: Vec<T>

The values of the nonzero elements.

indices: Vec<usize>

The indices of rows when variant = Column or columns when variant = Row of the nonzero elements.

offsets: Vec<usize>

The offsets of columns when variant = Column or rows when variant = Row such that the values and indices of the ith column when variant = Column or the ith row when variant = Row are stored starting from values[j] and indices[j], respectively, where j = offsets[i]. The vector has one additional element, which is always equal to nonzeros.

Implementations

impl<T: Element> Compressed<T>

pub fn new<S: Size>(size: S, variant: Variant) -> Self

Create a zero matrix.

pub fn with_capacity<S: Size>( size: S, variant: Variant, capacity: usize, ) -> Self

Create a zero matrix with a specific capacity.

pub fn get<P: Position>(&self, position: P) -> T

Read an element.

pub fn set<P: Position>(&mut self, position: P, value: T)

Assign a value to an element.

Note that the function treats zero values as any other.

pub fn iter<'l>(&'l self) -> Iterator<'l, T>

Return a sparse iterator.

pub fn iter_mut<'l>(&'l mut self) -> IteratorMut<'l, T>

Return a sparse iterator allowing mutation.

pub fn resize<S: Size>(&mut self, size: S)

Resize the matrix.

pub fn retain<F>(&mut self, condition: F)

where F: FnMut(usize, usize, &T) -> bool,

Retain the elements that satisfy a condition and discard the rest.

Trait Implementations

impl<T: Clone + Element> Clone for Compressed<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Element> Debug for Compressed<T>

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

Formats the value using the given formatter.

impl<'l, T: Element> From<&'l Compressed<T>> for Conventional<T>

fn from(matrix: &'l Compressed<T>) -> Self

Converts to this type from the input type.

impl<'l, T: Element> From<&'l Conventional<T>> for Compressed<T>

fn from(conventional: &'l Conventional<T>) -> Self

Converts to this type from the input type.

impl<'l, T: Element> From<&'l Diagonal<T>> for Compressed<T>

fn from(matrix: &'l Diagonal<T>) -> Self

Converts to this type from the input type.

impl<T: Element> From<Compressed<T>> for Conventional<T>

fn from(matrix: Compressed<T>) -> Self

Converts to this type from the input type.

impl<T: Element> From<Conventional<T>> for Compressed<T>

fn from(matrix: Conventional<T>) -> Self

Converts to this type from the input type.

impl<T: Element> From<Diagonal<T>> for Compressed<T>

fn from(matrix: Diagonal<T>) -> Self

Converts to this type from the input type.

impl<T: Element> Matrix for Compressed<T>

type Element = T

The element type.

fn nonzeros(&self) -> usize

Count nonzero elements.

fn zero<S: Size>(size: S) -> Self

Create a zero matrix.

impl<T> Multiply<Diagonal<T>, Compressed<T>> for Compressed<T>

where T: Element + Number,

fn multiply(&self, right: &Diagonal<T>) -> Self

Perform the multiplication.

impl<'l, T> MultiplyInto<[T], [T]> for Compressed<T>

where T: Element + Number,

fn multiply_into(&self, right: &[T], result: &mut [T])

Perform the multiplication.

impl<'l, T> MultiplyInto<Compressed<T>, [T]> for Conventional<T>

where T: Element + Number,

fn multiply_into(&self, right: &Compressed<T>, result: &mut [T])

Perform the multiplication.

impl<T> MultiplySelf<Diagonal<T>> for Compressed<T>

where T: Element + Number,

fn multiply_self(&mut self, right: &Diagonal<T>)

Perform the multiplication.

impl<T: PartialEq + Element> PartialEq for Compressed<T>

fn eq(&self, other: &Compressed<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: Element> Size for Compressed<T>

fn rows(&self) -> usize

Return the number of rows.

fn columns(&self) -> usize

Return the number of columns.

fn dimensions(&self) -> (usize, usize)

Return the number of rows and columns.

impl<T: Element> Transpose for Compressed<T>

fn transpose(&self) -> Self

Perform the transpose.

impl<T: Element> StructuralPartialEq for Compressed<T>