Struct MatrixOperator 

pub struct MatrixOperator<Input, Output> {
    pub mat: CsrMatrix<f64>,
    /* private fields */
}

A general sparse matrix operator, parameterized with the cochain types it consumes and produces.

This can be a composition of one or more MatrixOperators and DiagonalOperators. Composition can be done using multiplication syntax:

let op: MatrixOperator<_, _> = mesh.star() * mesh.d::<1, Primal>();

A free function compose is also provided for the same purpose.

There is also a DiagonalOperator type for operators which are specifically diagonal matrices, which stores them in a somewhat more efficient format. When you don’t need the efficiency and prefer notational convenience, these can also be converted into a MatrixOperator using the std From trait. This enables writing all your operator types as MatrixOperator<Input, Output>, a convenient pattern which can be written more concisely with the type alias Op. See the crate-level docs and examples for details.

Fields

mat: CsrMatrix<f64>

The underlying matrix, exposed for potential use cases that need to modify or read matrix values directly.

Modifying the dimensions of this matrix will result in runtime errors.

Implementations

impl<Input, Output> MatrixOperator<Input, Output>

where Input: Operand, Output: Operand,

pub fn exclude_subset( self, set: &SubsetImpl<<Output as Operand>::Dimension, <Output as Operand>::Primality>, ) -> Self

Set a subset of elements in the output cochain to zero when this operator is applied (i.e. set a subset of rows in the operator matrix to zero).

pub fn restrict_to_subset( self, set: &SubsetImpl<<<Self as Operator>::Output as Operand>::Dimension, <<Self as Operator>::Output as Operand>::Primality>, ) -> Self

Set all output elements that aren’t part of the given subset to zero.

Trait Implementations

impl<Input: Clone, Output: Clone> Clone for MatrixOperator<Input, Output>

fn clone(&self) -> MatrixOperator<Input, Output>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Input: Debug, Output: Debug> Debug for MatrixOperator<Input, Output>

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

Formats the value using the given formatter.

impl<Input, Output> From<CsrMatrix<f64>> for MatrixOperator<Input, Output>

fn from(mat: CsrMatrix<f64>) -> Self

Converts to this type from the input type.

impl<Input, Output> From<DiagonalOperator<Input, Output>> for MatrixOperator<Input, Output>

where DiagonalOperator<Input, Output>: Operator,

fn from(s: DiagonalOperator<Input, Output>) -> Self

Converts to this type from the input type.

impl<O, D, P> Mul<&CochainImpl<D, P>> for &MatrixOperator<CochainImpl<D, P>, O>

where O: Operand,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &CochainImpl<D, P>) -> Self::Output

Performs the * operation.

impl<O, D, P> Mul<&CochainImpl<D, P>> for MatrixOperator<CochainImpl<D, P>, O>

where O: Operand,

type Output = <MatrixOperator<CochainImpl<D, P>, O> as Operator>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &CochainImpl<D, P>) -> Self::Output

Performs the * operation.

impl<L, R> Mul<MatrixOperator<L, R>> for f64

type Output = MatrixOperator<L, R>

The resulting type after applying the * operator.

fn mul(self, rhs: MatrixOperator<L, R>) -> Self::Output

Performs the * operation.

impl<In, Out, OtherIn> Mul<MatrixOperator<OtherIn, In>> for DiagonalOperator<In, Out>

where In: Operand, Out: Operand, OtherIn: Operand,

type Output = MatrixOperator<OtherIn, Out>

The resulting type after applying the * operator.

fn mul(self, rhs: MatrixOperator<OtherIn, In>) -> Self::Output

Performs the * operation.

impl<In, Out, Op> Mul<Op> for MatrixOperator<In, Out>

where In: Operand, Out: Operand, Op: Operator<Output = <Self as Operator>::Input>,

type Output = MatrixOperator<<Op as Operator>::Input, <MatrixOperator<In, Out> as Operator>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Op) -> Self::Output

Performs the * operation.

impl<Input, Output> Neg for MatrixOperator<Input, Output>

type Output = MatrixOperator<Input, Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Input, Output> Operator for MatrixOperator<Input, Output>

where Input: Operand, Output: Operand,

type Input = Input

The type of cochain this operator takes as an input.

type Output = Output

The type of cochain this operator produces as an output.

fn apply(&self, input: &Self::Input) -> Self::Output

Apply this operator to an input cochain.

fn into_csr(self) -> CsrMatrix<f64>

Convert this operator into a CSR matrix.

impl<L, R> PartialEq for MatrixOperator<L, R>

fn eq(&self, other: &Self) -> 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.