Struct lophat::algorithms::LockFreeAlgorithm

pub struct LockFreeAlgorithm<C: Column + 'static> { /* private fields */ }

Implements the parallel, lockfree algorithm introduced by Morozov and Nigmetov. Also able to employ the clearing optimisation of Bauer et al..

Implementations

impl<C: Column + 'static> LockFreeAlgorithm<C>

pub fn get_col_with_pivot( &self, l: usize ) -> Option<(usize, GuardedRef<(C, Option<C>)>)>

Return a column with index l, if one exists. If found, returns (col_idx, col), where col is a tuple consisting of the corresponding column in R and V. If not maintaining V, second entry of tuple is None.

pub fn reduce_column(&self, j: usize)

Reduces the jth column of the matrix as far as possible. If a pivot is found to the right of j (e.g. redued by another thread) then will switch to reducing that column. It is safe to reduce all columns in parallel.

pub fn clear_with_column(&self, boudary_idx: usize)

Uses the boundary built up in column boudary_idx to clear the column corresponding to its pivot

pub fn reduce_dimension(&self, dimension: usize)

Reduce all columns of given dimension in parallel, according to options.

pub fn clear_dimension(&self, dimension: usize)

Clear all columns of given dimension in parallel

Trait Implementations

impl<C: Column> DecompositionAlgo<C> for LockFreeAlgorithm<C>

type Options = LoPhatOptions

A struct of options that you wish to provide to the algorithm.

fn init(options: Option<Self::Options>) -> Self

Initialise the algorithm with the options provided and an empty input matrix

fn add_cols(self, cols: impl Iterator<Item = C>) -> Self

Push the provided columns onto the end of the matrix

fn add_entries(self, entries: impl Iterator<Item = (usize, usize)>) -> Self

Add the provided (row, column) entries to the matrix. If the column has not already been pushed via add_cols then panic!()

type Decomposition = LockFreeDecomposition<C>

Return tupe of decompose – should carry sufficient information to query columns of the resulting decomposition.

fn decompose(self) -> Self::Decomposition

Decomposes the built-up matrix (D) into an R=DV decomposition, following the relevant algorithm and provided options.