Struct Matrix

pub struct Matrix<M> { /* private fields */ }

Generic matrix container.

Implementations

impl<I, E: Entity> Matrix<PermOwn<I, E>>

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

Convert self to a permutation view.

pub fn as_mut(&mut self) -> PermutationMut<'_, I, E>

Convert self to a mutable permutation view.

impl<I: Index, E: Entity> Matrix<PermOwn<I, E>>

pub fn new_checked(forward: Box<[I]>, inverse: Box<[I]>) -> Self

Creates a new permutation, by checking the validity of the inputs.

Panics

The function panics if any of the following conditions are violated: forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other.

pub unsafe fn new_unchecked(forward: Box<[I]>, inverse: Box<[I]>) -> Self

Creates a new permutation reference, without checking the validity of the inputs.

Safety

forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other.

pub fn into_arrays(self) -> (Box<[I]>, Box<[I]>)

Returns the permutation as an array.

pub fn len(&self) -> usize

Returns the dimension of the permutation.

pub fn inverse(self) -> Self

Returns the inverse permutation.

pub fn cast<T: Entity>(self) -> Permutation<I, T>

Cast the permutation to a different scalar type.

impl<'a, I: Index, E: Entity> Matrix<PermRef<'a, I, E>>

pub fn new_checked(forward: &'a [I], inverse: &'a [I]) -> Self

Creates a new permutation reference, by checking the validity of the inputs.

Panics

The function panics if any of the following conditions are violated: forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other.

pub unsafe fn new_unchecked(forward: &'a [I], inverse: &'a [I]) -> Self

Creates a new permutation reference, without checking the validity of the inputs.

Safety

forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other.

pub fn into_arrays(self) -> (&'a [I], &'a [I])

Returns the permutation as an array.

pub fn len(&self) -> usize

Returns the dimension of the permutation.

pub fn inverse(self) -> Self

Returns the inverse permutation.

pub fn cast<T: Entity>(self) -> PermutationRef<'a, I, T>

Cast the permutation to a different scalar type.

pub fn canonicalize(self) -> PermutationRef<'a, I::FixedWidth, E>

Cast the permutation to the fixed width index type.

pub fn uncanonicalize<J: Index>(self) -> PermutationRef<'a, J, E>

Cast the permutation from the fixed width index type.

impl<'a, I: Index, E: Entity> Matrix<PermMut<'a, I, E>>

pub fn new_checked(forward: &'a mut [I], inverse: &'a mut [I]) -> Self

Creates a new permutation mutable reference, by checking the validity of the inputs.

Panics

The function panics if any of the following conditions are violated: forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other.

pub unsafe fn new_unchecked(forward: &'a mut [I], inverse: &'a mut [I]) -> Self

Creates a new permutation mutable reference, without checking the validity of the inputs.

Safety

forward and inverse must have the same length which must be less than or equal to I::Signed::MAX, be valid permutations, and be inverse permutations of each other.

pub unsafe fn into_arrays(self) -> (&'a mut [I], &'a mut [I])

Returns the permutation as an array.

Safety

The behavior is undefined if the arrays are no longer inverse permutations of each other by the end of lifetime 'a.

pub fn len(&self) -> usize

Returns the dimension of the permutation.

pub fn inverse(self) -> Self

Returns the inverse permutation.

pub fn cast<T: Entity>(self) -> PermutationMut<'a, I, T>

Cast the permutation to a different scalar type.

pub fn canonicalize(self) -> PermutationMut<'a, I::FixedWidth, E>

Cast the permutation to the fixed width index type.

pub fn uncanonicalize<J: Index>(self) -> PermutationMut<'a, J, E>

Cast the permutation from the fixed width index type.

impl<'a, I: Index, E: Entity> Matrix<SparseRowMatMut<'a, I, E>>

pub fn new( symbolic: SymbolicSparseRowMatRef<'a, I>, values: GroupFor<E, &'a mut [E::Unit]>, ) -> Self

Creates a new sparse matrix view.

Panics

Panics if the length of values is not equal to the length of symbolic.col_indices().

pub fn to_owned(&self) -> Result<SparseRowMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_col_major(&self) -> Result<SparseColMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix, with column-major order.

Note

Allows unsorted matrices, producing a sorted output. Duplicate entries are kept, however.

pub fn transpose_mut(self) -> SparseColMatMut<'a, I, E>

Returns a view over the transpose of self in column-major format.

pub fn canonicalize_mut(self) -> (SparseRowMatMut<'a, I, E::Canonical>, Conj)

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn conjugate_mut(self) -> SparseRowMatMut<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint_mut(self) -> SparseColMatMut<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn values_mut(self) -> GroupFor<E, &'a mut [E::Unit]>

Returns the numerical values of the matrix.

pub fn values_of_row_mut(self, i: usize) -> GroupFor<E, &'a mut [E::Unit]>

Returns the numerical values of row i of the matrix.

Panics:

Panics if i >= nrows.

pub fn symbolic(&self) -> SymbolicSparseRowMatRef<'a, I>

Returns the symbolic structure of the matrix.

pub fn into_parts( self, ) -> (SymbolicSparseRowMatRef<'a, I>, GroupFor<E, &'a mut [E::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

impl<'a, I: Index, E: Entity> Matrix<SparseColMatMut<'a, I, E>>

pub fn new( symbolic: SymbolicSparseColMatRef<'a, I>, values: GroupFor<E, &'a mut [E::Unit]>, ) -> Self

Creates a new sparse matrix view.

Panics

Panics if the length of values is not equal to the length of symbolic.row_indices().

pub fn to_owned(&self) -> Result<SparseColMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_row_major(&self) -> Result<SparseRowMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix, with row-major order.

Note

Allows unsorted matrices, producing a sorted output. Duplicate entries are kept, however.

pub fn transpose_mut(self) -> SparseRowMatMut<'a, I, E>

Returns a view over the transpose of self in row-major format.

pub fn conjugate_mut(self) -> SparseColMatMut<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn canonicalize_mut(self) -> (SparseColMatMut<'a, I, E::Canonical>, Conj)

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint_mut(self) -> SparseRowMatMut<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn values_mut(self) -> GroupFor<E, &'a mut [E::Unit]>

Returns the numerical values of the matrix.

pub fn values_of_col_mut(self, j: usize) -> GroupFor<E, &'a mut [E::Unit]>

Returns the numerical values of column j of the matrix.

Panics:

Panics if j >= ncols.

pub fn symbolic(&self) -> SymbolicSparseColMatRef<'a, I>

Returns the symbolic structure of the matrix.

pub fn into_parts_mut( self, ) -> (SymbolicSparseColMatRef<'a, I>, GroupFor<E, &'a mut [E::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

impl<'a, I: Index, E: Entity> Matrix<SparseRowMatRef<'a, I, E>>

pub fn new( symbolic: SymbolicSparseRowMatRef<'a, I>, values: GroupFor<E, &'a [E::Unit]>, ) -> Self

Creates a new sparse matrix view.

Panics

Panics if the length of values is not equal to the length of symbolic.col_indices().

pub fn values(self) -> GroupFor<E, &'a [E::Unit]>

Returns the numerical values of the matrix.

pub fn to_owned(&self) -> Result<SparseRowMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_col_major(&self) -> Result<SparseColMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix, with column-major order.

Note

Allows unsorted matrices, producing a sorted output. Duplicate entries are kept, however.

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

Returns a view over the transpose of self in column-major format.

pub fn conjugate(self) -> SparseRowMatRef<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn canonicalize(self) -> (SparseRowMatRef<'a, I, E::Canonical>, Conj)

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(self) -> SparseColMatRef<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn values_of_row(self, i: usize) -> GroupFor<E, &'a [E::Unit]>

Returns the numerical values of row i of the matrix.

Panics:

Panics if i >= nrows.

pub fn symbolic(&self) -> SymbolicSparseRowMatRef<'a, I>

Returns the symbolic structure of the matrix.

pub fn into_parts( self, ) -> (SymbolicSparseRowMatRef<'a, I>, GroupFor<E, &'a [E::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

impl<'a, I: Index, E: Entity> Matrix<SparseColMatRef<'a, I, E>>

pub fn new( symbolic: SymbolicSparseColMatRef<'a, I>, values: GroupFor<E, &'a [E::Unit]>, ) -> Self

Creates a new sparse matrix view.

Panics

Panics if the length of values is not equal to the length of symbolic.row_indices().

pub fn to_owned(&self) -> Result<SparseColMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_row_major(&self) -> Result<SparseRowMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix, with row-major order.

Note

Allows unsorted matrices, producing a sorted output. Duplicate entries are kept, however.

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

Returns a view over the transpose of self in row-major format.

pub fn conjugate(self) -> SparseColMatRef<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn canonicalize(self) -> (SparseColMatRef<'a, I, E::Canonical>, Conj)

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(self) -> SparseRowMatRef<'a, I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn values(self) -> GroupFor<E, &'a [E::Unit]>

Returns the numerical values of the matrix.

pub fn values_of_col(self, j: usize) -> GroupFor<E, &'a [E::Unit]>

Returns the numerical values of column j of the matrix.

Panics:

Panics if j >= ncols.

pub fn symbolic(&self) -> SymbolicSparseColMatRef<'a, I>

Returns the symbolic structure of the matrix.

pub fn into_parts( self, ) -> (SymbolicSparseColMatRef<'a, I>, GroupFor<E, &'a [E::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

impl<I: Index, E: Entity> Matrix<SparseColMat<I, E>>

pub fn new( symbolic: SymbolicSparseColMat<I>, values: GroupFor<E, Vec<E::Unit>>, ) -> Self

Creates a new sparse matrix view.

Panics

Panics if the length of values is not equal to the length of symbolic.row_indices().

pub fn to_owned(&self) -> Result<SparseColMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_row_major(&self) -> Result<SparseRowMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix, with row-major order.

Note

Allows unsorted matrices, producing a sorted output. Duplicate entries are kept, however.

pub fn into_parts(self) -> (SymbolicSparseColMat<I>, GroupFor<E, Vec<E::Unit>>)

Decomposes the matrix into the symbolic part and the numerical values.

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

Returns a view over self.

pub fn as_mut(&mut self) -> SparseColMatMut<'_, I, E>

Returns a mutable view over self.

Note that the symbolic structure cannot be changed through this view.

pub fn values(&self) -> GroupFor<E, &[E::Unit]>

Returns a slice over the numerical values of the matrix.

pub fn values_mut(&mut self) -> GroupFor<E, &mut [E::Unit]>

Returns a mutable slice over the numerical values of the matrix.

pub fn into_transpose(self) -> SparseRowMat<I, E>

Returns a view over the transpose of self in row-major format.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn into_conjugate(self) -> SparseColMat<I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn into_adjoint(self) -> SparseRowMat<I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

impl<I: Index, E: Entity> Matrix<SparseRowMat<I, E>>

pub fn new( symbolic: SymbolicSparseRowMat<I>, values: GroupFor<E, Vec<E::Unit>>, ) -> Self

Creates a new sparse matrix view.

Panics

Panics if the length of values is not equal to the length of symbolic.col_indices().

pub fn to_owned(&self) -> Result<SparseRowMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_col_major(&self) -> Result<SparseColMat<I, E::Canonical>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies the current matrix into a newly allocated matrix, with column-major order.

Note

Allows unsorted matrices, producing a sorted output. Duplicate entries are kept, however.

pub fn into_parts(self) -> (SymbolicSparseRowMat<I>, GroupFor<E, Vec<E::Unit>>)

Decomposes the matrix into the symbolic part and the numerical values.

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

Returns a view over self.

pub fn as_mut(&mut self) -> SparseRowMatMut<'_, I, E>

Returns a mutable view over self.

Note that the symbolic structure cannot be changed through this view.

pub fn values(&self) -> GroupFor<E, &[E::Unit]>

Returns a slice over the numerical values of the matrix.

pub fn values_mut(&mut self) -> GroupFor<E, &mut [E::Unit]>

Returns a mutable slice over the numerical values of the matrix.

pub fn into_transpose(self) -> SparseColMat<I, E>

Returns a view over the transpose of self in column-major format.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn into_conjugate(self) -> SparseRowMat<I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn into_adjoint(self) -> SparseColMat<I, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

impl<I: Index, E: ComplexField> Matrix<SparseColMat<I, E>>

pub fn new_from_order_and_values( symbolic: SymbolicSparseColMat<I>, order: &ValuesOrder<I>, values: GroupFor<E, &[E::Unit]>, ) -> Result<Self, FaerError>

Create a new matrix from a previously created symbolic structure and value order. The provided values must correspond to the same indices that were provided in the function call from which the order was created.

pub fn try_new_from_triplets( nrows: usize, ncols: usize, triplets: &[(I, I, E)], ) -> Result<Self, CreationError>

Create a new matrix from triplets (row, col, value).

pub fn try_new_from_nonnegative_triplets( nrows: usize, ncols: usize, triplets: &[(I::Signed, I::Signed, E)], ) -> Result<Self, CreationError>

Create a new matrix from triplets (row, col, value). Negative indices are ignored.

impl<I: Index, E: ComplexField> Matrix<SparseRowMat<I, E>>

pub fn new_from_order_and_values( symbolic: SymbolicSparseRowMat<I>, order: &ValuesOrder<I>, values: GroupFor<E, &[E::Unit]>, ) -> Result<Self, FaerError>

Create a new matrix from a previously created symbolic structure and value order. The provided values must correspond to the same indices that were provided in the function call from which the order was created.

pub fn try_new_from_triplets( nrows: usize, ncols: usize, triplets: &[(I, I, E)], ) -> Result<Self, CreationError>

Create a new matrix from triplets (row, col, value).

pub fn try_new_from_nonnegative_triplets( nrows: usize, ncols: usize, triplets: &[(I::Signed, I::Signed, E)], ) -> Result<Self, CreationError>

Create a new matrix from triplets (row, col, value). Negative indices are ignored.

impl<I: Index, E: ComplexField> Matrix<SparseColMatMut<'_, I, E>>

pub fn fill_from_order_and_values( &mut self, order: &ValuesOrder<I>, values: GroupFor<E, &[E::Unit]>, mode: FillMode, )

Fill the matrix from a previously created value order. The provided values must correspond to the same indices that were provided in the function call from which the order was created.

Note

The symbolic structure is not changed.

impl<I: Index, E: ComplexField> Matrix<SparseRowMatMut<'_, I, E>>

pub fn fill_from_order_and_values( &mut self, order: &ValuesOrder<I>, values: GroupFor<E, &[E::Unit]>, mode: FillMode, )

Fill the matrix from a previously created value order. The provided values must correspond to the same indices that were provided in the function call from which the order was created.

Note

The symbolic structure is not changed.

impl<'a, I: Index, E: Entity> Matrix<SparseColMatRef<'a, I, E>>

pub fn get(self, row: usize, col: usize) -> Option<GroupFor<E, &'a E::Unit>>

Returns a reference to the value at the given index, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

impl<'a, I: Index, E: Entity> Matrix<SparseColMatMut<'a, I, E>>

pub fn get(self, row: usize, col: usize) -> Option<GroupFor<E, &'a E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

pub fn get_mut( self, row: usize, col: usize, ) -> Option<GroupFor<E, &'a mut E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

impl<I: Index, E: Entity> Matrix<SparseColMat<I, E>>

pub fn get(&self, row: usize, col: usize) -> Option<GroupFor<E, &E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

pub fn get_mut( &mut self, row: usize, col: usize, ) -> Option<GroupFor<E, &mut E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

impl<'a, I: Index, E: Entity> Matrix<SparseRowMatRef<'a, I, E>>

pub fn get(self, row: usize, col: usize) -> Option<GroupFor<E, &'a E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

impl<'a, I: Index, E: Entity> Matrix<SparseRowMatMut<'a, I, E>>

pub fn get_mut( self, row: usize, col: usize, ) -> Option<GroupFor<E, &'a mut E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

impl<I: Index, E: Entity> Matrix<SparseRowMat<I, E>>

pub fn get(&self, row: usize, col: usize) -> Option<GroupFor<E, &E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

pub fn get_mut( &mut self, row: usize, col: usize, ) -> Option<GroupFor<E, &mut E::Unit>>

Returns a reference to the value at the given index using a binary search, or None if the symbolic structure doesn’t contain it

Panics

Panics if row >= self.nrows()
Panics if col >= self.ncols()

impl<E: Entity> Matrix<Scale<E>>

pub fn new(value: E) -> Self

Returns a new scaling factor with the given value.

pub fn value(self) -> E

Returns the value of the scaling factor.

impl<'a, E: Entity> Matrix<DiagRef<'a, E>>

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

Returns the diagonal as a column vector view.

impl<'a, E: Entity> Matrix<DiagMut<'a, E>>

pub fn column_vector_mut(self) -> ColMut<'a, E>

Returns the diagonal as a mutable column vector view.

impl<E: Entity> Matrix<DiagOwn<E>>

pub fn into_column_vector(self) -> Col<E>

Returns the diagonal as a column vector.

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

Returns a view over self.

pub fn as_mut(&mut self) -> Matrix<DiagMut<'_, E>>

Returns a mutable view over self.

impl<'a, E: Entity> Matrix<DenseColRef<'a, E>>

pub fn nrows(&self) -> usize

Returns the number of rows of the column.

pub fn ncols(&self) -> usize

Returns the number of columns of the column. This is always equal to 1.

pub fn as_ptr(self) -> GroupFor<E, *const E::Unit>

Returns pointers to the matrix data.

pub fn row_stride(&self) -> isize

Returns the row 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, row: usize) -> GroupFor<E, *const E::Unit>

Returns raw pointers to the element at the given index.

pub unsafe fn ptr_inbounds_at(self, row: usize) -> GroupFor<E, *const E::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:

• row < self.nrows().

pub unsafe fn split_at_unchecked(self, row: usize) -> (Self, Self)

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

• top.
• bottom.

Safety

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

• row <= self.nrows().

pub unsafe fn split_at(self, row: usize) -> (Self, Self)

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:

• row <= self.nrows().

pub unsafe fn get_unchecked<RowRange>( self, row: RowRange, ) -> <Self as ColIndex<RowRange>>::Target

where Self: ColIndex<RowRange>,

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:

• row must be contained in [0, self.nrows()).

pub fn get<RowRange>( self, row: RowRange, ) -> <Self as ColIndex<RowRange>>::Target

where Self: ColIndex<RowRange>,

Returns references to the element at the given index, or subvector if row 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:

• row must be contained in [0, self.nrows()).

pub unsafe fn read_unchecked(&self, row: 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:

• row < self.nrows().

pub fn read(&self, row: 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:

• row < self.nrows().

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

Returns a view over the transpose of self.

pub fn conjugate(self) -> ColRef<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(self) -> RowRef<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize(self) -> (ColRef<'a, E::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_rows(self) -> Self

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

pub unsafe fn subrows_unchecked(self, row_start: usize, nrows: usize) -> Self

Returns a view over the subvector starting at row row_start, and with number of rows nrows.

Safety

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

pub fn subrows(self, row_start: usize, nrows: usize) -> Self

Returns a view over the subvector starting at row row_start, and with number of rows nrows.

Safety

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

pub fn column_vector_as_diagonal(self) -> Matrix<DiagRef<'a, E>>

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whoes diagonal elements are values in the column.

pub fn to_owned(&self) -> Col<E::Canonical>

where E: Conjugate,

Returns an owning Col 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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

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

Returns a view over the matrix.

impl<'a, E: Entity> Matrix<DenseColMut<'a, E>>

pub fn nrows(&self) -> usize

Returns the number of rows of the column.

pub fn ncols(&self) -> usize

Returns the number of columns of the column. This is always equal to 1.

pub fn as_ptr_mut(self) -> GroupFor<E, *mut E::Unit>

Returns pointers to the matrix data.

pub fn row_stride(&self) -> isize

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

pub fn as_2d_mut(self) -> MatMut<'a, E>

Returns self as a mutable matrix view.

pub fn ptr_at_mut(self, row: usize) -> GroupFor<E, *mut E::Unit>

Returns raw pointers to the element at the given index.

pub unsafe fn ptr_inbounds_at_mut(self, row: usize) -> GroupFor<E, *mut E::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:

• row < self.nrows().

pub unsafe fn split_at_mut_unchecked(self, row: usize) -> (Self, Self)

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

• top.
• bottom.

Safety

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

• row <= self.nrows().

pub fn split_at_mut(self, row: usize) -> (Self, Self)

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:

• row <= self.nrows().

pub unsafe fn get_unchecked_mut<RowRange>( self, row: RowRange, ) -> <Self as ColIndex<RowRange>>::Target

where Self: ColIndex<RowRange>,

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:

• row must be contained in [0, self.nrows()).

pub fn get_mut<RowRange>( self, row: RowRange, ) -> <Self as ColIndex<RowRange>>::Target

where Self: ColIndex<RowRange>,

Returns references to the element at the given index, or subvector if row 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:

• row must be contained in [0, self.nrows()).

pub unsafe fn read_unchecked(&self, row: 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:

• row < self.nrows().

pub fn read(&self, row: 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:

• row < self.nrows().

pub unsafe fn write_unchecked(&mut self, row: usize, value: E)

Writes the value to the element at the given index.

Safety

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

• row < self.nrows().

pub fn write(&mut self, row: usize, value: E)

Writes the value to the element at the given index, with bound checks.

Panics

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

• row < self.nrows().

pub fn copy_from(&mut self, other: impl AsColRef<E>)

Copies the values from other into self.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

pub fn transpose_mut(self) -> RowMut<'a, E>

Returns a view over the transpose of self.

pub fn conjugate_mut(self) -> ColMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint_mut(self) -> RowMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize_mut(self) -> (ColMut<'a, E::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_rows_mut(self) -> Self

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

pub unsafe fn subrows_mut_unchecked( self, row_start: usize, nrows: usize, ) -> Self

Returns a view over the subvector starting at row row_start, and with number of rows nrows.

Safety

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

pub fn subrows_mut(self, row_start: usize, nrows: usize) -> Self

Returns a view over the subvector starting at row row_start, and with number of rows nrows.

Safety

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

pub fn column_vector_as_diagonal(self) -> Matrix<DiagMut<'a, E>>

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whoes diagonal elements are values in the column.

pub fn to_owned(&self) -> Col<E::Canonical>

where E: Conjugate,

Returns an owning Col 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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

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

Returns a view over the matrix.

impl<'a, E: Entity> Matrix<DenseRowRef<'a, E>>

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) -> GroupFor<E, *const E::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) -> GroupFor<E, *const E::Unit>

Returns raw pointers to the element at the given index.

pub unsafe fn ptr_inbounds_at(self, col: usize) -> GroupFor<E, *const E::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) -> (Self, Self)

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 unsafe fn split_at(self, col: usize) -> (Self, Self)

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, ) -> <Self as RowIndex<ColRange>>::Target

where Self: 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, ) -> <Self as RowIndex<ColRange>>::Target

where Self: 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::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

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

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize(self) -> (RowRef<'a, E::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) -> Self

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

pub unsafe fn subcols_unchecked(self, col_start: usize, ncols: usize) -> Self

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) -> Self

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::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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

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

Returns a view over the matrix.

impl<'a, E: Entity> Matrix<DenseRowMut<'a, E>>

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_mut(self) -> GroupFor<E, *mut E::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_mut(self) -> MatMut<'a, E>

Returns self as a mutable matrix view.

pub fn ptr_at_mut(self, col: usize) -> GroupFor<E, *mut E::Unit>

Returns raw pointers to the element at the given index.

pub unsafe fn ptr_inbounds_at_mut(self, col: usize) -> GroupFor<E, *mut E::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_mut_unchecked(self, col: usize) -> (Self, Self)

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_mut(self, col: usize) -> (Self, Self)

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_mut_unchecked<ColRange>( self, col: ColRange, ) -> <Self as RowIndex<ColRange>>::Target

where Self: RowIndex<ColRange>,

Returns references to the element at the given index, or subvector if col 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_mut<ColRange>( self, col: ColRange, ) -> <Self as RowIndex<ColRange>>::Target

where Self: 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 unsafe fn write_unchecked(&mut self, col: usize, value: E)

Writes the value to the element at the given index.

Safety

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

• col < self.ncols().

pub fn write(&mut self, col: usize, value: E)

Writes the value to 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 copy_from(&mut self, other: impl AsRowRef<E>)

Copies the values from other into self.

Panics

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

• self.ncols() == other.ncols().

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

pub fn transpose_mut(self) -> ColMut<'a, E>

Returns a view over the transpose of self.

pub fn conjugate_mut(self) -> RowMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint_mut(self) -> ColMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize_mut(self) -> (RowMut<'a, E::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_mut(self) -> Self

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

pub unsafe fn subcols_mut_unchecked( self, col_start: usize, ncols: usize, ) -> Self

Returns a view over the subvector starting at col 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_mut(self, col_start: usize, ncols: usize) -> Self

Returns a view over the subvector starting at col 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 to_owned(&self) -> Row<E::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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

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

Returns a view over the matrix.

impl<'a, E: Entity> Matrix<DenseRef<'a, E>>

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

pub fn as_ptr(self) -> GroupFor<E, *const E::Unit>

Returns pointers to the matrix data.

pub fn row_stride(&self) -> isize

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

pub fn col_stride(&self) -> isize

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

pub fn ptr_at(self, row: usize, col: usize) -> GroupFor<E, *const E::Unit>

Returns raw pointers to the element at the given indices.

pub unsafe fn ptr_inbounds_at( self, row: usize, col: usize, ) -> GroupFor<E, *const E::Unit>

Returns raw pointers to the element at the given indices, assuming the provided indices are within the matrix dimensions.

Safety

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

• row < self.nrows().
• col < self.ncols().

pub unsafe fn split_at_unchecked( self, row: usize, col: usize, ) -> (Self, Self, Self, Self)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

• top left.
• top right.
• bottom left.
• bottom right.

Safety

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

• row <= self.nrows().
• col <= self.ncols().

pub fn split_at(self, row: usize, col: usize) -> (Self, Self, Self, Self)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

• top left.
• top right.
• bottom left.
• bottom right.

Panics

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

• row <= self.nrows().
• col <= self.ncols().

pub unsafe fn split_at_row_unchecked(self, row: usize) -> (Self, Self)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

• top.
• bottom.

Safety

The behavior is undefined if the following condition is violated:

• row <= self.nrows().

pub fn split_at_row(self, row: usize) -> (Self, Self)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

• top.
• bottom.

Panics

The function panics if the following condition is violated:

• row <= self.nrows().

pub unsafe fn split_at_col_unchecked(self, col: usize) -> (Self, Self)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

• left.
• right.

Safety

The behavior is undefined if the following condition is violated:

• col <= self.ncols().

pub fn split_at_col(self, col: usize) -> (Self, Self)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

• left.
• right.

Panics

The function panics if the following condition is violated:

• col <= self.ncols().

pub unsafe fn get_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

Returns references to the element at the given indices, or submatrices if either row or col 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:

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

pub fn get<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

Returns references to the element at the given indices, or submatrices if either row or 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:

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

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

Reads the value of the element at the given indices.

Safety

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

• row < self.nrows().
• col < self.ncols().

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

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

Panics

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

• row < self.nrows().
• col < self.ncols().

pub fn transpose(self) -> Self

Returns a view over the transpose of self.

Example

use faer_core::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let transpose = view.transpose();

let expected = mat![[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]];
assert_eq!(expected.as_ref(), transpose);

pub fn conjugate(self) -> MatRef<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(self) -> MatRef<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize(self) -> (MatRef<'a, E::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_rows(self) -> Self

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

Example

use faer_core::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed_rows = view.reverse_rows();

let expected = mat![[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]];
assert_eq!(expected.as_ref(), reversed_rows);

pub fn reverse_cols(self) -> Self

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

Example

use faer_core::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed_cols = view.reverse_cols();

let expected = mat![[3.0, 2.0, 1.0], [6.0, 5.0, 4.0]];
assert_eq!(expected.as_ref(), reversed_cols);

pub fn reverse_rows_and_cols(self) -> Self

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

Example

use faer_core::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed = view.reverse_rows_and_cols();

let expected = mat![[6.0, 5.0, 4.0], [3.0, 2.0, 1.0]];
assert_eq!(expected.as_ref(), reversed);

pub unsafe fn submatrix_unchecked( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> Self

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

Safety

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

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

pub fn submatrix( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> Self

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

Panics

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

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

Example

use faer_core::mat;

let matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_ref();
let submatrix = view.submatrix(2, 1, 2, 2);

let expected = mat![[7.0, 11.0], [8.0, 12.0f64]];
assert_eq!(expected.as_ref(), submatrix);

pub unsafe fn subrows_unchecked(self, row_start: usize, nrows: usize) -> Self

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

Safety

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

pub fn subrows(self, row_start: usize, nrows: usize) -> Self

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

Panics

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

Example

use faer_core::mat;

let matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_ref();
let subrows = view.subrows(1, 2);

let expected = mat![[2.0, 6.0, 10.0], [3.0, 7.0, 11.0],];
assert_eq!(expected.as_ref(), subrows);

pub unsafe fn subcols_unchecked(self, col_start: usize, ncols: usize) -> Self

Returns a view over the submatrix 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) -> Self

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

Panics

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

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

Example

use faer_core::mat;

let matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_ref();
let subcols = view.subcols(2, 1);

let expected = mat![[9.0], [10.0], [11.0], [12.0f64]];
assert_eq!(expected.as_ref(), subcols);

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

Returns a view over the row at the given index.

Safety

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

• row_idx < self.nrows().

pub fn row(self, row_idx: usize) -> RowRef<'a, E>

Returns a view over the row at the given index.

Panics

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

• row_idx < self.nrows().

pub unsafe fn col_unchecked(self, col_idx: usize) -> ColRef<'a, E>

Returns a view over the column at the given index.

Safety

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

• col_idx < self.ncols().

pub fn col(self, col_idx: usize) -> ColRef<'a, E>

Returns a view over the column at the given index.

Panics

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

• col_idx < self.ncols().

pub fn column_vector_as_diagonal(self) -> Matrix<DiagRef<'a, E>>

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whoes diagonal elements are values in the column.

pub fn diagonal(self) -> Matrix<DiagRef<'a, E>>

Returns the diagonal of the matrix.

pub fn to_owned(&self) -> Mat<E::Canonical>

where E: Conjugate,

Returns an owning Mat 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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

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

Returns a view over the matrix.

pub fn col_chunks( self, chunk_size: usize, ) -> impl 'a + DoubleEndedIterator<Item = MatRef<'a, E>>

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

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn row_chunks( self, chunk_size: usize, ) -> impl 'a + DoubleEndedIterator<Item = MatRef<'a, E>>

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

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn par_col_chunks( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the columns of this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn par_row_chunks( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the rows of this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

pub fn into_par_row_chunks( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, E>>

👎Deprecated: replaced by MatRef::par_row_chunks

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the rows of this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

impl<'a, E: Entity> Matrix<DenseMut<'a, E>>

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

pub fn as_ptr_mut(self) -> GroupFor<E, *mut E::Unit>

Returns pointers to the matrix data.

pub fn row_stride(&self) -> isize

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

pub fn col_stride(&self) -> isize

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

pub fn ptr_at_mut(self, row: usize, col: usize) -> GroupFor<E, *mut E::Unit>

Returns raw pointers to the element at the given indices.

pub unsafe fn ptr_inbounds_at_mut( self, row: usize, col: usize, ) -> GroupFor<E, *mut E::Unit>

Returns raw pointers to the element at the given indices, assuming the provided indices are within the matrix dimensions.

Safety

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

• row < self.nrows().
• col < self.ncols().

pub unsafe fn split_at_mut_unchecked( self, row: usize, col: usize, ) -> (Self, Self, Self, Self)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

• top left.
• top right.
• bottom left.
• bottom right.

Safety

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

• row <= self.nrows().
• col <= self.ncols().

pub fn split_at_mut(self, row: usize, col: usize) -> (Self, Self, Self, Self)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

• top left.
• top right.
• bottom left.
• bottom right.

Panics

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

• row <= self.nrows().
• col <= self.ncols().

pub unsafe fn split_at_row_mut_unchecked(self, row: usize) -> (Self, Self)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

• top.
• bottom.

Safety

The behavior is undefined if the following condition is violated:

• row <= self.nrows().

pub fn split_at_row_mut(self, row: usize) -> (Self, Self)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

• top.
• bottom.

Panics

The function panics if the following condition is violated:

• row <= self.nrows().

pub unsafe fn split_at_col_mut_unchecked(self, col: usize) -> (Self, Self)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

• left.
• right.

Safety

The behavior is undefined if the following condition is violated:

• col <= self.ncols().

pub fn split_at_col_mut(self, col: usize) -> (Self, Self)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

• left.
• right.

Panics

The function panics if the following condition is violated:

• col <= self.ncols().

pub unsafe fn get_mut_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or col 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:

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

pub fn get_mut<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or 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:

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

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

Reads the value of the element at the given indices.

Safety

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

• row < self.nrows().
• col < self.ncols().

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

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

Panics

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

• row < self.nrows().
• col < self.ncols().

pub unsafe fn write_unchecked(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices.

Safety

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

• row < self.nrows().
• col < self.ncols().

pub fn write(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices, with bound checks.

Panics

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

• row < self.nrows().
• col < self.ncols().

pub fn copy_from_triangular_lower(&mut self, other: impl AsMatRef<E>)

Copies the values from the lower triangular part of other into the lower triangular part of self. The diagonal part is included.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from_strict_triangular_lower(&mut self, other: impl AsMatRef<E>)

Copies the values from the lower triangular part of other into the lower triangular part of self. The diagonal part is excluded.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from_triangular_upper(&mut self, other: impl AsMatRef<E>)

Copies the values from the upper triangular part of other into the upper triangular part of self. The diagonal part is included.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from_strict_triangular_upper(&mut self, other: impl AsMatRef<E>)

Copies the values from the upper triangular part of other into the upper triangular part of self. The diagonal part is excluded.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from(&mut self, other: impl AsMatRef<E>)

Copies the values from other into self.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

pub fn transpose_mut(self) -> Self

Returns a view over the transpose of self.

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let transpose = view.transpose_mut();

let mut expected = mat![[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]];
assert_eq!(expected.as_mut(), transpose);

pub fn conjugate_mut(self) -> MatMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint_mut(self) -> MatMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize_mut(self) -> (MatMut<'a, E::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_rows_mut(self) -> Self

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

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed_rows = view.reverse_rows_mut();

let mut expected = mat![[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]];
assert_eq!(expected.as_mut(), reversed_rows);

pub fn reverse_cols_mut(self) -> Self

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

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed_cols = view.reverse_cols_mut();

let mut expected = mat![[3.0, 2.0, 1.0], [6.0, 5.0, 4.0]];
assert_eq!(expected.as_mut(), reversed_cols);

pub fn reverse_rows_and_cols_mut(self) -> Self

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

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed = view.reverse_rows_and_cols_mut();

let mut expected = mat![[6.0, 5.0, 4.0], [3.0, 2.0, 1.0]];
assert_eq!(expected.as_mut(), reversed);

pub fn submatrix_mut( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> Self

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

Panics

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

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

Example

use faer_core::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let submatrix = view.submatrix_mut(2, 1, 2, 2);

let mut expected = mat![[7.0, 11.0], [8.0, 12.0f64]];
assert_eq!(expected.as_mut(), submatrix);

pub fn subrows_mut(self, row_start: usize, nrows: usize) -> Self

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

Panics

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

Example

use faer_core::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let subrows = view.subrows_mut(1, 2);

let mut expected = mat![[2.0, 6.0, 10.0], [3.0, 7.0, 11.0],];
assert_eq!(expected.as_mut(), subrows);

pub fn subcols_mut(self, col_start: usize, ncols: usize) -> Self

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

Panics

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

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

Example

use faer_core::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let subcols = view.subcols_mut(2, 1);

let mut expected = mat![[9.0], [10.0], [11.0], [12.0f64]];
assert_eq!(expected.as_mut(), subcols);

pub fn row_mut(self, row_idx: usize) -> RowMut<'a, E>

Returns a view over the row at the given index.

Panics

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

• row_idx < self.nrows().

pub fn col_mut(self, col_idx: usize) -> ColMut<'a, E>

Returns a view over the column at the given index.

Panics

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

• col_idx < self.ncols().

pub fn column_vector_as_diagonal_mut(self) -> Matrix<DiagMut<'a, E>>

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whoes diagonal elements are values in the column.

pub fn diagonal_mut(self) -> Matrix<DiagMut<'a, E>>

Returns the diagonal of the matrix.

pub fn to_owned(&self) -> Mat<E::Canonical>

where E: Conjugate,

Returns an owning Mat 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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

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

Returns a view over the matrix.

pub fn as_mut(&mut self) -> MatMut<'_, E>

Returns a mutable view over the matrix.

pub fn col_chunks_mut( self, chunk_size: usize, ) -> impl 'a + DoubleEndedIterator<Item = MatMut<'a, E>>

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

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn row_chunks_mut( self, chunk_size: usize, ) -> impl 'a + DoubleEndedIterator<Item = MatMut<'a, E>>

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

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn par_col_chunks_mut( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the columns of this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn par_row_chunks_mut( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the rows of this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

impl<'a, E: RealField> Matrix<DenseRef<'a, Complex<E>>>

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

Returns the real and imaginary components of self.

impl<'a, E: RealField> Matrix<DenseMut<'a, Complex<E>>>

pub fn real_imag_mut(self) -> Complex<MatMut<'a, E>>

Returns the real and imaginary components of self.

impl<E: Entity> Matrix<DenseColOwn<E>>

pub fn new() -> Self

Returns an empty column of dimension 0.

pub fn with_capacity(row_capacity: usize) -> Self

Returns a new column vector with 0 rows, with enough capacity to hold a maximum of row_capacity rows columns without reallocating. If row_capacity is 0, the function will not allocate.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn from_fn(nrows: usize, f: impl FnMut(usize) -> E) -> Self

Returns a new matrix with number of rows nrows, filled with the provided function.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn zeros(nrows: usize) -> Self

where E: ComplexField,

Returns a new matrix with number of rows nrows, filled with zeros.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn nrows(&self) -> usize

Returns the number of rows of the column.

pub fn ncols(&self) -> usize

Returns the number of columns of the column. This is always equal to 1.

pub unsafe fn set_nrows(&mut self, nrows: usize)

Set the dimensions of the matrix.

Safety

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

• nrows < self.row_capacity().
• The elements that were previously out of bounds but are now in bounds must be initialized.

pub fn as_ptr(&self) -> GroupFor<E, *const E::Unit>

Returns a pointer to the data of the matrix.

pub fn as_ptr_mut(&mut self) -> GroupFor<E, *mut E::Unit>

Returns a mutable pointer to the data of the matrix.

pub fn row_capacity(&self) -> usize

Returns the row capacity, that is, the number of rows that the matrix is able to hold without needing to reallocate, excluding column insertions.

pub fn row_stride(&self) -> isize

Returns the offset between the first elements of two successive rows in the matrix. Always returns 1 since the matrix is column major.

pub fn reserve_exact(&mut self, row_capacity: usize)

Reserves the minimum capacity for row_capacity rows without reallocating. Does nothing if the capacity is already sufficient.

Panics

The function panics if the new total capacity in bytes exceeds isize::MAX.

pub fn resize_with(&mut self, new_nrows: usize, f: impl FnMut(usize) -> E)

Resizes the vector in-place so that the new number of rows is new_nrows. New elements are created with the given function f, so that elements at index i are created by calling f(i).

pub fn as_slice(&self) -> GroupFor<E, &[E::Unit]>

Returns a reference to a slice over the column.

pub fn as_slice_mut(&mut self) -> GroupFor<E, &mut [E::Unit]>

Returns a mutable reference to a slice over the column.

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

Returns a view over the vector.

pub fn as_mut(&mut self) -> ColMut<'_, E>

Returns a mutable view over the vector.

pub unsafe fn get_unchecked<RowRange>( &self, row: RowRange, ) -> <ColRef<'_, E> as ColIndex<RowRange>>::Target

where for<'a> ColRef<'a, E>: ColIndex<RowRange>,

Returns references to the element at the given index, or submatrices 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:

• row must be contained in [0, self.nrows()).

pub fn get<RowRange>( &self, row: RowRange, ) -> <ColRef<'_, E> as ColIndex<RowRange>>::Target

where for<'a> ColRef<'a, E>: ColIndex<RowRange>,

Returns references to the element at the given index, or submatrices if row 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:

• row must be contained in [0, self.nrows()).

pub unsafe fn get_mut_unchecked<RowRange>( &mut self, row: RowRange, ) -> <ColMut<'_, E> as ColIndex<RowRange>>::Target

where for<'a> ColMut<'a, E>: ColIndex<RowRange>,

Returns mutable references to the element at the given index, or submatrices 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:

• row must be contained in [0, self.nrows()).

pub fn get_mut<RowRange>( &mut self, row: RowRange, ) -> <ColMut<'_, E> as ColIndex<RowRange>>::Target

where for<'a> ColMut<'a, E>: ColIndex<RowRange>,

Returns mutable references to the element at the given index, or submatrices if row 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:

• row must be contained in [0, self.nrows()).

pub unsafe fn read_unchecked(&self, row: 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:

• row < self.nrows().

pub fn read(&self, row: 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:

• row < self.nrows().

pub unsafe fn write_unchecked(&mut self, row: usize, value: E)

Writes the value to the element at the given index.

Safety

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

• row < self.nrows().

pub fn write(&mut self, row: usize, value: E)

Writes the value to the element at the given index, with bound checks.

Panics

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

• row < self.nrows().

pub fn copy_from(&mut self, other: impl AsColRef<E>)

Copies the values from other into self.

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

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

Returns a view over the transpose of self.

pub fn conjugate(&self) -> ColRef<'_, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(&self) -> RowRef<'_, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn to_owned(&self) -> Col<E::Canonical>

where E: Conjugate,

Returns an owning Col 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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

impl<E: Entity> Matrix<DenseRowOwn<E>>

pub fn new() -> Self

Returns an empty row of dimension 0.

pub fn with_capacity(col_capacity: usize) -> Self

Returns a new column vector with 0 columns, with enough capacity to hold a maximum of col_capacity columnss columns without reallocating. If col_capacity is 0, the function will not allocate.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn from_fn(ncols: usize, f: impl FnMut(usize) -> E) -> Self

Returns a new matrix with number of columns ncols, filled with the provided function.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn zeros(ncols: usize) -> Self

where E: ComplexField,

Returns a new matrix with number of columns ncols, filled with zeros.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

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 unsafe fn set_ncols(&mut self, ncols: usize)

Set the dimensions of the matrix.

Safety

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

• ncols < self.col_capacity().
• The elements that were previously out of bounds but are now in bounds must be initialized.

pub fn as_ptr(&self) -> GroupFor<E, *const E::Unit>

Returns a pointer to the data of the matrix.

pub fn as_ptr_mut(&mut self) -> GroupFor<E, *mut E::Unit>

Returns a mutable pointer to the data of the matrix.

pub fn col_capacity(&self) -> usize

Returns the col capacity, that is, the number of cols that the matrix is able to hold without needing to reallocate, excluding column insertions.

pub fn col_stride(&self) -> isize

Returns the offset between the first elements of two successive columns in the matrix. Always returns 1 since the matrix is column major.

pub fn reserve_exact(&mut self, col_capacity: usize)

Reserves the minimum capacity for col_capacity columns without reallocating. Does nothing if the capacity is already sufficient.

Panics

The function panics if the new total capacity in bytes exceeds isize::MAX.

pub fn resize_with(&mut self, new_ncols: usize, f: impl FnMut(usize) -> E)

Resizes the vector in-place so that the new number of columns is new_ncols. New elements are created with the given function f, so that elements at index i are created by calling f(i).

pub fn as_slice(&self) -> GroupFor<E, &[E::Unit]>

Returns a reference to a slice over the row.

pub fn as_slice_mut(&mut self) -> GroupFor<E, &mut [E::Unit]>

Returns a mutable reference to a slice over the row.

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

Returns a view over the vector.

pub fn as_mut(&mut self) -> RowMut<'_, E>

Returns a mutable view over the vector.

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

where for<'a> RowRef<'a, E>: RowIndex<ColRange>,

Returns references to the element at the given index, or submatrices if col 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<'_, E> as RowIndex<ColRange>>::Target

where for<'a> RowRef<'a, E>: RowIndex<ColRange>,

Returns references to the element at the given index, or submatrices 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 get_mut_unchecked<ColRange>( &mut self, col: ColRange, ) -> <RowMut<'_, E> as RowIndex<ColRange>>::Target

where for<'a> RowMut<'a, E>: RowIndex<ColRange>,

Returns mutable references to the element at the given index, or submatrices if col 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_mut<ColRange>( &mut self, col: ColRange, ) -> <RowMut<'_, E> as RowIndex<ColRange>>::Target

where for<'a> RowMut<'a, E>: RowIndex<ColRange>,

Returns mutable references to the element at the given index, or submatrices 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 unsafe fn write_unchecked(&mut self, col: usize, value: E)

Writes the value to the element at the given index.

Safety

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

• col < self.ncols().

pub fn write(&mut self, col: usize, value: E)

Writes the value to 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 copy_from(&mut self, other: impl AsRowRef<E>)

Copies the values from other into self.

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

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

Returns a view over the transpose of self.

pub fn conjugate(&self) -> RowRef<'_, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(&self) -> ColRef<'_, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn to_owned(&self) -> Row<E::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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

impl<E: Entity> Matrix<DenseOwn<E>>

pub fn new() -> Self

Returns an empty matrix of dimension 0×0.

pub fn with_capacity(row_capacity: usize, col_capacity: usize) -> Self

Returns a new matrix with dimensions (0, 0), with enough capacity to hold a maximum of row_capacity rows and col_capacity columns without reallocating. If either is 0, the matrix will not allocate.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn from_fn( nrows: usize, ncols: usize, f: impl FnMut(usize, usize) -> E, ) -> Self

Returns a new matrix with dimensions (nrows, ncols), filled with the provided function.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn zeros(nrows: usize, ncols: usize) -> Self

where E: ComplexField,

Returns a new matrix with dimensions (nrows, ncols), filled with zeros.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn identity(nrows: usize, ncols: usize) -> Self

where E: ComplexField,

Returns a new matrix with dimensions (nrows, ncols), filled with zeros, except the main diagonal which is filled with ones.

Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

pub unsafe fn set_dims(&mut self, nrows: usize, ncols: usize)

Set the dimensions of the matrix.

Safety

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

• nrows < self.row_capacity().
• ncols < self.col_capacity().
• The elements that were previously out of bounds but are now in bounds must be initialized.

pub fn as_ptr(&self) -> GroupFor<E, *const E::Unit>

Returns a pointer to the data of the matrix.

pub fn as_ptr_mut(&mut self) -> GroupFor<E, *mut E::Unit>

Returns a mutable pointer to the data of the matrix.

pub fn row_capacity(&self) -> usize

Returns the row capacity, that is, the number of rows that the matrix is able to hold without needing to reallocate, excluding column insertions.

pub fn col_capacity(&self) -> usize

Returns the column capacity, that is, the number of columns that the matrix is able to hold without needing to reallocate, excluding row insertions.

pub fn row_stride(&self) -> isize

Returns the offset between the first elements of two successive rows in the matrix. Always returns 1 since the matrix is column major.

pub fn col_stride(&self) -> isize

Returns the offset between the first elements of two successive columns in the matrix.

pub fn reserve_exact(&mut self, row_capacity: usize, col_capacity: usize)

Reserves the minimum capacity for row_capacity rows and col_capacity columns without reallocating. Does nothing if the capacity is already sufficient.

Panics

The function panics if the new total capacity in bytes exceeds isize::MAX.

pub fn resize_with( &mut self, new_nrows: usize, new_ncols: usize, f: impl FnMut(usize, usize) -> E, )

Resizes the matrix in-place so that the new dimensions are (new_nrows, new_ncols). New elements are created with the given function f, so that elements at indices (i, j) are created by calling f(i, j).

pub fn col_as_slice(&self, col: usize) -> GroupFor<E, &[E::Unit]>

Returns a reference to a slice over the column at the given index.

pub fn col_as_slice_mut(&mut self, col: usize) -> GroupFor<E, &mut [E::Unit]>

Returns a mutable reference to a slice over the column at the given index.

pub fn col_ref(&self, col: usize) -> GroupFor<E, &[E::Unit]>

👎Deprecated: replaced by Mat::col_as_slice

Returns a reference to a slice over the column at the given index.

pub fn col_mut(&mut self, col: usize) -> GroupFor<E, &mut [E::Unit]>

👎Deprecated: replaced by Mat::col_as_slice_mut

Returns a mutable reference to a slice over the column at the given index.

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

Returns a view over the matrix.

pub fn as_mut(&mut self) -> MatMut<'_, E>

Returns a mutable view over the matrix.

pub unsafe fn get_unchecked<RowRange, ColRange>( &self, row: RowRange, col: ColRange, ) -> <MatRef<'_, E> as MatIndex<RowRange, ColRange>>::Target

where for<'a> MatRef<'a, E>: MatIndex<RowRange, ColRange>,

Returns references to the element at the given indices, or submatrices if either row or col 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:

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

pub fn get<RowRange, ColRange>( &self, row: RowRange, col: ColRange, ) -> <MatRef<'_, E> as MatIndex<RowRange, ColRange>>::Target

where for<'a> MatRef<'a, E>: MatIndex<RowRange, ColRange>,

Returns references to the element at the given indices, or submatrices if either row or 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:

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

pub unsafe fn get_mut_unchecked<RowRange, ColRange>( &mut self, row: RowRange, col: ColRange, ) -> <MatMut<'_, E> as MatIndex<RowRange, ColRange>>::Target

where for<'a> MatMut<'a, E>: MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or col 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:

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

pub fn get_mut<RowRange, ColRange>( &mut self, row: RowRange, col: ColRange, ) -> <MatMut<'_, E> as MatIndex<RowRange, ColRange>>::Target

where for<'a> MatMut<'a, E>: MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or 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:

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

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

Reads the value of the element at the given indices.

Safety

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

• row < self.nrows().
• col < self.ncols().

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

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

Panics

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

• row < self.nrows().
• col < self.ncols().

pub unsafe fn write_unchecked(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices.

Safety

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

• row < self.nrows().
• col < self.ncols().

pub fn write(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices, with bound checks.

Panics

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

• row < self.nrows().
• col < self.ncols().

pub fn copy_from(&mut self, other: impl AsMatRef<E>)

Copies the values from other into self.

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

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

Returns a view over the transpose of self.

pub fn conjugate(&self) -> MatRef<'_, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(&self) -> MatRef<'_, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

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

Returns a view over the diagonal of the matrix.

pub fn to_owned(&self) -> Mat<E::Canonical>

where E: Conjugate,

Returns an owning Mat 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::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the 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,

Kroneckor product of self and rhs.

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

pub fn col_chunks( &self, chunk_size: usize, ) -> impl '_ + DoubleEndedIterator<Item = MatRef<'_, E>>

Returns an iterator that provides successive chunks of the columns of a view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn col_chunks_mut( &mut self, chunk_size: usize, ) -> impl '_ + DoubleEndedIterator<Item = MatMut<'_, E>>

Returns an iterator that provides successive chunks of the columns of a mutable view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn par_col_chunks( &self, chunk_size: usize, ) -> impl '_ + IndexedParallelIterator<Item = MatRef<'_, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the columns of a view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn par_col_chunks_mut( &mut self, chunk_size: usize, ) -> impl '_ + IndexedParallelIterator<Item = MatMut<'_, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the columns of a mutable view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn row_chunks( &self, chunk_size: usize, ) -> impl '_ + DoubleEndedIterator<Item = MatRef<'_, E>>

Returns an iterator that provides successive chunks of the rows of a view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn row_chunks_mut( &mut self, chunk_size: usize, ) -> impl '_ + DoubleEndedIterator<Item = MatMut<'_, E>>

Returns an iterator that provides successive chunks of the rows of a mutable view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn par_row_chunks( &self, chunk_size: usize, ) -> impl '_ + IndexedParallelIterator<Item = MatRef<'_, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the rows of a view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

pub fn par_row_chunks_mut( &mut self, chunk_size: usize, ) -> impl '_ + IndexedParallelIterator<Item = MatMut<'_, E>>

Available on crate feature rayon only.

Returns a parallel iterator that provides successive chunks of the rows of a mutable view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

Trait Implementations

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Add<&Matrix<Rhs>> for &Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatAdd<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatAdd<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix<Rhs>) -> Self::Output

Performs the + operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Add<&Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatAdd<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatAdd<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix<Rhs>) -> Self::Output

Performs the + operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Add<Matrix<Rhs>> for &Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatAdd<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatAdd<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Rhs>) -> Self::Output

Performs the + operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Add<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatAdd<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatAdd<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Rhs>) -> Self::Output

Performs the + operation.

impl<Lhs: GenericMatrixMut, Rhs: GenericMatrix> AddAssign<&Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: ComplexField, Rhs::Elem: Conjugate<Canonical = Lhs::Elem>, Lhs::Kind: MatAddAssign<Rhs::Kind>,

fn add_assign(&mut self, rhs: &Matrix<Rhs>)

Performs the += operation.

impl<Lhs: GenericMatrixMut, Rhs: GenericMatrix> AddAssign<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: ComplexField, Rhs::Elem: Conjugate<Canonical = Lhs::Elem>, Lhs::Kind: MatAddAssign<Rhs::Kind>,

fn add_assign(&mut self, rhs: Matrix<Rhs>)

Performs the += operation.

impl<M: Clone> Clone for Matrix<M>

fn clone(&self) -> Matrix<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, FromE: Entity, ToE: Entity> Coerce<Matrix<DenseMut<'a, ToE>>> for MatMut<'a, FromE>

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

impl<'a, FromE: Entity, ToE: Entity> Coerce<Matrix<DenseRef<'a, ToE>>> for MatRef<'a, FromE>

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

impl<'a, E: Entity> IntoConst for Matrix<DiagMut<'a, E>>

type Target = Matrix<DiagRef<'a, E>>

fn into_const(self) -> Self::Target

impl<'a, E: Entity> IntoConst for Matrix<DiagRef<'a, E>>

type Target = Matrix<DiagRef<'a, E>>

fn into_const(self) -> Self::Target

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Mul<&Matrix<Rhs>> for &Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatMul<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatMul<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Rhs>) -> Self::Output

Performs the * operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Mul<&Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatMul<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatMul<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Rhs>) -> Self::Output

Performs the * operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Mul<Matrix<Rhs>> for &Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatMul<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatMul<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<Rhs>) -> Self::Output

Performs the * operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Mul<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatMul<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatMul<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<Rhs>) -> Self::Output

Performs the * operation.

impl<Lhs: GenericMatrixMut, Rhs: GenericMatrix> MulAssign<&Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: ComplexField, Rhs::Elem: Conjugate<Canonical = Lhs::Elem>, Lhs::Kind: MatMulAssign<Rhs::Kind>,

fn mul_assign(&mut self, rhs: &Matrix<Rhs>)

Performs the *= operation.

impl<Lhs: GenericMatrixMut, Rhs: GenericMatrix> MulAssign<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: ComplexField, Rhs::Elem: Conjugate<Canonical = Lhs::Elem>, Lhs::Kind: MatMulAssign<Rhs::Kind>,

fn mul_assign(&mut self, rhs: Matrix<Rhs>)

Performs the *= operation.

impl<Mat: GenericMatrix> Neg for &Matrix<Mat>

where Mat::Elem: Conjugate, <Mat::Elem as Conjugate>::Canonical: ComplexField, Mat::Kind: MatNeg,

type Output = <<<Mat as GenericMatrix>::Kind as MatNeg>::Output as MatrixKind>::Own<<<Mat as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Mat: GenericMatrix> Neg for Matrix<Mat>

where Mat::Elem: Conjugate, <Mat::Elem as Conjugate>::Canonical: ComplexField, Mat::Kind: MatNeg,

type Output = <<<Mat as GenericMatrix>::Kind as MatNeg>::Output as MatrixKind>::Own<<<Mat as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> PartialEq<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatEq<Rhs::Kind>,

fn eq(&self, rhs: &Matrix<Rhs>) -> 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, 'a, E: Entity> Reborrow<'short> for Matrix<DiagMut<'a, E>>

type Target = Matrix<DiagRef<'short, E>>

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

impl<'short, 'a, E: Entity> Reborrow<'short> for Matrix<DiagRef<'a, E>>

type Target = Matrix<DiagRef<'short, E>>

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

impl<'short, 'a, E: Entity> ReborrowMut<'short> for Matrix<DiagMut<'a, E>>

type Target = Matrix<DiagMut<'short, E>>

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

impl<'short, 'a, E: Entity> ReborrowMut<'short> for Matrix<DiagRef<'a, E>>

type Target = Matrix<DiagRef<'short, E>>

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

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Sub<&Matrix<Rhs>> for &Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatSub<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatSub<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix<Rhs>) -> Self::Output

Performs the - operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Sub<&Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatSub<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatSub<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix<Rhs>) -> Self::Output

Performs the - operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Sub<Matrix<Rhs>> for &Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatSub<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatSub<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Rhs>) -> Self::Output

Performs the - operation.

impl<Lhs: GenericMatrix, Rhs: GenericMatrix> Sub<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: Conjugate, Rhs::Elem: Conjugate<Canonical = <Lhs::Elem as Conjugate>::Canonical>, <Lhs::Elem as Conjugate>::Canonical: ComplexField, Lhs::Kind: MatSub<Rhs::Kind>,

type Output = <<<Lhs as GenericMatrix>::Kind as MatSub<<Rhs as GenericMatrix>::Kind>>::Output as MatrixKind>::Own<<<Lhs as GenericMatrix>::Elem as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Rhs>) -> Self::Output

Performs the - operation.

impl<Lhs: GenericMatrixMut, Rhs: GenericMatrix> SubAssign<&Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: ComplexField, Rhs::Elem: Conjugate<Canonical = Lhs::Elem>, Lhs::Kind: MatSubAssign<Rhs::Kind>,

fn sub_assign(&mut self, rhs: &Matrix<Rhs>)

Performs the -= operation.

impl<Lhs: GenericMatrixMut, Rhs: GenericMatrix> SubAssign<Matrix<Rhs>> for Matrix<Lhs>

where Lhs::Elem: ComplexField, Rhs::Elem: Conjugate<Canonical = Lhs::Elem>, Lhs::Kind: MatSubAssign<Rhs::Kind>,

fn sub_assign(&mut self, rhs: Matrix<Rhs>)

Performs the -= operation.

impl<M: Copy> Copy for Matrix<M>