Struct lophat::columns::VecColumn

pub struct VecColumn { /* private fields */ }

A column represented by an increasing vector of the non-zero indices.

To construct call VecColumn::from or use VecColumn::new_with_dimension and VecColumn::add_entries

Trait Implementations

impl Clone for VecColumn

fn clone(&self) -> VecColumn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Column for VecColumn

fn pivot(&self) -> Option<usize>

Returns the index of the lowest non-zero column, or None if the column is empty.

fn add_col(&mut self, other: &Self)

Adds one copy of other into self

fn add_entry(&mut self, entry: usize)

Should be equivalent to self.add_col(e_entry) where e_entry is the column with all zeros except a 1 in index entry.

fn has_entry(&self, entry: &usize) -> bool

Return whether or not entry appears with value 1 in the column

type EntriesIter<'a> = Copied<Iter<'a, usize>>

The output type of Self::entries

fn entries<'a>(&'a self) -> Self::EntriesIter<'a>

Returns the entries of the columns as an iterator over the non-zero indices (not necessarily sorted)

type EntriesRepr = Vec<usize>

A format that the user can provide the entries of the column in, in order to efficiently construct the column. The Default should correspond to the empty column

fn set_entries(&mut self, entries: Self::EntriesRepr)

Efficiently override the column, by providing entries in the internal format.

fn dimension(&self) -> usize

Return the dimension of this column (assuming the matrix represents a chain complex boundary matrix)

fn set_dimension(&mut self, dimension: usize)

Change column to provided dimension

fn is_cycle(&self) -> bool

Returns whether or not the column is a cycle, i.e. has no entries. Provided implementation makes call to Self::pivot. You may wish to provide a more efficient implementation

fn new_with_dimension(dimension: usize) -> Self

Init an empty column with the given dimension

fn set_mode(&mut self, _mode: ColumnMode)

Change the underlying representation of the column to optimise it for the corresponding mode. Only relevant for certain representations.

fn is_boundary(&self) -> bool

Returns whether or not the column is a boundary, i.e. is non-empty. Provided implementation negates Self::is_cycle

fn add_entries<B: Iterator<Item = usize>>(&mut self, entries: B)

Uses Self::add_entry to add elements from the iterator to the column

fn clear_entries(&mut self)

Removes all entries from the column

impl Debug for VecColumn

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

Formats the value using the given formatter.

impl Decomposition<VecColumn> for DecompositionFileFormat

type RColRef<'a> = &'a VecColumn where Self: 'a

Return type of get_r_col, typically &'a C.

fn get_r_col<'a>(&'a self, index: usize) -> Self::RColRef<'a>

Returns a reference to the column in position index of R, in the decomposition

type VColRef<'a> = &'a VecColumn where Self: 'a

Return type of get_v_col, typically &'a C.

fn get_v_col<'a>( &'a self, index: usize ) -> Result<Self::VColRef<'a>, NoVMatrixError>

Returns a reference to the column in position index of V, in the decomposition. Returns NoVMatrixError if V was not maintained by the algorithm.

fn n_cols(&self) -> usize

Returns the number of column in R (equal to the number of columns in D).

fn diagram(&self) -> PersistenceDiagram

Uses the methods implemented by this trait to read-off the column pairings which constiute the persistence diagram.

fn has_v(&self) -> bool

By checking whether self.get_v_col(0) returns an error, determines whether the V matrix was maintained for this decomposition.

impl Default for VecColumn

fn default() -> VecColumn

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for VecColumn

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(usize, Vec<usize>)> for VecColumn

fn from((dimension, boundary): (usize, Vec<usize>)) -> Self

Constructs a VecColumn, from a tuple where boundary is the vector of non-zero indices, sorted in increasing order.

impl PartialEq for VecColumn

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for VecColumn

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for VecColumn