Struct MapVecMatrix 

pub struct MapVecMatrix<'a, CF, ColT, RowT>
where
    CF: NonZeroCoefficient,
    ColT: BasisElement + Hash,
    RowT: BasisElement,
{
    pub columns: Cow<'a, FxHashMap<ColT, Vec<(CF, RowT)>>>,
}

A sprase matrix stored as a FxHashMap<Column> where each Column is a vector of the non-zero entries. The columns are indexed by any Hash type and the rows are indexed by an arbitrary type.

This is similar to the typical sparse matrix representation in other frameworks.

Fields

columns: Cow<'a, FxHashMap<ColT, Vec<(CF, RowT)>>>

The columns of the matrix. This is stored behind a Cow to allow construction whether you own columns or not

Trait Implementations

impl<'a, CF, ColT, RowT> From<&'a HashMap<ColT, Vec<(CF, RowT)>, BuildHasherDefault<FxHasher>>> for MapVecMatrix<'a, CF, ColT, RowT>

where CF: NonZeroCoefficient, ColT: BasisElement + Hash, RowT: BasisElement,

fn from(value: &'a FxHashMap<ColT, Vec<(CF, RowT)>>) -> Self

Converts to this type from the input type.

impl<CF, ColT, RowT> From<HashMap<ColT, Vec<(CF, RowT)>, BuildHasherDefault<FxHasher>>> for MapVecMatrix<'static, CF, ColT, RowT>

where CF: NonZeroCoefficient, ColT: BasisElement + Hash, RowT: BasisElement,

fn from(value: FxHashMap<ColT, Vec<(CF, RowT)>>) -> Self

Converts to this type from the input type.

impl<'a, CF, ColT, RowT> MatrixOracle for MapVecMatrix<'a, CF, ColT, RowT>

where CF: NonZeroCoefficient, ColT: BasisElement + Hash, RowT: BasisElement,

type CoefficientField = CF

Represents the non-zero elements in the field over which we are doing linear algebra.

type ColT = ColT

Represents elements in the domain basis.

type RowT = RowT

Represents elements in the target basis.

fn column( &self, col: Self::ColT, ) -> impl Iterator<Item = (Self::CoefficientField, Self::RowT)>

Given an element col in the domain basis, express the image of col under the linear transformation as a linear combination of elements in the target basis. You should provide this combination is an iterator of (coeff, row) tuples where each row is an element of the target basis. If coeff is 0 then omit this term from the linear combination.

fn eq_on_col<M2>(&self, other: &M2, col: Self::ColT) -> bool

where Self: Sized, M2: MatrixOracle<CoefficientField = Self::CoefficientField, ColT = Self::ColT, RowT = Self::RowT>,

Checks that the matricies are equal on the specified col, ignoring ordering due to filtration values

fn with_trivial_filtration(self) -> WithTrivialFiltration<Self>

where Self: Sized,

Endows self with a filtration in which all rows have the same filtration value: ().

fn with_filtration<FT: FiltrationValue, F: Fn(Self::RowT) -> FT>( self, filtration_function: F, ) -> WithFuncFiltration<Self, FT, F>

where Self: Sized,

Endows self with the filtration given by the provided filtration_function.

fn with_basis<B>(self, basis: B) -> MatrixWithBasis<Self, B>

where Self: Sized, B: ColBasis<ElemT = Self::ColT>,

Endows self with the basis basis.

fn reverse(self) -> ReverseMatrix<Self>

where Self: Sized,

Reverse the order on both the rows and columns. Both the indices and the filtration values are now the Reverse of their previous type.

fn unreverse<ColT, RowT>(self) -> UnreverseMatrix<Self>

where Self: Sized + MatrixOracle<RowT = Reverse<RowT>, ColT = Reverse<ColT>>,

Reverse the order on both the rows and columns. Can only be called when the indices are of the form Reverse<ColT> and Reverse<RowT> Returns a matrix indexed by ColT and RowT. Additionally, the filtration value can be ‘unreversed’. Can be useful when self was obtained by reducing a reversed matrix.

fn consolidate(self) -> Consolidator<Self>

where Self: Sized,

When accessing a column of the consolidated matrix, the corresponding column of self will be requested and stored into a binary heap. An iterator through this binary heap is then returned.

fn cache_cols(self) -> WithCachedCols<Self>

where Self: Sized,

Returns a wrapper around self which caches any calls to column in an internal HashMap.