Struct extendr_api::prelude::row::RowRef

#[repr(C)]
pub struct RowRef<'a, E>
where
    E: Entity,
{
    pub(super) inner: VecImpl<E>,
    pub(super) __marker: PhantomData<&'a E>,
}
Expand description

Immutable view over a row vector, similar to an immutable reference to a strided slice.

§Note

Unlike a slice, the data pointed to by RowRef<'_, E> is allowed to be partially or fully uninitialized under certain conditions. In this case, care must be taken to not perform any operations that read the uninitialized values, or form references to them, either directly through RowRef::read, or indirectly through any of the numerical library routines, unless it is explicitly permitted.

Fields§

§inner: VecImpl<E>§__marker: PhantomData<&'a E>

Implementations§

§

impl<'a, E> RowRef<'a, E>
where E: Entity,

pub fn nrows(&self) -> usize

Returns the number of rows of the row. This is always equal to 1.

pub fn ncols(&self) -> usize

Returns the number of columns of the row.

pub fn as_ptr( self, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns pointers to the matrix data.

pub fn col_stride(&self) -> isize

Returns the column stride of the matrix, specified in number of elements, not in bytes.

pub fn as_2d(self) -> MatRef<'a, E>

Returns self as a matrix view.

pub fn ptr_at( self, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns raw pointers to the element at the given index.

pub unsafe fn ptr_inbounds_at( self, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns raw pointers to the element at the given index, assuming the provided index is within the size of the vector.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • col < self.ncols().

pub unsafe fn split_at_unchecked( self, col: usize, ) -> (RowRef<'a, E>, RowRef<'a, E>)

Splits the column vector at the given index into two parts and returns an array of each subvector, in the following order:

  • left.
  • right.
§Safety

The behavior is undefined if any of the following conditions are violated:

  • col <= self.ncols().

pub fn split_at(self, col: usize) -> (RowRef<'a, E>, RowRef<'a, E>)

Splits the column vector at the given index into two parts and returns an array of each subvector, in the following order:

  • top.
  • bottom.
§Panics

The function panics if any of the following conditions are violated:

  • col <= self.ncols().

pub unsafe fn get_unchecked<ColRange>( self, col: ColRange, ) -> <RowRef<'a, E> as RowIndex<ColRange>>::Target
where RowRef<'a, E>: RowIndex<ColRange>,

Returns references to the element at the given index, or subvector if row is a range.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • col must be contained in [0, self.ncols()).

pub fn get<ColRange>( self, col: ColRange, ) -> <RowRef<'a, E> as RowIndex<ColRange>>::Target
where RowRef<'a, E>: RowIndex<ColRange>,

Returns references to the element at the given index, or subvector if col is a range, with bound checks.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

§Panics

The function panics if any of the following conditions are violated:

  • col must be contained in [0, self.ncols()).

pub unsafe fn read_unchecked(&self, col: usize) -> E

Reads the value of the element at the given index.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • col < self.ncols().

pub fn read(&self, col: usize) -> E

Reads the value of the element at the given index, with bound checks.

§Panics

The function panics if any of the following conditions are violated:

  • col < self.ncols().

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

Returns a view over the transpose of self.

pub fn conjugate(self) -> RowRef<'a, <E as Conjugate>::Conj>
where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(self) -> ColRef<'a, <E as Conjugate>::Conj>
where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize(self) -> (RowRef<'a, <E as Conjugate>::Canonical>, Conj)
where E: Conjugate,

Returns a view over the canonical representation of self, as well as a flag declaring whether self is implicitly conjugated or not.

pub fn reverse_cols(self) -> RowRef<'a, E>

Returns a view over the self, with the columns in reversed order.

pub unsafe fn subcols_unchecked( self, col_start: usize, ncols: usize, ) -> RowRef<'a, E>

Returns a view over the subvector starting at column col_start, and with number of columns ncols.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • col_start <= self.ncols().
  • ncols <= self.ncols() - col_start.

pub fn subcols(self, col_start: usize, ncols: usize) -> RowRef<'a, E>

Returns a view over the subvector starting at col col_start, and with number of cols ncols.

§Panics

The function panics if any of the following conditions are violated:

  • col_start <= self.ncols().
  • ncols <= self.ncols() - col_start.

pub fn to_owned(&self) -> Row<<E as Conjugate>::Canonical>
where E: Conjugate,

Returns an owning Row of the data.

pub fn has_nan(&self) -> bool
where E: ComplexField,

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

pub fn is_all_finite(&self) -> bool
where E: ComplexField,

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

pub fn norm_max(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l1(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the L1 norm of self.

pub fn norm_l2(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the L2 norm of self.

pub fn squared_norm_l2(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the squared L2 norm of self.

pub fn sum(&self) -> E
where E: ComplexField,

Returns the sum of self.

pub fn kron(&self, rhs: impl As2D<E>) -> Mat<E>
where E: ComplexField,

Kronecker product of self and rhs.

This is an allocating operation; see faer::linalg::kron for the allocation-free version or more info in general.

pub fn try_as_slice( self, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>>

Returns the row as a contiguous slice if its column stride is equal to 1.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

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

Returns a view over the matrix.

pub fn split_first( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, RowRef<'a, E>)>

Returns a reference to the first element and a view over the remaining ones if the row is non-empty, otherwise None.

pub fn split_last( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, RowRef<'a, E>)>

Returns a reference to the last element and a view over the remaining ones if the row is non-empty, otherwise None.

pub fn iter(self) -> ElemIter<'a, E>

Returns an iterator over the elements of the row.

pub fn chunks(self, chunk_size: usize) -> RowElemChunks<'a, E>

Returns an iterator that provides successive chunks of the elements of this row, with each having at most chunk_size elements.

pub fn partition(self, count: usize) -> RowElemPartition<'a, E>

Returns an iterator that provides exactly count successive chunks of the elements of this row.

pub fn par_chunks(self, chunk_size: usize) -> impl IndexedParallelIterator + 'a

Returns an iterator that provides successive chunks of the elements of this row, with each having at most chunk_size elements.

Only available with the rayon feature.

pub fn par_partition(self, count: usize) -> impl IndexedParallelIterator + 'a

Returns an iterator that provides exactly count successive chunks of the elements of this row.

Only available with the rayon feature.

Trait Implementations§

§

impl<E, LhsE, RhsE> Add<&Row<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 add( self, other: &Row<RhsE>, ) -> <&RowRef<'_, LhsE> as Add<&Row<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&Row<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 add(self, other: &Row<RhsE>) -> <RowRef<'_, LhsE> as Add<&Row<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowMut<'_, 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 add( self, other: &RowMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Add<&RowMut<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowMut<'_, 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 add( self, other: &RowMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Add<&RowMut<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowRef<'_, 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 add( self, other: &RowRef<'_, RhsE>, ) -> <&Row<LhsE> as Add<&RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowRef<'_, 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 add( self, other: &RowRef<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Add<&RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowRef<'_, 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 add( self, other: &RowRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Add<&RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowRef<'_, 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 add( self, other: &RowRef<'_, RhsE>, ) -> <Row<LhsE> as Add<&RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowRef<'_, 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 add( self, other: &RowRef<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Add<&RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&RowRef<'_, 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 add( self, other: &RowRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Add<&RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Row<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 add(self, other: Row<RhsE>) -> <&RowRef<'_, LhsE> as Add<Row<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Row<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 add(self, other: Row<RhsE>) -> <RowRef<'_, LhsE> as Add<Row<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowMut<'_, 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 add( self, other: RowMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Add<RowMut<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowMut<'_, 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 add( self, other: RowMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Add<RowMut<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowRef<'_, 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 add( self, other: RowRef<'_, RhsE>, ) -> <&Row<LhsE> as Add<RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowRef<'_, 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 add( self, other: RowRef<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Add<RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowRef<'_, 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 add( self, other: RowRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Add<RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowRef<'_, 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 add( self, other: RowRef<'_, RhsE>, ) -> <Row<LhsE> as Add<RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowRef<'_, 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 add( self, other: RowRef<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Add<RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<RowRef<'_, 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 add( self, rhs: RowRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Add<RowRef<'_, RhsE>>>::Output

Performs the + operation. Read more
§

impl<LhsE, RhsE> AddAssign<&RowRef<'_, RhsE>> for Row<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<&RowRef<'_, RhsE>> for RowMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<RowRef<'_, RhsE>> for Row<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<RowRef<'_, RhsE>> for RowMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<E> As2D<E> for RowRef<'_, E>
where E: Entity,

§

fn as_2d_ref(&self) -> MatRef<'_, E>

Convert to a 2D matrix view.
§

impl<E> AsRowRef<E> for RowRef<'_, E>
where E: Entity,

§

fn as_row_ref(&self) -> RowRef<'_, E>

Convert to a row view.
§

impl<E> Clone for RowRef<'_, E>
where E: Entity,

§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
§

impl<'a, FromE, ToE> Coerce<RowRef<'a, ToE>> for RowRef<'a, FromE>
where FromE: Entity, ToE: Entity,

§

fn coerce(self) -> RowRef<'a, ToE>

§

impl<'a, E> Debug for RowRef<'a, E>
where E: Entity,

§

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

Formats the value using the given formatter. Read more
§

impl<E> Default for RowRef<'_, E>
where E: Entity,

§

fn default() -> RowRef<'_, E>

Returns the “default value” for a type. Read more
§

impl<E, LhsE, RhsE> Div<Scale<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 div( self, other: Scale<RhsE>, ) -> <&RowRef<'_, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation. Read more
§

impl<E, LhsE, RhsE> Div<Scale<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 div( self, other: Scale<RhsE>, ) -> <RowRef<'_, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation. Read more
§

impl<E, RhsE> Div<f32> for &RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the / operator.
§

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

Performs the / operation. Read more
§

impl<E, RhsE> Div<f32> for RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the / operator.
§

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

Performs the / operation. Read more
§

impl<E, RhsE> Div<f64> for &RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the / operator.
§

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

Performs the / operation. Read more
§

impl<E, RhsE> Div<f64> for RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the / operator.
§

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

Performs the / operation. Read more
§

impl<E> Index<usize> for RowRef<'_, E>
where E: SimpleEntity,

§

type Output = E

The returned type after indexing.
§

fn index(&self, col: usize) -> &E

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

impl<E> IntoConst for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

§

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

§

impl<'a, E> MatIndex<'a> for RowRef<'_, E>
where E: Entity,

§

type Item = Read<'a, E>

Item produced by the zipped views.
§

unsafe fn get_unchecked( &'a mut self, _: <RowRef<'_, E> as MaybeContiguous>::Index, ) -> <RowRef<'_, E> as MatIndex<'a>>::Item

Get the item at the given index, skipping bound checks.
§

unsafe fn get_from_slice_unchecked( slice: &'a mut <RowRef<'_, E> as MaybeContiguous>::Slice, idx: usize, ) -> <RowRef<'_, E> as MatIndex<'a>>::Item

Get the item at the given slice position, skipping bound checks.
§

fn is_contiguous(&self) -> bool

Checks if the zipped matrices are contiguous.
§

fn preferred_layout( &self, ) -> <RowRef<'_, E> as MaybeContiguous>::LayoutTransform

Computes the preferred iteration layout of the matrices.
§

fn with_layout( self, layout: <RowRef<'_, E> as MaybeContiguous>::LayoutTransform, ) -> RowRef<'_, E>

Applies the layout transformation to the matrices.
§

impl<E> MatShape for RowRef<'_, E>
where E: Entity,

§

type Rows = ()

Type of rows.
§

type Cols = usize

Type of columns.
§

fn nrows(&self) -> <RowRef<'_, E> as MatShape>::Rows

Returns the number of rows.
§

fn ncols(&self) -> <RowRef<'_, E> as MatShape>::Cols

Returns the number of columns.
§

impl<E> MaybeContiguous for RowRef<'_, E>
where E: Entity,

§

type Index = ((), usize)

Indexing type.
§

type Slice = <<E as Entity>::Group as ForType>::FaerOf<&'static [MaybeUninit<<E as Entity>::Unit>]>

Contiguous slice type.
§

type LayoutTransform = VecLayoutTransform

Layout transformation type.
§

unsafe fn get_slice_unchecked( &mut self, _: <RowRef<'_, E> as MaybeContiguous>::Index, n_elems: usize, ) -> <RowRef<'_, E> as MaybeContiguous>::Slice

Returns slice at index of length n_elems.
§

impl<E, LhsE, RhsE> Mul<&Col<RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Col<RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColRef<'_, RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColRef<'_, RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Diag<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: &Diag<RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Diag<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: &Diag<RhsE>, ) -> <RowRef<'_, LhsE> as Mul<&Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&DiagMut<'_, 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: &DiagMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&DiagMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&DiagMut<'_, 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: &DiagMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<&DiagMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

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. Read more
§

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. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<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: &Mat<RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<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: &Mat<RhsE>) -> <RowRef<'_, LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatMut<'_, 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: &MatMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&MatMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatMut<'_, 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: &MatMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<&MatMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatRef<'_, 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: &MatRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&MatRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatRef<'_, 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: &MatRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<&MatRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&Perm<I>> for &RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul(self, other: &Perm<I>) -> <&RowRef<'_, E> as Mul<&Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&Perm<I>> for RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul(self, other: &Perm<I>) -> <RowRef<'_, E> as Mul<&Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&PermRef<'_, I>> for &RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul( self, other: &PermRef<'_, I>, ) -> <&RowRef<'_, E> as Mul<&PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&PermRef<'_, I>> for RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul( self, other: &PermRef<'_, I>, ) -> <RowRef<'_, E> as Mul<&PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for &Col<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: &RowRef<'_, RhsE>, ) -> <&Col<LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for &ColMut<'_, 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: &RowRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for &ColRef<'_, 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: &RowRef<'_, RhsE>, ) -> <&ColRef<'_, LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for Col<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: &RowRef<'_, RhsE>, ) -> <Col<LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for ColMut<'_, 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: &RowRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for ColRef<'_, 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: &RowRef<'_, RhsE>, ) -> <ColRef<'_, LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for Scale<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: &RowRef<'_, RhsE>, ) -> <Scale<LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMatMut<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMatMut<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Col<RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Col<RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColRef<'_, RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColRef<'_, RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = E

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Diag<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: Diag<RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Diag<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: Diag<RhsE>) -> <RowRef<'_, LhsE> as Mul<Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<DiagMut<'_, 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: DiagMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<DiagMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<DiagMut<'_, 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: DiagMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<DiagMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

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. Read more
§

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. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<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: Mat<RhsE>) -> <&RowRef<'_, LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<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: Mat<RhsE>) -> <RowRef<'_, LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatMut<'_, 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: MatMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<MatMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatMut<'_, 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: MatMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<MatMut<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatRef<'_, 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: MatRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<MatRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatRef<'_, 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: MatRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<MatRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<Perm<I>> for &RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul(self, other: Perm<I>) -> <&RowRef<'_, E> as Mul<Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<Perm<I>> for RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul(self, other: Perm<I>) -> <RowRef<'_, E> as Mul<Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<PermRef<'_, I>> for &RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul( self, other: PermRef<'_, I>, ) -> <&RowRef<'_, E> as Mul<PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<PermRef<'_, I>> for RowRef<'_, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the * operator.
§

fn mul( self, rhs: PermRef<'_, I>, ) -> <RowRef<'_, E> as Mul<PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for &Col<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: RowRef<'_, RhsE>, ) -> <&Col<LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for &ColMut<'_, 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: RowRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for &ColRef<'_, 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: RowRef<'_, RhsE>, ) -> <&ColRef<'_, LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for Col<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: RowRef<'_, RhsE>, ) -> <Col<LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for ColMut<'_, 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: RowRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for ColRef<'_, 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: RowRef<'_, RhsE>, ) -> <ColRef<'_, LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for Scale<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: RowRef<'_, RhsE>, ) -> <Scale<LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Scale<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: Scale<RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<Scale<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Scale<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: Scale<RhsE>) -> <RowRef<'_, LhsE> as Mul<Scale<RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, 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: SparseColMatRef<'_, I, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<SparseColMatRef<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMatMut<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMatMut<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, I, RhsE>> for &RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, 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: SparseRowMatRef<'_, I, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<SparseRowMatRef<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, RhsE> Mul<f32> for &RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, RhsE> Mul<f32> for RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, RhsE> Mul<f64> for &RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, RhsE> Mul<f64> for RowRef<'_, RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E> Neg for &RowRef<'_, E>
where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the - operator.
§

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

Performs the unary - operation. Read more
§

impl<E> Neg for RowRef<'_, E>
where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

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

The resulting type after applying the - operator.
§

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

Performs the unary - operation. Read more
§

impl<LhsE, RhsE> PartialEq<Row<RhsE>> for RowRef<'_, LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

fn eq(&self, other: &Row<RhsE>) -> 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<LhsE, RhsE> PartialEq<RowMut<'_, RhsE>> for RowRef<'_, LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

fn eq(&self, other: &RowMut<'_, RhsE>) -> 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<LhsE, RhsE> PartialEq<RowRef<'_, RhsE>> for Row<LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

fn eq(&self, other: &RowRef<'_, RhsE>) -> 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<LhsE, RhsE> PartialEq<RowRef<'_, RhsE>> for RowMut<'_, LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

fn eq(&self, other: &RowRef<'_, RhsE>) -> 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<LhsE, RhsE> PartialEq<RowRef<'_, RhsE>> for RowRef<'_, LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

fn eq(&self, other: &RowRef<'_, RhsE>) -> 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, E> Reborrow<'short> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'short, E>

§

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

§

impl<'short, E> ReborrowMut<'short> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'short, E>

§

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

§

impl<E> RowBatch<E> for RowRef<'_, E>
where E: Conjugate,

§

type Owned = Row<<E as Conjugate>::Canonical>

Corresponding owning type.
§

fn new_owned_zeros( nrows: usize, ncols: usize, ) -> <RowRef<'_, E> as RowBatch<E>>::Owned

Constructor of the owned type that initializes the values to zero.
§

fn new_owned_copied( src: &RowRef<'_, E>, ) -> <RowRef<'_, E> as RowBatch<E>>::Owned

Constructor of the owned type that copies the values.
§

fn resize_owned( owned: &mut <RowRef<'_, E> as RowBatch<E>>::Owned, nrows: usize, ncols: usize, )

Resize an owned column or matrix.
§

impl<E> RowIndex<Range<usize>> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

Resulting type of the indexing operation.
§

fn get(this: RowRef<'_, E>, col: Range<usize>) -> RowRef<'_, E>

Index the row at col.
§

unsafe fn get_unchecked(this: Self, col: ColRange) -> Self::Target

Index the row at col, without bound checks.
§

impl<E> RowIndex<RangeFrom<usize>> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

Resulting type of the indexing operation.
§

fn get(this: RowRef<'_, E>, col: RangeFrom<usize>) -> RowRef<'_, E>

Index the row at col.
§

unsafe fn get_unchecked(this: Self, col: ColRange) -> Self::Target

Index the row at col, without bound checks.
§

impl<E> RowIndex<RangeFull> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

Resulting type of the indexing operation.
§

fn get(this: RowRef<'_, E>, col: RangeFull) -> RowRef<'_, E>

Index the row at col.
§

unsafe fn get_unchecked(this: Self, col: ColRange) -> Self::Target

Index the row at col, without bound checks.
§

impl<E> RowIndex<RangeInclusive<usize>> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

Resulting type of the indexing operation.
§

fn get(this: RowRef<'_, E>, col: RangeInclusive<usize>) -> RowRef<'_, E>

Index the row at col.
§

unsafe fn get_unchecked(this: Self, col: ColRange) -> Self::Target

Index the row at col, without bound checks.
§

impl<E> RowIndex<RangeTo<usize>> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

Resulting type of the indexing operation.
§

fn get(this: RowRef<'_, E>, col: RangeTo<usize>) -> RowRef<'_, E>

Index the row at col.
§

unsafe fn get_unchecked(this: Self, col: ColRange) -> Self::Target

Index the row at col, without bound checks.
§

impl<E> RowIndex<RangeToInclusive<usize>> for RowRef<'_, E>
where E: Entity,

§

type Target = RowRef<'_, E>

Resulting type of the indexing operation.
§

fn get(this: RowRef<'_, E>, col: RangeToInclusive<usize>) -> RowRef<'_, E>

Index the row at col.
§

unsafe fn get_unchecked(this: Self, col: ColRange) -> Self::Target

Index the row at col, without bound checks.
§

impl<'a, E> RowIndex<usize> for RowRef<'a, E>
where E: Entity,

§

type Target = <<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>

Resulting type of the indexing operation.
§

unsafe fn get_unchecked( this: RowRef<'a, E>, col: usize, ) -> <RowRef<'a, E> as RowIndex<usize>>::Target

Index the row at col, without bound checks.
§

fn get( this: RowRef<'a, E>, col: usize, ) -> <RowRef<'a, E> as RowIndex<usize>>::Target

Index the row at col.
§

impl<E, LhsE, RhsE> Sub<&Row<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 sub( self, other: &Row<RhsE>, ) -> <&RowRef<'_, LhsE> as Sub<&Row<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&Row<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 sub(self, other: &Row<RhsE>) -> <RowRef<'_, LhsE> as Sub<&Row<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowMut<'_, 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 sub( self, other: &RowMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Sub<&RowMut<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowMut<'_, 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 sub( self, other: &RowMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Sub<&RowMut<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowRef<'_, 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 sub( self, other: &RowRef<'_, RhsE>, ) -> <&Row<LhsE> as Sub<&RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowRef<'_, 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 sub( self, other: &RowRef<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Sub<&RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowRef<'_, 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 sub( self, other: &RowRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Sub<&RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowRef<'_, 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 sub( self, other: &RowRef<'_, RhsE>, ) -> <Row<LhsE> as Sub<&RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowRef<'_, 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 sub( self, other: &RowRef<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Sub<&RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&RowRef<'_, 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 sub( self, other: &RowRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Sub<&RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Row<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 sub(self, other: Row<RhsE>) -> <&RowRef<'_, LhsE> as Sub<Row<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Row<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 sub(self, other: Row<RhsE>) -> <RowRef<'_, LhsE> as Sub<Row<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowMut<'_, 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 sub( self, other: RowMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Sub<RowMut<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowMut<'_, 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 sub( self, other: RowMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Sub<RowMut<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowRef<'_, 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 sub( self, other: RowRef<'_, RhsE>, ) -> <&Row<LhsE> as Sub<RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowRef<'_, 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 sub( self, other: RowRef<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Sub<RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowRef<'_, 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 sub( self, other: RowRef<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Sub<RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowRef<'_, 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 sub( self, other: RowRef<'_, RhsE>, ) -> <Row<LhsE> as Sub<RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowRef<'_, 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 sub( self, other: RowRef<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Sub<RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<RowRef<'_, 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 sub( self, rhs: RowRef<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Sub<RowRef<'_, RhsE>>>::Output

Performs the - operation. Read more
§

impl<LhsE, RhsE> SubAssign<&RowRef<'_, RhsE>> for Row<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<&RowRef<'_, RhsE>> for RowMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<RowRef<'_, RhsE>> for Row<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<RowRef<'_, RhsE>> for RowMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<E> ViewMut for &RowRef<'_, E>
where E: Entity,

§

type Target<'a> = RowRef<'a, E> where &RowRef<'_, E>: 'a

View type.
§

fn view_mut(&mut self) -> <&RowRef<'_, E> as ViewMut>::Target<'_>

Returns the view over self.
§

impl<E> ViewMut for &mut RowRef<'_, E>
where E: Entity,

§

type Target<'a> = RowRef<'a, E> where &mut RowRef<'_, E>: 'a

View type.
§

fn view_mut(&mut self) -> <&mut RowRef<'_, E> as ViewMut>::Target<'_>

Returns the view over self.
§

impl<E> ViewMut for RowRef<'_, E>
where E: Entity,

§

type Target<'a> = RowRef<'a, E> where RowRef<'_, E>: 'a

View type.
§

fn view_mut(&mut self) -> <RowRef<'_, E> as ViewMut>::Target<'_>

Returns the view over self.
§

impl<E> Copy for RowRef<'_, E>
where E: Entity,

Auto Trait Implementations§

§

impl<'a, E> Freeze for RowRef<'a, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: Freeze,

§

impl<'a, E> RefUnwindSafe for RowRef<'a, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: RefUnwindSafe, E: RefUnwindSafe,

§

impl<'a, E> Send for RowRef<'a, E>

§

impl<'a, E> Sync for RowRef<'a, E>

§

impl<'a, E> Unpin for RowRef<'a, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: Unpin,

§

impl<'a, E> UnwindSafe for RowRef<'a, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: UnwindSafe, E: RefUnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

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

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T> IntoEither for T

source§

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
source§

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
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

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

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

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

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Boilerplate for T
where T: Copy + Send + Sync + Debug + PartialEq + 'static,

§

impl<T> UniversalReborrow for T
where T: for<'a> Reborrow<'a>,

§

impl<T> UniversalReborrowMut for T
where T: for<'a> ReborrowMut<'a>,