Struct ComposedOperator 

pub struct ComposedOperator<Input, Output> { /* private fields */ }

A composition of one or more Operators.

Operator composition can be done using multiplication syntax:

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

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

A single operator (ExteriorDerivative or HodgeStar) can also be converted into a ComposedOperator without actually composing it with anything using the std From trait. This enables writing all your operator types as ComposedOperator<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.

Implementations

impl<Input, Output> ComposedOperator<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). useful for boundary conditions.

Trait Implementations

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

fn clone(&self) -> ComposedOperator<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 ComposedOperator<Input, Output>

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl<const D: usize, P> From<ExteriorDerivative<D, P>> for ComposedOperator<<ExteriorDerivative<D, P> as Operator>::Input, <ExteriorDerivative<D, P> as Operator>::Output>

where Const<D>: DimNameAdd<U1>,

fn from(d: ExteriorDerivative<D, P>) -> Self

Converts to this type from the input type.

impl<const D: usize, const MD: usize, P> From<HodgeStar<D, MD, P>> for ComposedOperator<<HodgeStar<D, MD, P> as Operator>::Input, <HodgeStar<D, MD, P> as Operator>::Output>

where Const<MD>: DimNameSub<Const<D>>, P: MeshPrimality,

fn from(s: HodgeStar<D, MD, P>) -> Self

Converts to this type from the input type.

impl<O, D, P> Mul<&CochainImpl<D, P>> for &ComposedOperator<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 ComposedOperator<CochainImpl<D, P>, O>

where O: Operand,

type Output = <ComposedOperator<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<ComposedOperator<L, R>> for f64

type Output = ComposedOperator<L, R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, O, Op> Mul<Op> for ComposedOperator<I, O>

where I: Operand, O: Operand, Op: Operator<Output = <Self as Operator>::Input>,

type Output = ComposedOperator<<Op as Operator>::Input, <ComposedOperator<I, O> as Operator>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Input, Output> Operator for ComposedOperator<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 ComposedOperator<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.