Struct DiagRef

pub struct DiagRef<'a, E>
where
    E: Entity,
{ /* private fields */ }

Diagonal matrix view.

Implementations

impl<'a, E> DiagRef<'a, E>

where E: Entity,

pub fn column_vector(self) -> ColRef<'a, E>

Returns the diagonal as a column vector view.

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

Returns a view over the matrix.

Trait Implementations

impl<E, LhsE, RhsE> Add<&Diag<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &Diag<RhsE>, ) -> <&DiagRef<'_, LhsE> as Add<&Diag<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&Diag<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &Diag<RhsE>, ) -> <DiagRef<'_, LhsE> as Add<&Diag<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Add<&DiagMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Add<&DiagMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagRef<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagRef<'_, RhsE>, ) -> <&Diag<LhsE> as Add<&DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagRef<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagRef<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Add<&DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Add<&DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagRef<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagRef<'_, RhsE>, ) -> <Diag<LhsE> as Add<&DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagRef<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Add<&DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: &DiagRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Add<&DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<Diag<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: Diag<RhsE>, ) -> <&DiagRef<'_, LhsE> as Add<Diag<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<Diag<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: Diag<RhsE>, ) -> <DiagRef<'_, LhsE> as Add<Diag<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Add<DiagMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Add<DiagMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagRef<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagRef<'_, RhsE>, ) -> <&Diag<LhsE> as Add<DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagRef<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagRef<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Add<DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Add<DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagRef<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagRef<'_, RhsE>, ) -> <Diag<LhsE> as Add<DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, other: DiagRef<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Add<DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the + operator.

fn add( self, rhs: DiagRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Add<DiagRef<'_, RhsE>>>::Output

Performs the + operation.

impl<LhsE, RhsE> AddAssign<&DiagRef<'_, RhsE>> for Diag<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn add_assign(&mut self, other: &DiagRef<'_, RhsE>)

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn add_assign(&mut self, other: &DiagRef<'_, RhsE>)

Performs the += operation.

impl<LhsE, RhsE> AddAssign<DiagRef<'_, RhsE>> for Diag<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn add_assign(&mut self, other: DiagRef<'_, RhsE>)

Performs the += operation.

impl<LhsE, RhsE> AddAssign<DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn add_assign(&mut self, rhs: DiagRef<'_, RhsE>)

Performs the += operation.

impl<E> Clone for DiagRef<'_, E>

where E: Entity,

fn clone(&self) -> DiagRef<'_, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, E> Debug for DiagRef<'a, E>

where E: Debug + Entity,

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

Formats the value using the given formatter.

impl<E, LhsE, RhsE> Div<Scale<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the / operator.

fn div( self, other: Scale<RhsE>, ) -> <&DiagRef<'_, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation.

impl<E, LhsE, RhsE> Div<Scale<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the / operator.

fn div( self, other: Scale<RhsE>, ) -> <DiagRef<'_, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation.

impl<E, RhsE> Div<f32> for &DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the / operator.

fn div(self, other: f32) -> <&DiagRef<'_, RhsE> as Div<f32>>::Output

Performs the / operation.

impl<E, RhsE> Div<f32> for DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the / operator.

fn div(self, other: f32) -> <DiagRef<'_, RhsE> as Div<f32>>::Output

Performs the / operation.

impl<E, RhsE> Div<f64> for &DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the / operator.

fn div(self, other: f64) -> <&DiagRef<'_, RhsE> as Div<f64>>::Output

Performs the / operation.

impl<E, RhsE> Div<f64> for DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the / operator.

fn div(self, other: f64) -> <DiagRef<'_, RhsE> as Div<f64>>::Output

Performs the / operation.

impl<E> IntoConst for DiagRef<'_, E>

where E: Entity,

type Target = DiagRef<'_, E>

fn into_const(self) -> <DiagRef<'_, E> as IntoConst>::Target

impl<E, LhsE, RhsE> Mul<&Col<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &Col<RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&Col<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Col<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &Col<RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&Col<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Diag<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &Diag<RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&Diag<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Diag<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &Diag<RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&Diag<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&DiagMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&DiagMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&Diag<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&Mat<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&MatMut<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&MatRef<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&Row<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <Diag<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <Mat<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <MatMut<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <MatRef<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <Row<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for Scale<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: &DiagRef<'_, RhsE>, ) -> <Scale<LhsE> as Mul<&DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &Mat<RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &Mat<RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &MatMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&MatMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &MatMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&MatMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&MatRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &MatRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&MatRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&MatRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &MatRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&MatRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Col<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: Col<RhsE>) -> <&DiagRef<'_, LhsE> as Mul<Col<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Col<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: Col<RhsE>) -> <DiagRef<'_, LhsE> as Mul<Col<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, rhs: ColRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Diag<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: Diag<RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<Diag<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Diag<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: Diag<RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<Diag<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<DiagMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<DiagMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&Diag<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&Mat<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&MatMut<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&MatRef<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&Row<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <Diag<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, rhs: DiagRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <Mat<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <MatMut<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, rhs: DiagRef<'_, RhsE>, ) -> <MatRef<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <Row<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, other: DiagRef<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul( self, rhs: DiagRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for Scale<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, rhs: DiagRef<'_, RhsE>, ) -> <Scale<LhsE> as Mul<DiagRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: Mat<RhsE>) -> <&DiagRef<'_, LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: Mat<RhsE>) -> <DiagRef<'_, LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: MatMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<MatMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: MatMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<MatMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<MatRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: MatRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<MatRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<MatRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, rhs: MatRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<MatRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, other: Scale<RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<Scale<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul( self, rhs: Scale<RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<Scale<RhsE>>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f32> for &DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> <&DiagRef<'_, RhsE> as Mul<f32>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f32> for DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> <DiagRef<'_, RhsE> as Mul<f32>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f64> for &DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> <&DiagRef<'_, RhsE> as Mul<f64>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f64> for DiagRef<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> <DiagRef<'_, RhsE> as Mul<f64>>::Output

Performs the * operation.

impl<E> Neg for &DiagRef<'_, E>

where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Diag<<E as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn neg(self) -> <&DiagRef<'_, E> as Neg>::Output

Performs the unary - operation.

impl<E> Neg for DiagRef<'_, E>

where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Diag<<E as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn neg(self) -> <DiagRef<'_, E> as Neg>::Output

Performs the unary - operation.

impl<LhsE, RhsE> PartialEq<Diag<RhsE>> for DiagRef<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

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

impl<LhsE, RhsE> PartialEq<DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &DiagMut<'_, RhsE>) -> 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.

impl<LhsE, RhsE> PartialEq<DiagRef<'_, RhsE>> for Diag<LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &DiagRef<'_, RhsE>) -> 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.

impl<LhsE, RhsE> PartialEq<DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &DiagRef<'_, RhsE>) -> 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.

impl<LhsE, RhsE> PartialEq<DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &DiagRef<'_, RhsE>) -> 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.

impl<'short, E> Reborrow<'short> for DiagRef<'_, E>

where E: Entity,

type Target = DiagRef<'short, E>

fn rb(&'short self) -> <DiagRef<'_, E> as Reborrow<'short>>::Target

impl<'short, E> ReborrowMut<'short> for DiagRef<'_, E>

where E: Entity,

type Target = DiagRef<'short, E>

fn rb_mut(&'short mut self) -> <DiagRef<'_, E> as ReborrowMut<'short>>::Target

impl<E, LhsE, RhsE> Sub<&Diag<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &Diag<RhsE>, ) -> <&DiagRef<'_, LhsE> as Sub<&Diag<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&Diag<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &Diag<RhsE>, ) -> <DiagRef<'_, LhsE> as Sub<&Diag<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Sub<&DiagMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Sub<&DiagMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagRef<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagRef<'_, RhsE>, ) -> <&Diag<LhsE> as Sub<&DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagRef<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagRef<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Sub<&DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Sub<&DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagRef<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagRef<'_, RhsE>, ) -> <Diag<LhsE> as Sub<&DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagRef<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Sub<&DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: &DiagRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Sub<&DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Diag<RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: Diag<RhsE>, ) -> <&DiagRef<'_, LhsE> as Sub<Diag<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Diag<RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: Diag<RhsE>, ) -> <DiagRef<'_, LhsE> as Sub<Diag<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Sub<DiagMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Sub<DiagMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagRef<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagRef<'_, RhsE>, ) -> <&Diag<LhsE> as Sub<DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagRef<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagRef<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Sub<DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagRef<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagRef<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Sub<DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagRef<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagRef<'_, RhsE>, ) -> <Diag<LhsE> as Sub<DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, other: DiagRef<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Sub<DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<DiagRef<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Diag<E>

The resulting type after applying the - operator.

fn sub( self, rhs: DiagRef<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Sub<DiagRef<'_, RhsE>>>::Output

Performs the - operation.

impl<LhsE, RhsE> SubAssign<&DiagRef<'_, RhsE>> for Diag<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn sub_assign(&mut self, other: &DiagRef<'_, RhsE>)

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn sub_assign(&mut self, other: &DiagRef<'_, RhsE>)

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<DiagRef<'_, RhsE>> for Diag<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn sub_assign(&mut self, other: DiagRef<'_, RhsE>)

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<DiagRef<'_, RhsE>> for DiagMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

fn sub_assign(&mut self, rhs: DiagRef<'_, RhsE>)

Performs the -= operation.

impl<E> Copy for DiagRef<'_, E>

where E: Entity,