Struct Mat 

pub struct Mat<R> { /* private fields */ }

Implementations

impl<R> Mat<R>

pub fn inner(&self) -> &DMatrix<R>

pub fn inner_mut(&mut self) -> &mut DMatrix<R>

pub fn into_inner(self) -> DMatrix<R>

pub fn iter(&self) -> impl Iterator<Item = (usize, usize, &R)>

impl<R> Mat<R>

where R: Scalar,

pub fn from_data<I>(shape: (usize, usize), data: I) -> Self

where I: IntoIterator<Item = R>,

pub fn zero(shape: (usize, usize)) -> Self

where R: Zero,

pub fn is_zero(&self) -> bool

where R: Zero,

pub fn id(size: usize) -> Self

where R: Zero + One,

pub fn is_id(&self) -> bool

where R: Zero + One,

pub fn diag<I>(shape: (usize, usize), entries: I) -> Self

where R: Zero, I: IntoIterator<Item = R>,

pub fn is_diag(&self) -> bool

where R: Zero,

pub fn submat(&self, rows: Range<usize>, cols: Range<usize>) -> Mat<R>

pub fn submat_rows(&self, rows: Range<usize>) -> Mat<R>

pub fn submat_cols(&self, cols: Range<usize>) -> Mat<R>

pub fn into_sparse(self) -> SpMat<R>

where R: Zero + ClosedAddAssign,

impl<R> Mat<R>

where R: Scalar,

pub fn swap_rows(&mut self, i: usize, j: usize)

pub fn swap_cols(&mut self, i: usize, j: usize)

pub fn mul_row(&mut self, i: usize, r: &R)

where R: ClosedMulAssign,

pub fn mul_col(&mut self, j: usize, r: &R)

where R: ClosedMulAssign,

pub fn add_row_to(&mut self, i: usize, j: usize, r: &R)

where R: ClosedAddAssign + ClosedMulAssign,

pub fn add_col_to(&mut self, i: usize, j: usize, r: &R)

where R: ClosedAddAssign + ClosedMulAssign,

pub fn left_elementary(&mut self, comps: [&R; 4], i: usize, j: usize)

where R: ClosedAddAssign + ClosedMulAssign,

pub fn right_elementary(&mut self, comps: [&R; 4], i: usize, j: usize)

where R: ClosedAddAssign + ClosedMulAssign,

Trait Implementations

impl<R> Add for Mat<R>

where R: Scalar + ClosedAddAssign,

type Output = Mat<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R> Add<&Mat<R>> for &Mat<R>

where R: Scalar + ClosedAddAssign, Mat<R>: Clone,

type Output = Mat<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R> Add<&Mat<R>> for Mat<R>

where R: Scalar + ClosedAddAssign,

type Output = Mat<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R> Add<Mat<R>> for &Mat<R>

where R: Scalar + ClosedAddAssign, Mat<R>: Clone,

type Output = Mat<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R> AddAssign for Mat<R>

where R: Scalar + ClosedAddAssign,

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

Performs the += operation.

impl<R> AddAssign<&Mat<R>> for Mat<R>

where R: Scalar + ClosedAddAssign,

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<R: Clone> Clone for Mat<R>

fn clone(&self) -> Mat<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for Mat<R>

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

Formats the value using the given formatter.

impl<R> Default for Mat<R>

where R: Scalar + Zero,

fn default() -> Self

Returns the “default value” for a type.

impl<R> Display for Mat<R>

where DMatrix<R>: Display,

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

Formats the value using the given formatter.

impl<R: Eq> Eq for Mat<R>

impl<R> From<Mat<R>> for SpMat<R>

where R: Scalar + Zero,

fn from(value: Mat<R>) -> Self

Converts to this type from the input type.

impl<R> From<Matrix<R, Dyn, Dyn, VecStorage<R, Dyn, Dyn>>> for Mat<R>

fn from(inner: DMatrix<R>) -> Self

Converts to this type from the input type.

impl<R> From<SpMat<R>> for Mat<R>

where R: Scalar + Zero + ClosedAddAssign,

fn from(value: SpMat<R>) -> Self

Converts to this type from the input type.

impl<R> Index<(usize, usize)> for Mat<R>

type Output = R

The returned type after indexing.

fn index(&self, index: (usize, usize)) -> &R

Performs the indexing (container[index]) operation.

impl<R> IndexMut<(usize, usize)> for Mat<R>

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

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

impl<R> MatTrait for Mat<R>

fn shape(&self) -> (usize, usize)

fn nrows(&self) -> usize

fn ncols(&self) -> usize

fn is_square(&self) -> bool

impl<'a, 'b, R> Mul for Mat<R>

where R: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

type Output = Mat<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, R> Mul<&'b Mat<R>> for &'a Mat<R>

where R: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

type Output = Mat<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, R> Mul<&'b Mat<R>> for Mat<R>

where R: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

type Output = Mat<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, R> Mul<Mat<R>> for &'a Mat<R>

where R: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

type Output = Mat<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, R> MulAssign for Mat<R>

where R: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

fn mul_assign(&mut self, rhs: Mat<R>)

Performs the *= operation.

impl<'a, 'b, R> MulAssign<&'b Mat<R>> for Mat<R>

where R: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

fn mul_assign(&mut self, rhs: &'b Mat<R>)

Performs the *= operation.

impl<R> Neg for &Mat<R>

where R: Scalar + Neg<Output = R>,

type Output = Mat<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R> Neg for Mat<R>

where R: Scalar + Neg<Output = R>,

type Output = Mat<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: PartialEq> PartialEq for Mat<R>

fn eq(&self, other: &Mat<R>) -> 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<R> StructuralPartialEq for Mat<R>

impl<R> Sub for Mat<R>

where R: Scalar + ClosedSubAssign,

type Output = Mat<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R> Sub<&Mat<R>> for &Mat<R>

where R: Scalar + ClosedSubAssign, Mat<R>: Clone,

type Output = Mat<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R> Sub<&Mat<R>> for Mat<R>

where R: Scalar + ClosedSubAssign,

type Output = Mat<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R> Sub<Mat<R>> for &Mat<R>

where R: Scalar + ClosedSubAssign, Mat<R>: Clone,

type Output = Mat<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R> SubAssign for Mat<R>

where R: Scalar + ClosedSubAssign,

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

Performs the -= operation.

impl<R> SubAssign<&Mat<R>> for Mat<R>

where R: Scalar + ClosedSubAssign,

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.