Struct DiagonalOperator 

pub struct DiagonalOperator<Input, Output> {
    pub diagonal: DVector<f64>,
    /* private fields */
}

A diagonal matrix operator.

See MatrixOperator and the crate-level docs for more details.

Fields

diagonal: DVector<f64>

The diagonal values of the matrix, stored as a vector.

Modifying the dimension of this vector will result in runtime errors.

Values of the diagonal can also be accessed by indexing with SimplexViews / DualCellViews corresponding to the output type of the operator:

type P = Cochain<1, Primal>;
type D = Cochain<2, Dual>;

let star: DiagonalOperator<P, D> = mesh_3d.star();
let star_dual: DiagonalOperator<D, P> = mesh_3d.star();

for edge in mesh_3d.simplices::<1>() {
    // these stars are inverses of each other so they should multiply to 1
    assert!((star_dual[edge] * star[edge.dual()] - 1.).abs() < 1e-6);
}

This can be handy to e.g. retrieve values of material parameters stored in an operator created with SimplicialMesh::scaling.

Implementations

impl<Input, Output> DiagonalOperator<Input, Output>

where Input: Operand, Output: Operand,

pub fn exclude_subset( self, set: &SubsetImpl<<<Self as Operator>::Output as Operand>::Dimension, <<Self as Operator>::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.

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.

pub fn inverse(&self) -> DiagonalOperator<Output, Input>

The matrix inverse of this diagonal operator (i.e. simply the reciprocals of the elements).

At the type level, this swaps the input and output types. If you need the types to remain the same, use recip instead. Note also that this is not always the same as the dual Hodge star, since it can differ from the matrix inverse by a sign.

pub fn recip(&self) -> Self

The matrix inverse of this operator, but unlike inverse, keeping the input and output types unchanged.

This and inverse are both simply more convenient ways to write DiagonalOperator::from(my_op.diagonal.map(|el| 1. / el)), which is still a useful pattern if you need more esoteric manipulations than simple scalings or inverses.

pub fn inner_product(&self, lhs: &Input, rhs: &Input) -> f64

Compute the inner product between two cochains defined by this operator, i.e. the matrix product a^T D b, where D is this operator and a,b are cochains of its input type.

Note: this does not check that the operator is positive definite, so the operation may not actually be an inner product.

pub fn norm(&self, c: &Input) -> f64

Compute the norm of a cochain defined by this operator, i.e. its inner_product with itself.

The same caveat applies as to inner_product: this does not check that the operator is positive definite, so the operation may not actually be a norm.

Trait Implementations

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

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

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

Formats the value using the given formatter.

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<Input, Output> From<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>> for DiagonalOperator<Input, Output>

fn from(diagonal: DVector<f64>) -> Self

Converts to this type from the input type.

impl<'a, In, OutDim, const MESH_DIM: usize> Index<DualCellView<'a, OutDim, MESH_DIM>> for DiagonalOperator<In, CochainImpl<OutDim, Dual>>

where OutDim: DimName, Const<MESH_DIM>: DimNameSub<OutDim>,

type Output = f64

The returned type after indexing.

fn index(&self, index: DualCellView<'a, OutDim, MESH_DIM>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, In, OutDim, const MESH_DIM: usize> Index<SimplexView<'a, OutDim, MESH_DIM>> for DiagonalOperator<In, CochainImpl<OutDim, Primal>>

where OutDim: DimName, Const<MESH_DIM>: DimNameSub<OutDim>,

type Output = f64

The returned type after indexing.

fn index(&self, index: SimplexView<'a, OutDim, MESH_DIM>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, In, OutDim, const MESH_DIM: usize> IndexMut<DualCellView<'a, OutDim, MESH_DIM>> for DiagonalOperator<In, CochainImpl<OutDim, Dual>>

where OutDim: DimName, Const<MESH_DIM>: DimNameSub<OutDim>,

fn index_mut( &mut self, index: DualCellView<'a, OutDim, MESH_DIM>, ) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, In, OutDim, const MESH_DIM: usize> IndexMut<SimplexView<'a, OutDim, MESH_DIM>> for DiagonalOperator<In, CochainImpl<OutDim, Primal>>

where OutDim: DimName, Const<MESH_DIM>: DimNameSub<OutDim>,

fn index_mut( &mut self, index: SimplexView<'a, OutDim, MESH_DIM>, ) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<Out, D, P> Mul<&CochainImpl<D, P>> for &DiagonalOperator<CochainImpl<D, P>, Out>

where Out: Operand,

type Output = Out

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Out, D, P> Mul<&CochainImpl<D, P>> for DiagonalOperator<CochainImpl<D, P>, Out>

where Out: Operand,

type Output = Out

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Input, Output> Mul<DiagonalOperator<Input, Output>> for f64

type Output = DiagonalOperator<Input, Output>

The resulting type after applying the * operator.

fn mul(self, rhs: DiagonalOperator<Input, Output>) -> Self::Output

Performs the * operation.

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

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

type Output = DiagonalOperator<OtherIn, Out>

The resulting type after applying the * operator.

fn mul(self, rhs: DiagonalOperator<OtherIn, In>) -> 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<Input, Output> Neg for DiagonalOperator<Input, Output>

type Output = DiagonalOperator<Input, Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Input, Output> Operator for DiagonalOperator<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<Input, Output> PartialEq for DiagonalOperator<Input, Output>

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.