Struct Diag &nbsp; Copy item path

impl<'a, T> Diag<Mut<'a, T>>

pub fn from_mut(value: &'a mut T) -> Self

creates a diagonal matrix view over the given element

pub fn from_slice_mut(slice: &'a mut [T]) -> Self

creates a DiagMut from slice views over the diagonal data, the result has the same dimension as the length of the input slice

impl<'a, T, Dim: Shape, Stride: Stride> Diag<Mut<'a, T, Dim, Stride>>

pub const unsafe fn from_raw_parts_mut( ptr: *mut T, dim: Dim, stride: Stride, ) -> Self

creates a DiagMut from pointers to the diagonal data, dimension, and stride

§safety

this function has the same safety requirements as [MatMut::from_raw_parts_mut(ptr, dim, 1, stride, 0)]

pub fn column_vector(self) -> ColRef<'a, T, Dim, Stride>

returns the diagonal as a column vector view

pub fn column_vector_mut(self) -> ColMut<'a, T, Dim, Stride>

returns the diagonal as a mutable column vector view

pub fn as_ref(&self) -> DiagRef<'_, T, Dim, Stride>

returns a view over self

pub fn as_mut(&mut self) -> DiagMut<'_, T, Dim, Stride>

returns a view over self

pub fn fill(&mut self, value: T)
where T: Clone,

fills all the elements of self with value

pub fn canonical(self) -> DiagRef<'a, T::Canonical, Dim, Stride>
where T: Conjugate,

see DiagRef::canonical

pub fn as_shape_mut<D: Shape>(self, len: D) -> DiagMut<'a, T, D, Stride>

see DiagRef::as_shape

pub fn as_dyn_mut(self) -> DiagMut<'a, T, usize, Stride>

see DiagRef::as_dyn

pub fn as_dyn_stride_mut(self) -> DiagMut<'a, T, Dim>

see DiagRef::as_dyn_stride

pub fn conjugate_mut(self) -> DiagMut<'a, T::Conj, Dim, Stride>
where T: Conjugate,

see DiagRef::conjugate

pub fn canonical_mut(self) -> DiagMut<'a, T::Canonical, Dim, Stride>
where T: Conjugate,

see DiagRef::canonical

pub fn dim(&self) -> Dim

returns the dimension of self

pub fn copy_from<RhsT: Conjugate<Canonical = T>>( &mut self, rhs: impl AsDiagRef<T = RhsT, Dim = Dim>, )
where T: ComplexField,

copies other into self

impl<T, Dim: Shape> Diag<Own<T, Dim>>

pub fn column_vector(&self) -> ColRef<'_, T, Dim>

returns the diagonal as a column vector

pub fn column_vector_mut(&mut self) -> ColMut<'_, T, Dim>

returns the diagonal as a column vector

pub fn into_column_vector(self) -> Col<T, Dim>

returns the diagonal as a column vector

pub fn as_ref(&self) -> DiagRef<'_, T, Dim>

returns a view over self

pub fn as_mut(&mut self) -> DiagMut<'_, T, Dim>

returns a view over self

pub fn as_shape<D: Shape>(&self, len: D) -> DiagRef<'_, T, D>

see DiagRef::as_shape

pub fn as_dyn(&self) -> DiagRef<'_, T>

see DiagRef::as_dyn

pub fn as_dyn_mut(&mut self) -> DiagMut<'_, T>

see DiagMut::as_dyn_mut

pub fn conjugate(&self) -> DiagRef<'_, T::Conj, Dim>
where T: Conjugate,

see DiagRef::conjugate

pub fn canonical(&self) -> DiagRef<'_, T::Canonical, Dim>
where T: Conjugate,

see DiagRef::canonical

pub fn as_shape_mut<D: Shape>(&mut self, len: D) -> DiagMut<'_, T, D>

see DiagMut::as_shape_mut

pub fn conjugate_mut(&mut self) -> DiagMut<'_, T::Conj, Dim>
where T: Conjugate,

see DiagMut::conjugate_mut

pub fn canonical_mut(&mut self) -> DiagMut<'_, T::Canonical, Dim>
where T: Conjugate,

see DiagMut::canonical_mut

pub fn dim(&self) -> Dim

returns the dimension of self

pub fn zeros(dim: Dim) -> Self
where T: ComplexField,

returns a new diagonal with dimension dim, filled with zeros

pub fn ones(dim: Dim) -> Self
where T: ComplexField,

returns a new diagonal with dimension dim, filled with ones

pub fn full(dim: Dim, value: T) -> Self
where T: Clone,

returns a new diagonal with dimension dim, filled with value

pub fn copy_from<RhsT: Conjugate<Canonical = T>>( &mut self, rhs: impl AsDiagRef<T = RhsT, Dim = Dim>, )
where T: ComplexField,

copies other into self

impl<'a, T> Diag<Ref<'a, T>>

pub fn from_ref(value: &'a T) -> Self

creates a diagonal matrix view over the given element

pub fn from_slice(slice: &'a [T]) -> Self

creates a DiagRef from slice views over the diagonal data, the result has the same dimension as the length of the input slice

impl<'a, T, Dim: Shape, Stride: Stride> Diag<Ref<'a, T, Dim, Stride>>

pub const unsafe fn from_raw_parts( ptr: *const T, dim: Dim, stride: Stride, ) -> Self

creates a DiagRef from pointers to the diagonal data, dimension, and stride

§safety

this function has the same safety requirements as [MatRef::from_raw_parts(ptr, dim, 1, stride, 0)]

pub fn column_vector(self) -> ColRef<'a, T, Dim, Stride>

returns the diagonal as a column vector view.

pub fn as_ref(&self) -> DiagRef<'_, T, Dim, Stride>

returns a view over self

pub fn as_shape<D: Shape>(self, len: D) -> DiagRef<'a, T, D, Stride>

returns the input matrix with the given shape after checking that it matches the current shape

pub fn as_dyn(self) -> DiagRef<'a, T, usize, Stride>

returns the input matrix with dynamic shape

pub fn as_dyn_stride(self) -> DiagRef<'a, T, Dim>

returns the input matrix with dynamic stride

pub fn conjugate(self) -> DiagRef<'a, T::Conj, Dim, Stride>
where T: Conjugate,

returns a view over the conjugate of self

pub fn canonical(self) -> DiagRef<'a, T::Canonical, Dim, Stride>
where T: Conjugate,

returns an unconjugated view over self

pub fn dim(&self) -> Dim

returns the dimension of self

impl<T, Dim: Shape, Stride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Dim, Stride>>> Diag<Inner>

pub fn is_all_finite(&self) -> bool
where T: Conjugate,

returns true if all of the elements of self are finite. otherwise returns false.

pub fn has_nan(&self) -> bool
where T: Conjugate,

returns true if any of the elements of self is NaN. otherwise returns false.

impl<Inner> Diag<Inner>

pub fn from_inner_ref(inner: &Inner) -> &Self

wrap by reference

pub fn from_inner_mut(inner: &mut Inner) -> &mut Self

wrap by mutable reference

Trait Implementations§

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Add<&Diag<R>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the + operator.

fn add(self, rhs: &Diag<R>) -> Self::Output

Performs the + operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Add<&Diag<R>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the + operator.

fn add(self, rhs: &Diag<R>) -> Self::Output

Performs the + operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Add<Diag<R>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the + operator.

fn add(self, rhs: Diag<R>) -> Self::Output

Performs the + operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Add<Diag<R>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the + operator.

fn add(self, rhs: Diag<R>) -> Self::Output

Performs the + operation. Read more

impl<T: ComplexField, Dim: Shape, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> AddAssign<&Diag<R>> for Diag<L>

fn add_assign(&mut self, rhs: &Diag<R>)

Performs the += operation. Read more

impl<T: ComplexField, Dim: Shape, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> AddAssign<Diag<R>> for Diag<L>

fn add_assign(&mut self, rhs: Diag<R>)

Performs the += operation. Read more

impl<Inner: Clone> Clone for Diag<Inner>

fn clone(&self) -> Diag<Inner>

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

impl<Inner: Debug> Debug for Diag<Inner>

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

Formats the value using the given formatter. Read more

impl<Inner> Deref for Diag<Inner>

type Target = Inner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Inner> DerefMut for Diag<Inner>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<&Scale<T>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: &Scale<T>) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<&Scale<T>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: &Scale<T>) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<&f64> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<&f64> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<Scale<T>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<Scale<T>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<f64> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Div<f64> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<&Scale<T>> for Diag<L>

fn div_assign(&mut self, rhs: &Scale<T>)

Performs the /= operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<&f64> for Diag<L>

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<Scale<T>> for Diag<L>

fn div_assign(&mut self, rhs: Scale<T>)

Performs the /= operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<f64> for Diag<L>

fn div_assign(&mut self, rhs: f64)

Performs the /= operation. Read more

impl<T, Dim: Shape, Stride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Dim, Stride>>> Index<<Dim as ShapeIdx>::Idx<usize>> for Diag<Inner>

type Output = T

The returned type after indexing.

fn index(&self, idx: Idx<Dim>) -> &Self::Output

Performs the indexing (container[index]) operation. Read more

impl<T, Dim: Shape, Stride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Dim, Stride>> + for<'short> ReborrowMut<'short, Target = Mut<'short, T, Dim, Stride>>> IndexMut<<Dim as ShapeIdx>::Idx<usize>> for Diag<Inner>

fn index_mut(&mut self, idx: Idx<Dim>) -> &mut Self::Output

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

impl<Inner: IntoConst> IntoConst for Diag<Inner>

type Target = Diag<<Inner as IntoConst>::Target>

fn into_const(self) -> Self::Target

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<&Col<R>> for &Diag<L>

type Output = Col<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Col<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<&Col<R>> for Diag<L>

type Output = Col<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Col<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Dim, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &Mat<L>

type Output = Mat<Own<T, Rows, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &Scale<T>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &f64

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Dim, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for Mat<L>

type Output = Mat<Own<T, Rows, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for Scale<T>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for f64

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for &Diag<L>

type Output = Mat<Own<T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for Diag<L>

type Output = Mat<Own<T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<&Scale<T>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scale<T>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<&Scale<T>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scale<T>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for &Diag<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for Diag<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseRowMat<R>> for &Diag<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseRowMat<R>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseRowMat<R>> for Diag<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseRowMat<R>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<&f64> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<&f64> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<Col<R>> for &Diag<L>

type Output = Col<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<Col<R>> for Diag<L>

type Output = Col<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Dim, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &Mat<L>

type Output = Mat<Own<T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &Scale<T>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &f64

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Dim, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for Mat<L>

type Output = Mat<Own<T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for Scale<T>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for SparseColMat<L>

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for SparseRowMat<L>

type Output = SparseRowMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, RT: Conjugate<Canonical = T>, RStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for f64

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, Cols, RRStride, RCStride>>> Mul<Mat<R>> for &Diag<L>

type Output = Mat<Own<T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, Cols, RRStride, RCStride>>> Mul<Mat<R>> for Diag<L>

type Output = Mat<Own<T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<Scale<T>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<Scale<T>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for &Diag<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for Diag<L>

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseRowMat<R>> for &Diag<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseRowMat<R>> for Diag<L>

type Output = SparseRowMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<f64> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>> Mul<f64> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<&Scale<T>> for Diag<L>

fn mul_assign(&mut self, rhs: &Scale<T>)

Performs the *= operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<&f64> for Diag<L>

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<Scale<T>> for Diag<L>

fn mul_assign(&mut self, rhs: Scale<T>)

Performs the *= operation. Read more

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<f64> for Diag<L>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation. Read more

impl<T: Conjugate, Dim: Shape, Stride: Stride, Inner: for<'a> Reborrow<'a, Target = Ref<'a, T, Dim, Stride>>> Neg for &Diag<Inner>

type Output = Diag<Own<<T as Conjugate>::Canonical, Dim>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

impl<T: Conjugate, Dim: Shape, Stride: Stride, Inner: for<'a> Reborrow<'a, Target = Ref<'a, T, Dim, Stride>>> Neg for Diag<Inner>

type Output = Diag<Own<<T as Conjugate>::Canonical, Dim>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

impl<LT: PartialEq<RT>, LDim: Shape, LStride: Stride, RT, RDim: Shape, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, LDim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, RDim, RStride>>> PartialEq<Diag<R>> for Diag<L>

fn eq(&self, other: &Diag<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'short, Inner: Reborrow<'short>> Reborrow<'short> for Diag<Inner>

type Target = Diag<<Inner as Reborrow<'short>>::Target>

fn rb(&'short self) -> Self::Target

impl<'short, Inner: ReborrowMut<'short>> ReborrowMut<'short> for Diag<Inner>

type Target = Diag<<Inner as ReborrowMut<'short>>::Target>

fn rb_mut(&'short mut self) -> Self::Target

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Sub<&Diag<R>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the - operator.

fn sub(self, rhs: &Diag<R>) -> Self::Output

Performs the - operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Sub<&Diag<R>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the - operator.

fn sub(self, rhs: &Diag<R>) -> Self::Output

Performs the - operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Sub<Diag<R>> for &Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the - operator.

fn sub(self, rhs: Diag<R>) -> Self::Output

Performs the - operation. Read more

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Sub<Diag<R>> for Diag<L>

type Output = Diag<Own<T, Dim>>

The resulting type after applying the - operator.

fn sub(self, rhs: Diag<R>) -> Self::Output

Performs the - operation. Read more

impl<T: ComplexField, Dim: Shape, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> SubAssign<&Diag<R>> for Diag<L>

fn sub_assign(&mut self, rhs: &Diag<R>)

Performs the -= operation. Read more

impl<T: ComplexField, Dim: Shape, LStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> SubAssign<Diag<R>> for Diag<L>

fn sub_assign(&mut self, rhs: Diag<R>)

Performs the -= operation. Read more

impl<Inner: Copy> Copy for Diag<Inner>

Auto Trait Implementations§

impl<Inner> Freeze for Diag<Inner>
where Inner: Freeze,

impl<Inner> RefUnwindSafe for Diag<Inner>
where Inner: RefUnwindSafe,

impl<Inner> Send for Diag<Inner>
where Inner: Send,

impl<Inner> Sync for Diag<Inner>
where Inner: Sync,

impl<Inner> Unpin for Diag<Inner>
where Inner: Unpin,

impl<Inner> UnwindSafe for Diag<Inner>
where Inner: UnwindSafe,

Blanket Implementations§

impl<Rhs, Lhs, Output> AddByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Add<&'a Rhs, Output = Output>,

type Output = Output

fn add_by_ref(&self, rhs: &Rhs) -> <Lhs as AddByRef<Rhs>>::Output

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> ByRef<T> for T

fn by_ref(&self) -> &T

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> DistributionExt for T
where T: ?Sized,

fn rand<T>(&self, rng: &mut (impl ?Sized + Rng)) -> T
where Self: Distribution<T>,

impl<Rhs, Lhs, Output> DivByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Div<&'a Rhs, Output = Output>,

type Output = Output

fn div_by_ref(&self, rhs: &Rhs) -> <Lhs as DivByRef<Rhs>>::Output

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more