Trait LinearOperator

pub trait LinearOperator {
    type Elem: Scalar;

    // Provided methods
    fn apply<S>(&self, a: &ArrayBase<S, Ix1>) -> Array1<S::Elem>
       where S: Data<Elem = Self::Elem> { ... }
    fn apply_mut<S>(&self, a: &mut ArrayBase<S, Ix1>)
       where S: DataMut<Elem = Self::Elem> { ... }
    fn apply_into<S>(&self, a: ArrayBase<S, Ix1>) -> ArrayBase<S, Ix1>
       where S: DataOwned<Elem = Self::Elem> + DataMut { ... }
    fn apply2<S>(&self, a: &ArrayBase<S, Ix2>) -> Array2<S::Elem>
       where S: Data<Elem = Self::Elem> { ... }
    fn apply2_mut<S>(&self, a: &mut ArrayBase<S, Ix2>)
       where S: DataMut<Elem = Self::Elem> { ... }
    fn apply2_into<S>(&self, a: ArrayBase<S, Ix2>) -> ArrayBase<S, Ix2>
       where S: DataOwned<Elem = Self::Elem> + DataMut { ... }
}

Abstracted linear operator as an action to vector (ArrayBase<S, Ix1>) and matrix (ArrayBase<S, Ix2)

Required Associated Types

type Elem: Scalar

Provided Methods

fn apply<S>(&self, a: &ArrayBase<S, Ix1>) -> Array1<S::Elem>

where S: Data<Elem = Self::Elem>,

Apply operator out-place

fn apply_mut<S>(&self, a: &mut ArrayBase<S, Ix1>)

where S: DataMut<Elem = Self::Elem>,

Apply operator in-place

fn apply_into<S>(&self, a: ArrayBase<S, Ix1>) -> ArrayBase<S, Ix1>

where S: DataOwned<Elem = Self::Elem> + DataMut,

Apply operator with move

fn apply2<S>(&self, a: &ArrayBase<S, Ix2>) -> Array2<S::Elem>

where S: Data<Elem = Self::Elem>,

Apply operator to matrix out-place

fn apply2_mut<S>(&self, a: &mut ArrayBase<S, Ix2>)

where S: DataMut<Elem = Self::Elem>,

Apply operator to matrix in-place

fn apply2_into<S>(&self, a: ArrayBase<S, Ix2>) -> ArrayBase<S, Ix2>

where S: DataOwned<Elem = Self::Elem> + DataMut,

Apply operator to matrix with move

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<A, Sa> LinearOperator for ArrayBase<Sa, Ix2>

where A: Scalar, Sa: Data<Elem = A>,

type Elem = A

fn apply<S>(&self, a: &ArrayBase<S, Ix1>) -> Array1<A>

where S: Data<Elem = A>,

Implementors

impl<A, Sa> LinearOperator for Diagonal<Sa>

where A: Scalar, Sa: Data<Elem = A>,

type Elem = A