Type Alias SparseRowMat 

pub type SparseRowMat<I, T, Rows = usize, Cols = usize> = SparseRowMat<Own<I, T, Rows, Cols>>;

owning sparse row major matrix

see SymbolicSparseRowMatRef

Aliased Type

#[repr(transparent)]
pub struct SparseRowMat<I, T, Rows = usize, Cols = usize>(/* private fields */);

Implementations

impl<Rows: Shape, Cols: Shape, I: Index, T> SparseRowMat<I, T, Rows, Cols>

pub fn new(symbolic: SymbolicSparseRowMat<I, Rows, Cols>, val: Vec<T>) -> Self

see [SparseRowMatRef::new]

pub fn parts(&self) -> (SymbolicSparseRowMatRef<'_, I, Rows, Cols>, &[T])

see [SparseRowMatRef::parts]

pub fn parts_mut( &mut self, ) -> (SymbolicSparseRowMatRef<'_, I, Rows, Cols>, &mut [T])

see [SparseRowMatRef::parts]

pub fn into_parts(self) -> (SymbolicSparseRowMat<I, Rows, Cols>, Vec<T>)

see [SparseRowMatRef::parts]

pub fn symbolic(&self) -> SymbolicSparseRowMatRef<'_, I, Rows, Cols>

see [SparseRowMatRef::symbolic]

pub fn val(&self) -> &[T]

see [SparseRowMatRef::val]

pub fn val_mut(&mut self) -> &mut [T]

see [SparseRowMatRef::val]

pub fn val_of_row(&self, j: Idx<Rows>) -> &[T]

see [SparseRowMatRef::val_of_row]

pub fn val_of_row_mut(&mut self, j: Idx<Rows>) -> &mut [T]

see [SparseRowMatRef::val_of_row]

pub fn as_shape<V: Shape, H: Shape>( &self, nrows: V, ncols: H, ) -> SparseRowMatRef<'_, I, T, V, H>

see [SparseRowMatRef::as_shape]

pub fn as_shape_mut<V: Shape, H: Shape>( &mut self, nrows: V, ncols: H, ) -> SparseRowMatMut<'_, I, T, V, H>

see [SparseRowMatRef::as_shape]

pub fn into_shape<V: Shape, H: Shape>( self, nrows: V, ncols: H, ) -> SparseRowMat<I, T, V, H>

see [SparseRowMatRef::as_shape]

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

see [SparseRowMatRef::as_dyn]

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

see [SparseRowMatRef::as_dyn]

pub fn into_dyn(self) -> SparseRowMat<I, T>

see [SparseRowMatRef::as_dyn]

pub fn as_ref(&self) -> SparseRowMatRef<'_, I, T, Rows, Cols>

see [SparseRowMatRef::as_ref]

pub fn transpose(&self) -> SparseColMatRef<'_, I, T, Cols, Rows>

see [SparseRowMatRef::transpose]

pub fn transpose_mut(&mut self) -> SparseColMatMut<'_, I, T, Cols, Rows>

see [SparseRowMatRef::transpose]

pub fn into_transpose(self) -> SparseColMat<I, T, Cols, Rows>

see [SparseRowMatRef::transpose]

pub fn conjugate(&self) -> SparseRowMatRef<'_, I, T::Conj, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::conjugate]

pub fn conjugate_mut(&mut self) -> SparseRowMatMut<'_, I, T::Conj, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::conjugate]

pub fn into_conjugate(self) -> SparseRowMat<I, T::Conj, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::conjugate]

pub fn adjoint(&self) -> SparseColMatRef<'_, I, T::Conj, Cols, Rows>

where T: Conjugate,

see [SparseRowMatRef::adjoint]

pub fn adjoint_mut(&mut self) -> SparseColMatMut<'_, I, T::Conj, Cols, Rows>

where T: Conjugate,

see [SparseRowMatRef::adjoint]

pub fn into_adjoint(self) -> SparseColMat<I, T::Conj, Cols, Rows>

where T: Conjugate,

see [SparseRowMatRef::adjoint]

pub fn canonical(&self) -> SparseRowMatRef<'_, I, T::Canonical, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::canonical]

pub fn canonical_mut( &mut self, ) -> SparseRowMatMut<'_, I, T::Canonical, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::canonical]

pub fn into_canonical(self) -> SparseRowMat<I, T::Canonical, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::canonical]

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

where T: Conjugate,

see [SparseRowMatRef::to_col_major]

pub fn to_dense(&self) -> Mat<T::Canonical, Rows, Cols>

where T: Conjugate,

see [SparseRowMatRef::to_dense]

pub fn new_from_argsort( symbolic: SymbolicSparseRowMat<I, Rows, Cols>, argsort: &Argsort<I>, val: &[T], ) -> Result<Self, FaerError>

where T: ComplexField,

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: Rows, ncols: Cols, entries: &[Triplet<Idx<Rows, I>, Idx<Cols, I>, T>], ) -> Result<Self, CreationError>

where T: ComplexField,

create a new matrix from triplets

pub fn try_new_from_nonnegative_triplets( nrows: Rows, ncols: Cols, entries: &[Triplet<MaybeIdx<Rows, I>, MaybeIdx<Cols, I>, T>], ) -> Result<Self, CreationError>

where T: ComplexField,

create a new matrix from triplets

negative indices are ignored

pub fn get(&self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&T>

see [SparseRowMatRef::get]

pub fn get_mut(&mut self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&mut T>

see [SparseRowMatRef::get]

pub fn triplet_iter( &self, ) -> impl '_ + Iterator<Item = Triplet<Idx<Rows>, Idx<Cols>, &T>>

see [SparseRowMatRef::triplet_iter]

Trait Implementations

impl<I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>> BiLinOp<T> for SparseRowMat<I, ViewT>

fn transpose_apply_scratch(&self, rhs_ncols: usize, par: ParShape) -> StackReq

computes the workspace layout required to apply the transpose or adjoint o self to a matrix with rhs_ncols columns

fn transpose_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in out

fn adjoint_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in out

impl<I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>> BiPrecond<T> for SparseRowMat<I, ViewT>

fn transpose_apply_in_place_scratch( &self, rhs_ncols: usize, par: ParShape, ) -> StackReq

computes the workspace layout required to apply the transpose or adjoint of self to a matrix with rhs_ncols columns in place

fn transpose_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in rhs

fn adjoint_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in rhs

impl<Rows: Shape, Cols: Shape, I: Index, T: Debug> Debug for SparseRowMat<I, T, Rows, Cols>

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

Formats the value using the given formatter.

impl<Rows: Shape, Cols: Shape, I: Index, T> Deref for SparseRowMat<I, T, Rows, Cols>

type Target = SymbolicSparseRowMat<Own<I, Rows, Cols>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<I: Index, T> Index<(usize, usize)> for SparseRowMat<I, T>

type Output = T

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I: Index, T> IndexMut<(usize, usize)> for SparseRowMat<I, T>

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut Self::Output

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

impl<I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>> LinOp<T> for SparseRowMat<I, ViewT>

fn nrows(&self) -> usize

output dimension of the operator

fn ncols(&self) -> usize

input dimension of the operator

fn apply_scratch(&self, rhs_ncols: usize, par: ParShape) -> StackReq

computes the workspace layout required to apply self or the conjugate o self to a matrix with rhs_ncols columns

fn apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies self to rhs, and stores the result in out

fn conj_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in out

impl<I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>> Precond<T> for SparseRowMat<I, ViewT>

fn apply_in_place_scratch(&self, rhs_ncols: usize, par: ParShape) -> StackReq

computes the workspace layout required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place

fn apply_in_place(&self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack)

applies self to rhs, and stores the result in rhs

fn conj_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in rhs