nyx_space::linalg

Type Alias Matrix6xX

Source
pub type Matrix6xX<T> = Matrix<T, Const<6>, Dyn, VecStorage<T, Const<6>, Dyn>>;
Expand description

A heap-allocated, column-major, matrix with 6 rows and a dynamic number of columns.

Because this is an alias, not all its methods are listed here. See the Matrix type too.

Aliased Type§

struct Matrix6xX<T> {
    pub data: VecStorage<T, Const<6>, Dyn>,
    /* private fields */
}

Fields§

§data: VecStorage<T, Const<6>, Dyn>

The data storage that contains all the matrix components. Disappointed?

Well, if you came here to see how you can access the matrix components, you may be in luck: you can access the individual components of all vectors with compile-time dimensions <= 6 using field notation like this: vec.x, vec.y, vec.z, vec.w, vec.a, vec.b. Reference and assignation work too:

let mut vec = Vector3::new(1.0, 2.0, 3.0);
vec.x = 10.0;
vec.y += 30.0;
assert_eq!(vec.x, 10.0);
assert_eq!(vec.y + 100.0, 132.0);

Similarly, for matrices with compile-time dimensions <= 6, you can use field notation like this: mat.m11, mat.m42, etc. The first digit identifies the row to address and the second digit identifies the column to address. So mat.m13 identifies the component at the first row and third column (note that the count of rows and columns start at 1 instead of 0 here. This is so we match the mathematical notation).

For all matrices and vectors, independently from their size, individual components can be accessed and modified using indexing: vec[20], mat[(20, 19)]. Here the indexing starts at 0 as you would expect.

Implementations

Source§

impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>
where T: Scalar, R: Dim, C: Dim, DefaultAllocator: Allocator<R, C>,

Source

pub fn uninit( nrows: R, ncols: C, ) -> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>

Builds a matrix with uninitialized elements of type MaybeUninit<T>.

Source§

impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>
where T: Scalar, R: Dim, C: Dim, DefaultAllocator: Allocator<R, C>,

Source

pub unsafe fn assume_init( self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Assumes a matrix’s entries to be initialized. This operation should be near zero-cost.

§Safety

The user must make sure that every single entry of the buffer has been initialized, or Undefined Behavior will immediately occur.

Source§

impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimName, T: Scalar + Zero + One, DefaultAllocator: Allocator<D, D>,

§Translation and scaling in any dimension

Source

pub fn new_scaling( scaling: T, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

Creates a new homogeneous matrix that applies the same scaling factor on each dimension.

Source

pub fn new_nonuniform_scaling<SB>( scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

Creates a new homogeneous matrix that applies a distinct scaling factor for each dimension.

Source

pub fn new_translation<SB>( translation: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

Creates a new homogeneous matrix that applies a pure translation.

Source§

impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: Dim, T: Scalar, DefaultAllocator: Allocator<D, D>,

Source

pub fn from_diagonal<SB>( diag: &Matrix<T, D, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where SB: RawStorage<T, D>, T: Zero,

Creates a square matrix with its diagonal set to diag and all other entries set to 0.

§Example

let m = Matrix3::from_diagonal(&Vector3::new(1.0, 2.0, 3.0));
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal(&DVector::from_row_slice(&[1.0, 2.0, 3.0]));

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 3.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 3.0);
Source§

impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where T: ComplexField, D: DimMin<D, Output = D>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimMin<D>>::Output> + Allocator<D>,

Source

pub fn exp( &self, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

Computes exponential of this matrix

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, D: DimName, S: Storage<T, D, D>,

§Append/prepend translation and scaling

Source

pub fn append_scaling( &self, scaling: T, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

Computes the transformation equal to self followed by an uniform scaling factor.

Source

pub fn prepend_scaling( &self, scaling: T, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

Computes the transformation equal to an uniform scaling factor followed by self.

Source

pub fn append_nonuniform_scaling<SB>( &self, scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<D, D>,

Computes the transformation equal to self followed by a non-uniform scaling factor.

Source

pub fn prepend_nonuniform_scaling<SB>( &self, scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<D, D>,

Computes the transformation equal to a non-uniform scaling factor followed by self.

Source

pub fn append_translation<SB>( &self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<D, D>,

Computes the transformation equal to self followed by a translation.

Source

pub fn prepend_translation<SB>( &self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimNameSub<Const<1>>>::Output>,

Computes the transformation equal to a translation followed by self.

Source

pub fn append_scaling_mut(&mut self, scaling: T)
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>,

Computes in-place the transformation equal to self followed by an uniform scaling factor.

Source

pub fn prepend_scaling_mut(&mut self, scaling: T)
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>,

Computes in-place the transformation equal to an uniform scaling factor followed by self.

Source

pub fn append_nonuniform_scaling_mut<SB>( &mut self, scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

Computes in-place the transformation equal to self followed by a non-uniform scaling factor.

Source

pub fn prepend_nonuniform_scaling_mut<SB>( &mut self, scaling: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

Computes in-place the transformation equal to a non-uniform scaling factor followed by self.

Source

pub fn append_translation_mut<SB>( &mut self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where S: StorageMut<T, D, D>, D: DimNameSub<Const<1>>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>,

Computes the transformation equal to self followed by a translation.

Source

pub fn prepend_translation_mut<SB>( &mut self, shift: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, SB>, )
where D: DimNameSub<Const<1>>, S: StorageMut<T, D, D>, SB: Storage<T, <D as DimNameSub<Const<1>>>::Output>, DefaultAllocator: Allocator<<D as DimNameSub<Const<1>>>::Output>,

Computes the transformation equal to a translation followed by self.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: RealField, D: DimNameSub<Const<1>>, S: Storage<T, D, D>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimNameSub<Const<1>>>::Output> + Allocator<<D as DimNameSub<Const<1>>>::Output, <D as DimNameSub<Const<1>>>::Output>,

§Transformation of vectors and points

Source

pub fn transform_vector( &self, v: &Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<<D as DimNameSub<Const<1>>>::Output>>::Buffer<T>>, ) -> Matrix<T, <D as DimNameSub<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<<D as DimNameSub<Const<1>>>::Output>>::Buffer<T>>

Transforms the given vector, assuming the matrix self uses homogeneous coordinates.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar, D: Dim, S: RawStorageMut<T, D, D>,

Source

pub fn fill_lower_triangle_with_upper_triangle(&mut self)

Copies the upper-triangle of this matrix to its lower-triangular part.

This makes the matrix symmetric. Panics if the matrix is not square.

Source

pub fn fill_upper_triangle_with_lower_triangle(&mut self)

Copies the upper-triangle of this matrix to its upper-triangular part.

This makes the matrix symmetric. Panics if the matrix is not square.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar, D: Dim, S: RawStorageMut<T, D, D>,

Source

pub fn transpose_mut(&mut self)

Transposes the square matrix self in-place.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: SimdComplexField, D: Dim, S: RawStorageMut<T, D, D>,

Source

pub fn conjugate_transform_mut(&mut self)

👎Deprecated: Renamed to self.adjoint_mut().

Sets self to its adjoint.

Source

pub fn adjoint_mut(&mut self)

Sets self to its adjoint (aka. conjugate-transpose).

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar, D: Dim, S: RawStorage<T, D, D>,

Source

pub fn diagonal( &self, ) -> Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>

The diagonal of this matrix.

Source

pub fn map_diagonal<T2>( &self, f: impl FnMut(T) -> T2, ) -> Matrix<T2, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T2>>

Apply the given function to this matrix’s diagonal and returns it.

This is a more efficient version of self.diagonal().map(f) since this allocates only once.

Source

pub fn trace(&self) -> T
where T: Scalar + Zero + ClosedAddAssign,

Computes a trace of a square matrix, i.e., the sum of its diagonal elements.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: SimdComplexField, D: Dim, S: Storage<T, D, D>,

Source

pub fn symmetric_part( &self, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

The symmetric part of self, i.e., 0.5 * (self + self.transpose()).

Source

pub fn hermitian_part( &self, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

The hermitian part of self, i.e., 0.5 * (self + self.adjoint()).

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar + Zero + One, D: DimAdd<Const<1>> + IsNotStaticOne, S: RawStorage<T, D, D>,

Source

pub fn to_homogeneous( &self, ) -> Matrix<T, <D as DimAdd<Const<1>>>::Output, <D as DimAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<D as DimAdd<Const<1>>>::Output, <D as DimAdd<Const<1>>>::Output>>::Buffer<T>>
where DefaultAllocator: Allocator<<D as DimAdd<Const<1>>>::Output, <D as DimAdd<Const<1>>>::Output>,

Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and and setting the diagonal element to 1.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: RealField, D: Dim, S: Storage<T, D, D>, DefaultAllocator: Allocator<D, D>,

Source

pub fn is_special_orthogonal(&self, eps: T) -> bool
where D: DimMin<D, Output = D>, DefaultAllocator: Allocator<D>,

Checks that this matrix is orthogonal and has a determinant equal to 1.

Source

pub fn is_invertible(&self) -> bool

Returns true if this matrix is invertible.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: Dim, S: Storage<T, D, D>,

§Square matrix decomposition

This section contains the methods for computing some common decompositions of square matrices with real or complex components. The following are currently supported:

DecompositionFactorsDetails
HessenbergQ * H * QᵀQ is a unitary matrix and H an upper-Hessenberg matrix.
CholeskyL * LᵀL is a lower-triangular matrix.
UDUU * D * UᵀU is a upper-triangular matrix, and D a diagonal matrix.
Schur decompositionQ * T * QᵀQ is an unitary matrix and T a quasi-upper-triangular matrix.
Symmetric eigendecompositionQ ~ Λ ~ QᵀQ is an unitary matrix, and Λ is a real diagonal matrix.
Symmetric tridiagonalizationQ ~ T ~ QᵀQ is an unitary matrix, and T is a tridiagonal matrix.
Source

pub fn cholesky(self) -> Option<Cholesky<T, D>>

Attempts to compute the Cholesky decomposition of this matrix.

Returns None if the input matrix is not definite-positive. The input matrix is assumed to be symmetric and only the lower-triangular part is read.

Source

pub fn udu(self) -> Option<UDU<T, D>>
where T: RealField, DefaultAllocator: Allocator<D> + Allocator<D, D>,

Attempts to compute the UDU decomposition of this matrix.

The input matrix self is assumed to be symmetric and this decomposition will only read the upper-triangular part of self.

Source

pub fn hessenberg(self) -> Hessenberg<T, D>
where D: DimSub<Const<1>>, DefaultAllocator: Allocator<D, D> + Allocator<D> + Allocator<<D as DimSub<Const<1>>>::Output>,

Computes the Hessenberg decomposition of this matrix using householder reflections.

Source

pub fn schur(self) -> Schur<T, D>
where D: DimSub<Const<1>>, DefaultAllocator: Allocator<D, <D as DimSub<Const<1>>>::Output> + Allocator<<D as DimSub<Const<1>>>::Output> + Allocator<D, D> + Allocator<D>,

Computes the Schur decomposition of a square matrix.

Source

pub fn try_schur( self, eps: <T as ComplexField>::RealField, max_niter: usize, ) -> Option<Schur<T, D>>
where D: DimSub<Const<1>>, DefaultAllocator: Allocator<D, <D as DimSub<Const<1>>>::Output> + Allocator<<D as DimSub<Const<1>>>::Output> + Allocator<D, D> + Allocator<D>,

Attempts to compute the Schur decomposition of a square matrix.

If only eigenvalues are needed, it is more efficient to call the matrix method .eigenvalues() instead.

§Arguments
  • eps − tolerance used to determine when a value converged to 0.
  • max_niter − maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded, None is returned. If niter == 0, then the algorithm continues indefinitely until convergence.
Source

pub fn symmetric_eigen(self) -> SymmetricEigen<T, D>
where D: DimSub<Const<1>>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimSub<Const<1>>>::Output> + Allocator<D>,

Computes the eigendecomposition of this symmetric matrix.

Only the lower-triangular part (including the diagonal) of m is read.

Source

pub fn try_symmetric_eigen( self, eps: <T as ComplexField>::RealField, max_niter: usize, ) -> Option<SymmetricEigen<T, D>>
where D: DimSub<Const<1>>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimSub<Const<1>>>::Output> + Allocator<D>,

Computes the eigendecomposition of the given symmetric matrix with user-specified convergence parameters.

Only the lower-triangular part (including the diagonal) of m is read.

§Arguments
  • eps − tolerance used to determine when a value converged to 0.
  • max_niter − maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded, None is returned. If niter == 0, then the algorithm continues indefinitely until convergence.
Source

pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D>
where D: DimSub<Const<1>>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimSub<Const<1>>>::Output>,

Computes the tridiagonalization of this symmetric matrix.

Only the lower-triangular part (including the diagonal) of m is read.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: DimMin<D, Output = D>, S: Storage<T, D, D>,

Source

pub fn determinant(&self) -> T

Computes the matrix determinant.

If the matrix has a dimension larger than 3, an LU decomposition is used.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: Dim, S: Storage<T, D, D>,

Source

pub fn try_inverse( self, ) -> Option<Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>>

Attempts to invert this square matrix.

§Panics

Panics if self isn’t a square matrix.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: Dim, S: StorageMut<T, D, D>,

Source

pub fn try_inverse_mut(&mut self) -> bool

Attempts to invert this square matrix in-place. Returns false and leaves self untouched if inversion fails.

§Panics

Panics if self isn’t a square matrix.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, D: DimMin<D, Output = D>, S: StorageMut<T, D, D>, DefaultAllocator: Allocator<D, D> + Allocator<D>,

Source

pub fn pow_mut(&mut self, exp: u32)

Raises this matrix to an integral power exp in-place.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where S: Storage<T, D, D> + StorageMut<T, D, D>, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, D: DimMin<D, Output = D>, DefaultAllocator: Allocator<D, D> + Allocator<D>,

Source

pub fn pow( &self, exp: u32, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

Raise this matrix to an integral power exp.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: Dim + DimSub<Const<1>>, S: Storage<T, D, D>, DefaultAllocator: Allocator<D, <D as DimSub<Const<1>>>::Output> + Allocator<<D as DimSub<Const<1>>>::Output> + Allocator<D, D> + Allocator<D>,

Source

pub fn eigenvalues( &self, ) -> Option<Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>>

Computes the eigenvalues of this matrix.

Source

pub fn complex_eigenvalues( &self, ) -> Matrix<Complex<T>, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<Complex<T>>>
where T: RealField, DefaultAllocator: Allocator<D>,

Computes the eigenvalues of this matrix.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: Dim, S: Storage<T, D, D>,

Source

pub fn solve_lower_triangular<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn solve_upper_triangular<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn solve_lower_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn solve_lower_triangular_with_diag_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, diag: T, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self . x = b where x is the unknown and only the lower-triangular part of self is considered not-zero. The diagonal is never read as it is assumed to be equal to diag. Returns false and does not modify its inputs if diag is zero.

Source

pub fn solve_upper_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_lower_triangular<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.transpose() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_upper_triangular<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.transpose() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_lower_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.transpose() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_upper_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.transpose() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_lower_triangular<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.adjoint() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_upper_triangular<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.adjoint() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_lower_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.adjoint() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_upper_triangular_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.adjoint() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: SimdComplexField, D: Dim, S: Storage<T, D, D>,

Source

pub fn solve_lower_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn solve_upper_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn solve_lower_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn solve_lower_triangular_with_diag_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, diag: T, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self . x = b where x is the unknown and only the lower-triangular part of self is considered not-zero. The diagonal is never read as it is assumed to be equal to diag. Returns false and does not modify its inputs if diag is zero.

Source

pub fn solve_upper_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_lower_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.transpose() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_upper_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.transpose() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_lower_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.transpose() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn tr_solve_upper_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.transpose() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_lower_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.adjoint() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_upper_triangular_unchecked<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, DefaultAllocator: Allocator<R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Computes the solution of the linear system self.adjoint() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_lower_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.adjoint() . x = b where x is the unknown and only the lower-triangular part of self (including the diagonal) is considered not-zero.

Source

pub fn ad_solve_upper_triangular_unchecked_mut<R2, C2, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, )
where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self.adjoint() . x = b where x is the unknown and only the upper-triangular part of self (including the diagonal) is considered not-zero.

Source§

impl<T, D, S> Matrix<T, D, D, S>
where T: ComplexField, D: DimSub<Const<1>>, S: Storage<T, D, D>, DefaultAllocator: Allocator<D, D> + Allocator<<D as DimSub<Const<1>>>::Output> + Allocator<D>,

Source

pub fn symmetric_eigenvalues( &self, ) -> Matrix<<T as ComplexField>::RealField, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<<T as ComplexField>::RealField>>

Computes the eigenvalues of this symmetric matrix.

Only the lower-triangular part of the matrix is read.

Source§

impl<T, D1, S> Matrix<T, D1, D1, S>
where D1: Dim, S: StorageMut<T, D1, D1>, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,

Source

pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>( &mut self, work: &mut Matrix<T, D2, Const<1>, S2>, alpha: T, lhs: &Matrix<T, R3, C3, S3>, mid: &Matrix<T, D4, D4, S4>, beta: T, )
where D2: Dim, R3: Dim, C3: Dim, D4: Dim, S2: StorageMut<T, D2>, S3: Storage<T, R3, C3>, S4: Storage<T, D4, D4>, ShapeConstraint: DimEq<D1, D2> + DimEq<D1, R3> + DimEq<D2, R3> + DimEq<C3, D4>,

Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self.

This uses the provided workspace work to avoid allocations for intermediate results.

§Example
// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let lhs = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0,
                                          4.0, 5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
                                          0.5, 0.6, 0.7,
                                          0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(2);
let expected = &lhs * &mid * lhs.transpose() * 10.0 + &mat * 5.0;

mat.quadform_tr_with_workspace(&mut workspace, 10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);
Source

pub fn quadform_tr<R3, C3, S3, D4, S4>( &mut self, alpha: T, lhs: &Matrix<T, R3, C3, S3>, mid: &Matrix<T, D4, D4, S4>, beta: T, )
where R3: Dim, C3: Dim, D4: Dim, S3: Storage<T, R3, C3>, S4: Storage<T, D4, D4>, ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>, DefaultAllocator: Allocator<D1>,

Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self.

This allocates a workspace vector of dimension D1 for intermediate results. If D1 is a type-level integer, then the allocation is performed on the stack. Use .quadform_tr_with_workspace(...) instead to avoid allocations.

§Example
let mut mat = Matrix2::identity();
let lhs = Matrix2x3::new(1.0, 2.0, 3.0,
                         4.0, 5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
                       0.5, 0.6, 0.7,
                       0.9, 1.0, 1.1);
let expected = lhs * mid * lhs.transpose() * 10.0 + mat * 5.0;

mat.quadform_tr(10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);
Source

pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>( &mut self, work: &mut Matrix<T, D2, Const<1>, S2>, alpha: T, mid: &Matrix<T, D3, D3, S3>, rhs: &Matrix<T, R4, C4, S4>, beta: T, )
where D2: Dim, D3: Dim, R4: Dim, C4: Dim, S2: StorageMut<T, D2>, S3: Storage<T, D3, D3>, S4: Storage<T, R4, C4>, ShapeConstraint: DimEq<D3, R4> + DimEq<D1, C4> + DimEq<D2, D3> + AreMultipliable<C4, R4, D2, Const<1>>,

Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self.

This uses the provided workspace work to avoid allocations for intermediate results.

§Example
// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let rhs = DMatrix::from_row_slice(3, 2, &[1.0, 2.0,
                                          3.0, 4.0,
                                          5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
                                          0.5, 0.6, 0.7,
                                          0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(3);
let expected = rhs.transpose() * &mid * &rhs * 10.0 + &mat * 5.0;

mat.quadform_with_workspace(&mut workspace, 10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);
Source

pub fn quadform<D2, S2, R3, C3, S3>( &mut self, alpha: T, mid: &Matrix<T, D2, D2, S2>, rhs: &Matrix<T, R3, C3, S3>, beta: T, )
where D2: Dim, R3: Dim, C3: Dim, S2: Storage<T, D2, D2>, S3: Storage<T, R3, C3>, ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, Const<1>>, DefaultAllocator: Allocator<D2>,

Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self.

This allocates a workspace vector of dimension D2 for intermediate results. If D2 is a type-level integer, then the allocation is performed on the stack. Use .quadform_with_workspace(...) instead to avoid allocations.

§Example
let mut mat = Matrix2::identity();
let rhs = Matrix3x2::new(1.0, 2.0,
                         3.0, 4.0,
                         5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
                       0.5, 0.6, 0.7,
                       0.9, 1.0, 1.1);
let expected = rhs.transpose() * mid * rhs * 10.0 + mat * 5.0;

mat.quadform(10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);
Source§

impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, R: Dim, C: Dim, DefaultAllocator: Allocator<R, C>,

§Generic constructors

This set of matrix and vector construction functions are all generic with-regard to the matrix dimensions. They all expect to be given the dimension as inputs.

These functions should only be used when working on dimension-generic code.

Source

pub fn from_element_generic( nrows: R, ncols: C, elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with all its elements set to elem.

Source

pub fn repeat_generic( nrows: R, ncols: C, elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with all its elements set to elem.

Same as from_element_generic.

Source

pub fn zeros_generic( nrows: R, ncols: C, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero,

Creates a matrix with all its elements set to 0.

Source

pub fn from_iterator_generic<I>( nrows: R, ncols: C, iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix with all its elements filled by an iterator.

Source

pub fn from_row_iterator_generic<I>( nrows: R, ncols: C, iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix with all its elements filled by an row-major order iterator.

Source

pub fn from_row_slice_generic( nrows: R, ncols: C, slice: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

Source

pub fn from_column_slice_generic( nrows: R, ncols: C, slice: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with its elements filled with the components provided by a slice. The components must have the same layout as the matrix data storage (i.e. column-major).

Source

pub fn from_fn_generic<F>( nrows: R, ncols: C, f: F, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

Creates a matrix filled with the results of a function applied to each of its component coordinates.

Source

pub fn identity_generic( nrows: R, ncols: C, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero + One,

Creates a new identity matrix.

If the matrix is not square, the largest square submatrix starting at index (0, 0) is set to the identity matrix. All other entries are set to zero.

Source

pub fn from_diagonal_element_generic( nrows: R, ncols: C, elt: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero + One,

Creates a new matrix with its diagonal filled with copies of elt.

If the matrix is not square, the largest square submatrix starting at index (0, 0) is set to the identity matrix. All other entries are set to zero.

Source

pub fn from_partial_diagonal_generic( nrows: R, ncols: C, elts: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero,

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

Source

pub fn from_rows<SB>( rows: &[Matrix<T, Const<1>, C, SB>], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where SB: RawStorage<T, Const<1>, C>,

Builds a new matrix from its rows.

Panics if not enough rows are provided (for statically-sized matrices), or if all rows do not have the same dimensions.

§Example

let m = Matrix3::from_rows(&[ RowVector3::new(1.0, 2.0, 3.0),  RowVector3::new(4.0, 5.0, 6.0),  RowVector3::new(7.0, 8.0, 9.0) ]);

assert!(m.m11 == 1.0 && m.m12 == 2.0 && m.m13 == 3.0 &&
        m.m21 == 4.0 && m.m22 == 5.0 && m.m23 == 6.0 &&
        m.m31 == 7.0 && m.m32 == 8.0 && m.m33 == 9.0);
Source

pub fn from_columns<SB>( columns: &[Matrix<T, R, Const<1>, SB>], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where SB: RawStorage<T, R>,

Builds a new matrix from its columns.

Panics if not enough columns are provided (for statically-sized matrices), or if all columns do not have the same dimensions.

§Example

let m = Matrix3::from_columns(&[ Vector3::new(1.0, 2.0, 3.0),  Vector3::new(4.0, 5.0, 6.0),  Vector3::new(7.0, 8.0, 9.0) ]);

assert!(m.m11 == 1.0 && m.m12 == 4.0 && m.m13 == 7.0 &&
        m.m21 == 2.0 && m.m22 == 5.0 && m.m23 == 8.0 &&
        m.m31 == 3.0 && m.m32 == 6.0 && m.m33 == 9.0);
Source

pub fn from_vec_generic( nrows: R, ncols: C, data: Vec<T>, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

§Example

let vec = vec![0, 1, 2, 3, 4, 5];
let vec_ptr = vec.as_ptr();

let matrix = Matrix::from_vec_generic(Dyn(vec.len()), Const::<1>, vec);
let matrix_storage_ptr = matrix.data.as_vec().as_ptr();

// `matrix` is backed by exactly the same `Vec` as it was constructed from.
assert_eq!(matrix_storage_ptr, vec_ptr);
Source§

impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, R: DimName, C: DimName, DefaultAllocator: Allocator<R, C>,

§Constructors of statically-sized vectors or statically-sized matrices

Source

pub fn from_element( elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix or vector with all its elements set to elem.

§Example

let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Source

pub fn repeat( elem: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix or vector with all its elements set to elem.

Same as .from_element.

§Example

let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Source

pub fn zeros() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero,

Creates a matrix or vector with all its elements set to 0.

§Example

let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);

assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
Source

pub fn from_iterator<I>( iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by an iterator.

The output matrix is filled column-by-column.

§Example

let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Source

pub fn from_row_iterator<I>( iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by a row-major iterator.

The output matrix is filled row-by-row.

§Example

let v = Vector3::from_row_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_row_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_row_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_iterator(2, 3, (0..6).into_iter());

// For Vectors from_row_iterator is identical to from_iterator
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Source

pub fn from_fn<F>( f: F, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.

§Example

let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Source

pub fn identity() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero + One,

Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.

§Example

let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
Source

pub fn from_diagonal_element( elt: T, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero + One,

Creates a matrix filled with its diagonal filled with elt and all other components set to zero.

§Example

let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);

assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
Source

pub fn from_partial_diagonal( elts: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Zero,

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

§Example

let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
Source§

impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, R: DimName, C: DimName, DefaultAllocator: Allocator<R, C>,

Source

pub fn from_row_slice( data: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

§Example

let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(&[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Source

pub fn from_column_slice( data: &[T], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix with its elements filled with the components provided by a slice in column-major order.

§Example

let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(&[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Source

pub fn from_vec( data: Vec<T>, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

§Example

let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);

assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);


// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);

assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

§Dot/scalar product

Source

pub fn dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

The dot product between two vectors or matrices (seen as vectors).

This is equal to self.transpose() * rhs. For the sesquilinear complex dot product, use self.dotc(rhs).

Note that this is not the matrix multiplication as in, e.g., numpy. For matrix multiplication, use one of: .gemm, .mul_to, .mul, the * operator.

§Example
let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.dot(&vec2), 1.4);

let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
                          4.0, 5.0, 6.0);
let mat2 = Matrix2x3::new(0.1, 0.2, 0.3,
                          0.4, 0.5, 0.6);
assert_eq!(mat1.dot(&mat2), 9.1);
Source

pub fn dotc<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, T: SimdComplexField, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

The conjugate-linear dot product between two vectors or matrices (seen as vectors).

This is equal to self.adjoint() * rhs. For real vectors, this is identical to self.dot(&rhs). Note that this is not the matrix multiplication as in, e.g., numpy. For matrix multiplication, use one of: .gemm, .mul_to, .mul, the * operator.

§Example
let vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.4, 0.3), Complex::new(0.2, 0.1));
assert_eq!(vec1.dotc(&vec2), Complex::new(2.0, -1.0));

// Note that for complex vectors, we generally have:
// vec1.dotc(&vec2) != vec2.dot(&vec2)
assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2));
Source

pub fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,

The dot product between the transpose of self and rhs.

§Example
let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = RowVector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.tr_dot(&vec2), 1.4);

let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
                          4.0, 5.0, 6.0);
let mat2 = Matrix3x2::new(0.1, 0.4,
                          0.2, 0.5,
                          0.3, 0.6);
assert_eq!(mat1.tr_dot(&mat2), 9.1);
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>,

Source

pub fn abs( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Computes the component-wise absolute value.

§Example
let a = Matrix2::new(0.0, 1.0,
                     -2.0, -3.0);
assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0))
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

§Set rows, columns, and diagonal

Source

pub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<T, R2, Const<1>, S2>)
where R2: Dim, R: DimMin<C>, S2: RawStorage<T, R2>, ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,

Fills the diagonal of this matrix with the content of the given vector.

Source

pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = T>)

Fills the diagonal of this matrix with the content of the given iterator.

This will fill as many diagonal elements as the iterator yields, up to the minimum of the number of rows and columns of self, and starting with the diagonal element at index (0, 0).

Source

pub fn set_row<C2, S2>(&mut self, i: usize, row: &Matrix<T, Const<1>, C2, S2>)
where C2: Dim, S2: RawStorage<T, Const<1>, C2>, ShapeConstraint: SameNumberOfColumns<C, C2>,

Fills the selected row of this matrix with the content of the given vector.

Source

pub fn set_column<R2, S2>( &mut self, i: usize, column: &Matrix<T, R2, Const<1>, S2>, )
where R2: Dim, S2: RawStorage<T, R2>, ShapeConstraint: SameNumberOfRows<R, R2>,

Fills the selected column of this matrix with the content of the given vector.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

§In-place filling

Source

pub fn fill_with(&mut self, val: impl Fn() -> T)

Sets all the elements of this matrix to the value returned by the closure.

Source

pub fn fill(&mut self, val: T)
where T: Scalar,

Sets all the elements of this matrix to val.

Source

pub fn fill_with_identity(&mut self)
where T: Scalar + Zero + One,

Fills self with the identity matrix.

Source

pub fn fill_diagonal(&mut self, val: T)
where T: Scalar,

Sets all the diagonal elements of this matrix to val.

Source

pub fn fill_row(&mut self, i: usize, val: T)
where T: Scalar,

Sets all the elements of the selected row to val.

Source

pub fn fill_column(&mut self, j: usize, val: T)
where T: Scalar,

Sets all the elements of the selected column to val.

Source

pub fn fill_lower_triangle(&mut self, val: T, shift: usize)
where T: Scalar,

Sets all the elements of the lower-triangular part of this matrix to val.

The parameter shift allows some subdiagonals to be left untouched:

  • If shift = 0 then the diagonal is overwritten as well.
  • If shift = 1 then the diagonal is left untouched.
  • If shift > 1, then the diagonal and the first shift - 1 subdiagonals are left untouched.
Source

pub fn fill_upper_triangle(&mut self, val: T, shift: usize)
where T: Scalar,

Sets all the elements of the lower-triangular part of this matrix to val.

The parameter shift allows some superdiagonals to be left untouched:

  • If shift = 0 then the diagonal is overwritten as well.
  • If shift = 1 then the diagonal is left untouched.
  • If shift > 1, then the diagonal and the first shift - 1 superdiagonals are left untouched.
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>,

§Triangular matrix extraction

Source

pub fn upper_triangle( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Extracts the upper triangular part of this matrix (including the diagonal).

Source

pub fn lower_triangle( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Extracts the lower triangular part of this matrix (including the diagonal).

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

§In-place swapping

Source

pub fn swap_rows(&mut self, irow1: usize, irow2: usize)

Swaps two rows in-place.

Source

pub fn swap_columns(&mut self, icol1: usize, icol2: usize)

Swaps two columns in-place.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>,

§Rows and columns removal

Source

pub fn remove_column( self, i: usize, ) -> Matrix<T, R, <C as DimSub<Const<1>>>::Output, <DefaultAllocator as Allocator<R, <C as DimSub<Const<1>>>::Output>>::Buffer<T>>
where C: DimSub<Const<1>>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<Const<1>>>::Output>,

Removes the i-th column from this matrix.

Source

pub fn remove_columns_at( self, indices: &[usize], ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where C: DimSub<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, R, Dyn>,

Removes all columns in indices

Source

pub fn remove_rows_at( self, indices: &[usize], ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where R: DimSub<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, Dyn, C>,

Removes all rows in indices

Source

pub fn remove_fixed_columns<const D: usize>( self, i: usize, ) -> Matrix<T, R, <C as DimSub<Const<D>>>::Output, <DefaultAllocator as Allocator<R, <C as DimSub<Const<D>>>::Output>>::Buffer<T>>
where C: DimSub<Const<D>>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<Const<D>>>::Output>,

Removes D::dim() consecutive columns from this matrix, starting with the i-th (included).

Source

pub fn remove_columns( self, i: usize, n: usize, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where C: DimSub<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, R, Dyn>,

Removes n consecutive columns from this matrix, starting with the i-th (included).

Source

pub fn remove_columns_generic<D>( self, i: usize, nremove: D, ) -> Matrix<T, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<R, <C as DimSub<D>>::Output>>::Buffer<T>>
where D: Dim, C: DimSub<D>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<D>>::Output>,

Removes nremove.value() columns from this matrix, starting with the i-th (included).

This is the generic implementation of .remove_columns(...) and .remove_fixed_columns(...) which have nicer API interfaces.

Source

pub fn remove_row( self, i: usize, ) -> Matrix<T, <R as DimSub<Const<1>>>::Output, C, <DefaultAllocator as Allocator<<R as DimSub<Const<1>>>::Output, C>>::Buffer<T>>
where R: DimSub<Const<1>>, DefaultAllocator: Reallocator<T, R, C, <R as DimSub<Const<1>>>::Output, C>,

Removes the i-th row from this matrix.

Source

pub fn remove_fixed_rows<const D: usize>( self, i: usize, ) -> Matrix<T, <R as DimSub<Const<D>>>::Output, C, <DefaultAllocator as Allocator<<R as DimSub<Const<D>>>::Output, C>>::Buffer<T>>
where R: DimSub<Const<D>>, DefaultAllocator: Reallocator<T, R, C, <R as DimSub<Const<D>>>::Output, C>,

Removes D::dim() consecutive rows from this matrix, starting with the i-th (included).

Source

pub fn remove_rows( self, i: usize, n: usize, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where R: DimSub<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, Dyn, C>,

Removes n consecutive rows from this matrix, starting with the i-th (included).

Source

pub fn remove_rows_generic<D>( self, i: usize, nremove: D, ) -> Matrix<T, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<<R as DimSub<D>>::Output, C>>::Buffer<T>>
where D: Dim, R: DimSub<D>, DefaultAllocator: Reallocator<T, R, C, <R as DimSub<D>>::Output, C>,

Removes nremove.value() rows from this matrix, starting with the i-th (included).

This is the generic implementation of .remove_rows(...) and .remove_fixed_rows(...) which have nicer API interfaces.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>,

§Rows and columns extraction

Source

pub fn select_rows<'a, I>( &self, irows: I, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

Creates a new matrix by extracting the given set of rows from self.

Source

pub fn select_columns<'a, I>( &self, icols: I, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Creates a new matrix by extracting the given set of columns from self.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>,

§Rows and columns insertion

Source

pub fn insert_column( self, i: usize, val: T, ) -> Matrix<T, R, <C as DimAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<R, <C as DimAdd<Const<1>>>::Output>>::Buffer<T>>
where C: DimAdd<Const<1>>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<1>>>::Output>,

Inserts a column filled with val at the i-th position.

Source

pub fn insert_fixed_columns<const D: usize>( self, i: usize, val: T, ) -> Matrix<T, R, <C as DimAdd<Const<D>>>::Output, <DefaultAllocator as Allocator<R, <C as DimAdd<Const<D>>>::Output>>::Buffer<T>>
where C: DimAdd<Const<D>>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<D>>>::Output>,

Inserts D columns filled with val starting at the i-th position.

Source

pub fn insert_columns( self, i: usize, n: usize, val: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where C: DimAdd<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, R, Dyn>,

Inserts n columns filled with val starting at the i-th position.

Source

pub unsafe fn insert_columns_generic_uninitialized<D>( self, i: usize, ninsert: D, ) -> Matrix<MaybeUninit<T>, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<R, <C as DimAdd<D>>::Output>>::BufferUninit<T>>
where D: Dim, C: DimAdd<D>, DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<D>>::Output>,

Inserts ninsert.value() columns starting at the i-th place of this matrix.

§Safety

The output matrix has all its elements initialized except for the the components of the added columns.

Source

pub fn insert_row( self, i: usize, val: T, ) -> Matrix<T, <R as DimAdd<Const<1>>>::Output, C, <DefaultAllocator as Allocator<<R as DimAdd<Const<1>>>::Output, C>>::Buffer<T>>
where R: DimAdd<Const<1>>, DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<1>>>::Output, C>,

Inserts a row filled with val at the i-th position.

Source

pub fn insert_fixed_rows<const D: usize>( self, i: usize, val: T, ) -> Matrix<T, <R as DimAdd<Const<D>>>::Output, C, <DefaultAllocator as Allocator<<R as DimAdd<Const<D>>>::Output, C>>::Buffer<T>>
where R: DimAdd<Const<D>>, DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<D>>>::Output, C>,

Inserts D::dim() rows filled with val starting at the i-th position.

Source

pub fn insert_rows( self, i: usize, n: usize, val: T, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where R: DimAdd<Dyn, Output = Dyn>, DefaultAllocator: Reallocator<T, R, C, Dyn, C>,

Inserts n rows filled with val starting at the i-th position.

Source

pub unsafe fn insert_rows_generic_uninitialized<D>( self, i: usize, ninsert: D, ) -> Matrix<MaybeUninit<T>, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<<R as DimAdd<D>>::Output, C>>::BufferUninit<T>>
where D: Dim, R: DimAdd<D>, DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<D>>::Output, C>,

Inserts ninsert.value() rows at the i-th place of this matrix.

§Safety

The added rows values are not initialized. This is the generic implementation of .insert_rows(...) and .insert_fixed_rows(...) which have nicer API interfaces.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>,

§Resizing and reshaping

Source

pub fn resize( self, new_nrows: usize, new_ncols: usize, val: T, ) -> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
where DefaultAllocator: Reallocator<T, R, C, Dyn, Dyn>,

Resizes this matrix so that it contains new_nrows rows and new_ncols columns.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows and/or columns than self, then the extra rows or columns are filled with val.

Source

pub fn resize_vertically( self, new_nrows: usize, val: T, ) -> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
where DefaultAllocator: Reallocator<T, R, C, Dyn, C>,

Resizes this matrix vertically, i.e., so that it contains new_nrows rows while keeping the same number of columns.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows than self, then the extra rows are filled with val.

Source

pub fn resize_horizontally( self, new_ncols: usize, val: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where DefaultAllocator: Reallocator<T, R, C, R, Dyn>,

Resizes this matrix horizontally, i.e., so that it contains new_ncolumns columns while keeping the same number of columns.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more columns than self, then the extra columns are filled with val.

Source

pub fn fixed_resize<const R2: usize, const C2: usize>( self, val: T, ) -> Matrix<T, Const<R2>, Const<C2>, <DefaultAllocator as Allocator<Const<R2>, Const<C2>>>::Buffer<T>>
where DefaultAllocator: Reallocator<T, R, C, Const<R2>, Const<C2>>,

Resizes this matrix so that it contains R2::value() rows and C2::value() columns.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows and/or columns than self, then the extra rows or columns are filled with val.

Source

pub fn resize_generic<R2, C2>( self, new_nrows: R2, new_ncols: C2, val: T, ) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, DefaultAllocator: Reallocator<T, R, C, R2, C2>,

Resizes self such that it has dimensions new_nrows × new_ncols.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more rows and/or columns than self, then the extra rows or columns are filled with val.

Source

pub fn reshape_generic<R2, C2>( self, new_nrows: R2, new_ncols: C2, ) -> Matrix<T, R2, C2, <S as ReshapableStorage<T, R, C, R2, C2>>::Output>
where R2: Dim, C2: Dim, S: ReshapableStorage<T, R, C, R2, C2>,

Reshapes self such that it has dimensions new_nrows × new_ncols.

This will reinterpret self as if it is a matrix with new_nrows rows and new_ncols columns. The arrangements of the component in the output matrix are the same as what would be obtained by Matrix::from_slice_generic(self.as_slice(), new_nrows, new_ncols).

If self is a dynamically-sized matrix, then its components are neither copied nor moved. If self is staticyll-sized, then a copy may happen in some situations. This function will panic if the given dimensions are such that the number of elements of the input matrix are not equal to the number of elements of the output matrix.

§Examples

let m1 = Matrix2x3::new(
    1.1, 1.2, 1.3,
    2.1, 2.2, 2.3
);
let m2 = Matrix3x2::new(
    1.1, 2.2,
    2.1, 1.3,
    1.2, 2.3
);
let reshaped = m1.reshape_generic(Const::<3>, Const::<2>);
assert_eq!(reshaped, m2);

let dm1 = DMatrix::from_row_slice(
    4,
    3,
    &[
        1.0, 0.0, 0.0,
        0.0, 0.0, 1.0,
        0.0, 0.0, 0.0,
        0.0, 1.0, 0.0
    ],
);
let dm2 = DMatrix::from_row_slice(
    6,
    2,
    &[
        1.0, 0.0,
        0.0, 1.0,
        0.0, 0.0,
        0.0, 1.0,
        0.0, 0.0,
        0.0, 0.0,
    ],
);
let reshaped = dm1.reshape_generic(Dyn(6), Dyn(2));
assert_eq!(reshaped, dm2);
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Views based on ranges

§Indices to Individual Elements
§Two-Dimensional Indices
let matrix = Matrix2::new(0, 2,
                          1, 3);

assert_eq!(matrix.index((0, 0)), &0);
assert_eq!(matrix.index((1, 0)), &1);
assert_eq!(matrix.index((0, 1)), &2);
assert_eq!(matrix.index((1, 1)), &3);
§Linear Address Indexing
let matrix = Matrix2::new(0, 2,
                          1, 3);

assert_eq!(matrix.get(0), Some(&0));
assert_eq!(matrix.get(1), Some(&1));
assert_eq!(matrix.get(2), Some(&2));
assert_eq!(matrix.get(3), Some(&3));
§Indices to Individual Rows and Columns
§Index to a Row
let matrix = Matrix2::new(0, 2,
                          1, 3);

assert!(matrix.index((0, ..))
    .eq(&Matrix1x2::new(0, 2)));
§Index to a Column
let matrix = Matrix2::new(0, 2,
                          1, 3);

assert!(matrix.index((.., 0))
    .eq(&Matrix2x1::new(0,
                        1)));
§Indices to Parts of Individual Rows and Columns
§Index to a Partial Row
let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((0, ..2))
    .eq(&Matrix1x2::new(0, 3)));
§Index to a Partial Column
let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((..2, 0))
    .eq(&Matrix2x1::new(0,
                        1)));

assert!(matrix.index((Const::<1>.., 0))
    .eq(&Matrix2x1::new(1,
                        2)));
§Indices to Ranges of Rows and Columns
§Index to a Range of Rows
let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((1..3, ..))
    .eq(&Matrix2x3::new(1, 4, 7,
                        2, 5, 8)));
§Index to a Range of Columns
let matrix = Matrix3::new(0, 3, 6,
                          1, 4, 7,
                          2, 5, 8);

assert!(matrix.index((.., 1..3))
    .eq(&Matrix3x2::new(3, 6,
                        4, 7,
                        5, 8)));
Source

pub fn get<'a, I>( &'a self, index: I, ) -> Option<<I as MatrixIndex<'a, T, R, C, S>>::Output>
where I: MatrixIndex<'a, T, R, C, S>,

Produces a view of the data at the given index, or None if the index is out of bounds.

Source

pub fn get_mut<'a, I>( &'a mut self, index: I, ) -> Option<<I as MatrixIndexMut<'a, T, R, C, S>>::OutputMut>
where S: RawStorageMut<T, R, C>, I: MatrixIndexMut<'a, T, R, C, S>,

Produces a mutable view of the data at the given index, or None if the index is out of bounds.

Source

pub fn index<'a, I>( &'a self, index: I, ) -> <I as MatrixIndex<'a, T, R, C, S>>::Output
where I: MatrixIndex<'a, T, R, C, S>,

Produces a view of the data at the given index, or panics if the index is out of bounds.

Source

pub fn index_mut<'a, I>( &'a mut self, index: I, ) -> <I as MatrixIndexMut<'a, T, R, C, S>>::OutputMut
where S: RawStorageMut<T, R, C>, I: MatrixIndexMut<'a, T, R, C, S>,

Produces a mutable view of the data at the given index, or panics if the index is out of bounds.

Source

pub unsafe fn get_unchecked<'a, I>( &'a self, index: I, ) -> <I as MatrixIndex<'a, T, R, C, S>>::Output
where I: MatrixIndex<'a, T, R, C, S>,

Produces a view of the data at the given index, without doing any bounds checking.

§Safety

index must within bounds of the array.

Source

pub unsafe fn get_unchecked_mut<'a, I>( &'a mut self, index: I, ) -> <I as MatrixIndexMut<'a, T, R, C, S>>::OutputMut
where S: RawStorageMut<T, R, C>, I: MatrixIndexMut<'a, T, R, C, S>,

Returns a mutable view of the data at the given index, without doing any bounds checking.

§Safety

index must within bounds of the array.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Iteration on components, rows, and columns

Source

pub fn iter(&self) -> MatrixIter<'_, T, R, C, S>

Iterates through this matrix coordinates in column-major order.

§Example
let mat = Matrix2x3::new(11, 12, 13,
                         21, 22, 23);
let mut it = mat.iter();
assert_eq!(*it.next().unwrap(), 11);
assert_eq!(*it.next().unwrap(), 21);
assert_eq!(*it.next().unwrap(), 12);
assert_eq!(*it.next().unwrap(), 22);
assert_eq!(*it.next().unwrap(), 13);
assert_eq!(*it.next().unwrap(), 23);
assert!(it.next().is_none());
Source

pub fn row_iter(&self) -> RowIter<'_, T, R, C, S>

Iterate through the rows of this matrix.

§Example
let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, row) in a.row_iter().enumerate() {
    assert_eq!(row, a.row(i))
}
Source

pub fn column_iter(&self) -> ColumnIter<'_, T, R, C, S>

Iterate through the columns of this matrix.

§Example
let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, column) in a.column_iter().enumerate() {
    assert_eq!(column, a.column(i))
}
Source

pub fn iter_mut(&mut self) -> MatrixIterMut<'_, T, R, C, S>
where S: RawStorageMut<T, R, C>,

Mutably iterates through this matrix coordinates.

Source

pub fn row_iter_mut(&mut self) -> RowIterMut<'_, T, R, C, S>
where S: RawStorageMut<T, R, C>,

Mutably iterates through this matrix rows.

§Example
let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, mut row) in a.row_iter_mut().enumerate() {
    row *= (i + 1) * 10;
}

let expected = Matrix2x3::new(10, 20, 30,
                              80, 100, 120);
assert_eq!(a, expected);
Source

pub fn column_iter_mut(&mut self) -> ColumnIterMut<'_, T, R, C, S>
where S: RawStorageMut<T, R, C>,

Mutably iterates through this matrix columns.

§Example
let mut a = Matrix2x3::new(1, 2, 3,
                           4, 5, 6);
for (i, mut col) in a.column_iter_mut().enumerate() {
    col *= (i + 1) * 10;
}

let expected = Matrix2x3::new(10, 40, 90,
                              40, 100, 180);
assert_eq!(a, expected);
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

Source

pub fn as_mut_ptr(&mut self) -> *mut T

Returns a mutable pointer to the start of the matrix.

If the matrix is not empty, this pointer is guaranteed to be aligned and non-null.

Source

pub unsafe fn swap_unchecked( &mut self, row_cols1: (usize, usize), row_cols2: (usize, usize), )

Swaps two entries without bound-checking.

§Safety

Both (r, c) must have r < nrows(), c < ncols().

Source

pub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))

Swaps two entries.

Source

pub fn copy_from_slice(&mut self, slice: &[T])
where T: Scalar,

Fills this matrix with the content of a slice. Both must hold the same number of elements.

The components of the slice are assumed to be ordered in column-major order.

Source

pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>)
where T: Scalar, R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Fills this matrix with the content of another one. Both must have the same shape.

Source

pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>)
where T: Scalar, R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,

Fills this matrix with the content of the transpose another one.

Source

pub fn apply_into<F>(self, f: F) -> Matrix<T, R, C, S>
where F: FnMut(&mut T),

Returns self with each of its components replaced by the result of a closure f applied on it.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous,

Source

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

Extracts a slice containing the entire matrix entries ordered column-by-columns.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous,

Source

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

Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source

pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>)
where R2: Dim, C2: Dim, SB: RawStorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,

Takes the adjoint (aka. conjugate-transpose) of self and store the result into out.

Source

pub fn adjoint( &self, ) -> Matrix<T, C, R, <DefaultAllocator as Allocator<C, R>>::Buffer<T>>

The adjoint (aka. conjugate-transpose) of self.

Source

pub fn conjugate_transpose_to<R2, C2, SB>( &self, out: &mut Matrix<T, R2, C2, SB>, )
where R2: Dim, C2: Dim, SB: RawStorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,

👎Deprecated: Renamed self.adjoint_to(out).

Takes the conjugate and transposes self and store the result into out.

Source

pub fn conjugate_transpose( &self, ) -> Matrix<T, C, R, <DefaultAllocator as Allocator<C, R>>::Buffer<T>>

👎Deprecated: Renamed self.adjoint().

The conjugate transposition of self.

Source

pub fn conjugate( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

The conjugate of self.

Source

pub fn unscale( &self, real: <T as SimdComplexField>::SimdRealField, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Divides each component of the complex matrix self by the given real.

Source

pub fn scale( &self, real: <T as SimdComplexField>::SimdRealField, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Multiplies each component of the complex matrix self by the given real.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: SimdComplexField, R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

Source

pub fn conjugate_mut(&mut self)

The conjugate of the complex matrix self computed in-place.

Source

pub fn unscale_mut(&mut self, real: <T as SimdComplexField>::SimdRealField)

Divides each component of the complex matrix self by the given real.

Source

pub fn scale_mut(&mut self, real: <T as SimdComplexField>::SimdRealField)

Multiplies each component of the complex matrix self by the given real.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign, R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Cross product

Source

pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T
where R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, Const<2>> + SameNumberOfColumns<C, Const<1>> + SameNumberOfRows<R2, Const<2>> + SameNumberOfColumns<C2, Const<1>>,

The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x.

Source

pub fn cross<R2, C2, SB>( &self, b: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer<T>>
where R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

The 3D cross product between two vectors.

Panics if the shape is not 3D vector. In the future, this will be implemented only for dynamically-sized matrices and statically-sized 3D matrices.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>,

Source

pub fn angle<R2, C2, SB>( &self, other: &Matrix<T, R2, C2, SB>, ) -> <T as SimdComplexField>::SimdRealField
where R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,

The smallest angle between two vectors.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>

Source

pub const unsafe fn from_data_statically_unchecked( data: S, ) -> Matrix<T, R, C, S>

Creates a new matrix with the given data without statically checking that the matrix dimension matches the storage dimension.

§Safety

The storage dimension must match the given dimensions.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source

pub fn from_data(data: S) -> Matrix<T, R, C, S>

Creates a new matrix with the given data.

Source

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

The shape of this matrix returned as the tuple (number of rows, number of columns).

§Example
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.shape(), (3, 4));
Source

pub fn shape_generic(&self) -> (R, C)

The shape of this matrix wrapped into their representative types (Const or Dyn).

Source

pub fn nrows(&self) -> usize

The number of rows of this matrix.

§Example
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.nrows(), 3);
Source

pub fn ncols(&self) -> usize

The number of columns of this matrix.

§Example
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.ncols(), 4);
Source

pub fn strides(&self) -> (usize, usize)

The strides (row stride, column stride) of this matrix.

§Example
let mat = DMatrix::<f32>::zeros(10, 10);
let view = mat.view_with_steps((0, 0), (5, 3), (1, 2));
// The column strides is the number of steps (here 2) multiplied by the corresponding dimension.
assert_eq!(mat.strides(), (1, 10));
Source

pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)

Computes the row and column coordinates of the i-th element of this matrix seen as a vector.

§Example
let m = Matrix2::new(1, 2,
                     3, 4);
let i = m.vector_to_matrix_index(3);
assert_eq!(i, (1, 1));
assert_eq!(m[i], m[3]);
Source

pub fn as_ptr(&self) -> *const T

Returns a pointer to the start of the matrix.

If the matrix is not empty, this pointer is guaranteed to be aligned and non-null.

§Example
let m = Matrix2::new(1, 2,
                     3, 4);
let ptr = m.as_ptr();
assert_eq!(unsafe { *ptr }, m[0]);
Source

pub fn relative_eq<R2, C2, SB>( &self, other: &Matrix<T, R2, C2, SB>, eps: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::Epsilon, ) -> bool
where T: RelativeEq + Scalar, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, <T as AbsDiffEq>::Epsilon: Clone, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Tests whether self and rhs are equal up to a given epsilon.

See relative_eq from the RelativeEq trait for more details.

Source

pub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> bool
where T: PartialEq, R2: Dim, C2: Dim, SB: RawStorage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Tests whether self and rhs are exactly equal.

Source

pub fn into_owned( self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, S: Storage<T, R, C>, DefaultAllocator: Allocator<R, C>,

Moves this matrix into one that owns its data.

Source

pub fn into_owned_sum<R2, C2>( self, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer<T>>
where T: Scalar, S: Storage<T, R, C>, R2: Dim, C2: Dim, DefaultAllocator: SameShapeAllocator<R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Moves this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.

Source

pub fn clone_owned( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar, S: Storage<T, R, C>, DefaultAllocator: Allocator<R, C>,

Clones this matrix to one that owns its data.

Source

pub fn clone_owned_sum<R2, C2>( &self, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer<T>>
where T: Scalar, S: Storage<T, R, C>, R2: Dim, C2: Dim, DefaultAllocator: SameShapeAllocator<R, C, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Clones this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.

Source

pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>)
where T: Scalar, R2: Dim, C2: Dim, SB: RawStorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,

Transposes self and store the result into out.

Source

pub fn transpose( &self, ) -> Matrix<T, C, R, <DefaultAllocator as Allocator<C, R>>::Buffer<T>>

Transposes self.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Elementwise mapping and folding

Source

pub fn map<T2, F>( &self, f: F, ) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T2>>
where T2: Scalar, F: FnMut(T) -> T2, T: Scalar, DefaultAllocator: Allocator<R, C>,

Returns a matrix containing the result of f applied to each of its entries.

Source

pub fn cast<T2>( self, ) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T2>>
where T2: Scalar, T: Scalar, Matrix<T2, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T2>>: SupersetOf<Matrix<T, R, C, S>>, DefaultAllocator: Allocator<R, C>,

Cast the components of self to another type.

§Example
let q = Vector3::new(1.0f64, 2.0, 3.0);
let q2 = q.cast::<f32>();
assert_eq!(q2, Vector3::new(1.0f32, 2.0, 3.0));
Source

pub fn try_cast<T2>( self, ) -> Option<Matrix<T2, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T2>>>
where T2: Scalar, T: Scalar, Matrix<T, R, C, S>: SupersetOf<Matrix<T2, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T2>>>, DefaultAllocator: Allocator<R, C>,

Attempts to cast the components of self to another type.

§Example
let q = Vector3::new(1.0f64, 2.0, 3.0);
let q2 = q.try_cast::<i32>();
assert_eq!(q2, Some(Vector3::new(1, 2, 3)));
Source

pub fn fold_with<T2>( &self, init_f: impl FnOnce(Option<&T>) -> T2, f: impl FnMut(T2, &T) -> T2, ) -> T2
where T: Scalar,

Similar to self.iter().fold(init, f) except that init is replaced by a closure.

The initialization closure is given the first component of this matrix:

  • If the matrix has no component (0 rows or 0 columns) then init_f is called with None and its return value is the value returned by this method.
  • If the matrix has has least one component, then init_f is called with the first component to compute the initial value. Folding then continues on all the remaining components of the matrix.
Source

pub fn map_with_location<T2, F>( &self, f: F, ) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T2>>
where T2: Scalar, F: FnMut(usize, usize, T) -> T2, T: Scalar, DefaultAllocator: Allocator<R, C>,

Returns a matrix containing the result of f applied to each of its entries. Unlike map, f also gets passed the row and column index, i.e. f(row, col, value).

Source

pub fn zip_map<T2, N3, S2, F>( &self, rhs: &Matrix<T2, R, C, S2>, f: F, ) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<N3>>
where T: Scalar, T2: Scalar, N3: Scalar, S2: RawStorage<T2, R, C>, F: FnMut(T, T2) -> N3, DefaultAllocator: Allocator<R, C>,

Returns a matrix containing the result of f applied to each entries of self and rhs.

Source

pub fn zip_zip_map<T2, N3, N4, S2, S3, F>( &self, b: &Matrix<T2, R, C, S2>, c: &Matrix<N3, R, C, S3>, f: F, ) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<N4>>
where T: Scalar, T2: Scalar, N3: Scalar, N4: Scalar, S2: RawStorage<T2, R, C>, S3: RawStorage<N3, R, C>, F: FnMut(T, T2, N3) -> N4, DefaultAllocator: Allocator<R, C>,

Returns a matrix containing the result of f applied to each entries of self and b, and c.

Source

pub fn fold<Acc>(&self, init: Acc, f: impl FnMut(Acc, T) -> Acc) -> Acc
where T: Scalar,

Folds a function f on each entry of self.

Source

pub fn zip_fold<T2, R2, C2, S2, Acc>( &self, rhs: &Matrix<T2, R2, C2, S2>, init: Acc, f: impl FnMut(Acc, T, T2) -> Acc, ) -> Acc
where T: Scalar, T2: Scalar, R2: Dim, C2: Dim, S2: RawStorage<T2, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Folds a function f on each pairs of entries from self and rhs.

Source

pub fn apply<F>(&mut self, f: F)
where F: FnMut(&mut T), S: RawStorageMut<T, R, C>,

Applies a closure f to modify each component of self.

Source

pub fn zip_apply<T2, R2, C2, S2>( &mut self, rhs: &Matrix<T2, R2, C2, S2>, f: impl FnMut(&mut T, T2), )
where S: RawStorageMut<T, R, C>, T2: Scalar, R2: Dim, C2: Dim, S2: RawStorage<T2, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Replaces each component of self by the result of a closure f applied on its components joined with the components from rhs.

Source

pub fn zip_zip_apply<T2, R2, C2, S2, N3, R3, C3, S3>( &mut self, b: &Matrix<T2, R2, C2, S2>, c: &Matrix<N3, R3, C3, S3>, f: impl FnMut(&mut T, T2, N3), )
where S: RawStorageMut<T, R, C>, T2: Scalar, R2: Dim, C2: Dim, S2: RawStorage<T2, R2, C2>, N3: Scalar, R3: Dim, C3: Dim, S3: RawStorage<N3, R3, C3>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Replaces each component of self by the result of a closure f applied on its components joined with the components from b and c.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

Source

pub fn slice_range_mut<RowRange, ColRange>( &mut self, rows: RowRange, cols: ColRange, ) -> Matrix<T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, ViewStorageMut<'_, T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RowRange: DimRange<R>, ColRange: DimRange<C>,

👎Deprecated: Use view_range_mut instead. See issue #1076 for more information.

Slices a mutable sub-matrix containing the rows indexed by the range rows and the columns indexed by the range cols.

Source

pub fn view_range_mut<RowRange, ColRange>( &mut self, rows: RowRange, cols: ColRange, ) -> Matrix<T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, ViewStorageMut<'_, T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RowRange: DimRange<R>, ColRange: DimRange<C>,

Return a mutable view containing the rows indexed by the range rows and the columns indexed by the range cols.

Source

pub fn rows_range_mut<RowRange>( &mut self, rows: RowRange, ) -> Matrix<T, <RowRange as DimRange<R>>::Size, C, ViewStorageMut<'_, T, <RowRange as DimRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RowRange: DimRange<R>,

Mutable view containing all the rows indexed by the range rows.

Source

pub fn columns_range_mut<ColRange>( &mut self, cols: ColRange, ) -> Matrix<T, R, <ColRange as DimRange<C>>::Size, ViewStorageMut<'_, T, R, <ColRange as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where ColRange: DimRange<C>,

Mutable view containing all the columns indexed by the range cols.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source

pub fn as_view<RView, CView, RViewStride, CViewStride>( &self, ) -> Matrix<T, RView, CView, ViewStorage<'_, T, RView, CView, RViewStride, CViewStride>>
where RView: Dim, CView: Dim, RViewStride: Dim, CViewStride: Dim, ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, <S as RawStorage<T, R, C>>::RStride> + DimEq<CViewStride, <S as RawStorage<T, R, C>>::CStride>,

Returns this matrix as a view.

The returned view type is generally ambiguous unless specified. This is particularly useful when working with functions or methods that take matrix views as input.

§Panics

Panics if the dimensions of the view and the matrix are not compatible and this cannot be proven at compile-time. This might happen, for example, when constructing a static view of size 3x3 from a dynamically sized matrix of dimension 5x5.

§Examples
use nalgebra::{DMatrixSlice, SMatrixView};

fn consume_view(_: DMatrixSlice<f64>) {}

let matrix = nalgebra::Matrix3::zeros();
consume_view(matrix.as_view());

let dynamic_view: DMatrixSlice<f64> = matrix.as_view();
let static_view_from_dyn: SMatrixView<f64, 3, 3> = dynamic_view.as_view();
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

Source

pub fn as_view_mut<RView, CView, RViewStride, CViewStride>( &mut self, ) -> Matrix<T, RView, CView, ViewStorageMut<'_, T, RView, CView, RViewStride, CViewStride>>
where RView: Dim, CView: Dim, RViewStride: Dim, CViewStride: Dim, ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, <S as RawStorage<T, R, C>>::RStride> + DimEq<CViewStride, <S as RawStorage<T, R, C>>::CStride>,

Returns this matrix as a mutable view.

The returned view type is generally ambiguous unless specified. This is particularly useful when working with functions or methods that take matrix views as input.

§Panics

Panics if the dimensions of the view and the matrix are not compatible and this cannot be proven at compile-time. This might happen, for example, when constructing a static view of size 3x3 from a dynamically sized matrix of dimension 5x5.

§Examples
use nalgebra::{DMatrixViewMut, SMatrixViewMut};

fn consume_view(_: DMatrixViewMut<f64>) {}

let mut matrix = nalgebra::Matrix3::zeros();
consume_view(matrix.as_view_mut());

let mut dynamic_view: DMatrixViewMut<f64> = matrix.as_view_mut();
let static_view_from_dyn: SMatrixViewMut<f64, 3, 3> = dynamic_view.as_view_mut();
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Views based on index and length

Source

pub fn row( &self, i: usize, ) -> Matrix<T, Const<1>, C, ViewStorage<'_, T, Const<1>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the i-th row of this matrix.

Source

pub fn row_part( &self, i: usize, n: usize, ) -> Matrix<T, Const<1>, Dyn, ViewStorage<'_, T, Const<1>, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the n first elements of the i-th row of this matrix.

Source

pub fn rows( &self, first_row: usize, nrows: usize, ) -> Matrix<T, Dyn, C, ViewStorage<'_, T, Dyn, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a set of consecutive rows.

Source

pub fn rows_with_step( &self, first_row: usize, nrows: usize, step: usize, ) -> Matrix<T, Dyn, C, ViewStorage<'_, T, Dyn, C, Dyn, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a set of consecutive rows regularly skipping step rows.

Source

pub fn fixed_rows<const RVIEW: usize>( &self, first_row: usize, ) -> Matrix<T, Const<RVIEW>, C, ViewStorage<'_, T, Const<RVIEW>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts a compile-time number of consecutive rows from this matrix.

Source

pub fn fixed_rows_with_step<const RVIEW: usize>( &self, first_row: usize, step: usize, ) -> Matrix<T, Const<RVIEW>, C, ViewStorage<'_, T, Const<RVIEW>, C, Dyn, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a compile-time number of rows regularly skipping step rows.

Source

pub fn rows_generic<RView>( &self, row_start: usize, nrows: RView, ) -> Matrix<T, RView, C, ViewStorage<'_, T, RView, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim,

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

Source

pub fn rows_generic_with_step<RView>( &self, row_start: usize, nrows: RView, step: usize, ) -> Matrix<T, RView, C, ViewStorage<'_, T, RView, C, Dyn, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim,

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

Source

pub fn column( &self, i: usize, ) -> Matrix<T, R, Const<1>, ViewStorage<'_, T, R, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the i-th column of this matrix.

Source

pub fn column_part( &self, i: usize, n: usize, ) -> Matrix<T, Dyn, Const<1>, ViewStorage<'_, T, Dyn, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the n first elements of the i-th column of this matrix.

Source

pub fn columns( &self, first_col: usize, ncols: usize, ) -> Matrix<T, R, Dyn, ViewStorage<'_, T, R, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a set of consecutive columns.

Source

pub fn columns_with_step( &self, first_col: usize, ncols: usize, step: usize, ) -> Matrix<T, R, Dyn, ViewStorage<'_, T, R, Dyn, <S as RawStorage<T, R, C>>::RStride, Dyn>>

Extracts from this matrix a set of consecutive columns regularly skipping step columns.

Source

pub fn fixed_columns<const CVIEW: usize>( &self, first_col: usize, ) -> Matrix<T, R, Const<CVIEW>, ViewStorage<'_, T, R, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts a compile-time number of consecutive columns from this matrix.

Source

pub fn fixed_columns_with_step<const CVIEW: usize>( &self, first_col: usize, step: usize, ) -> Matrix<T, R, Const<CVIEW>, ViewStorage<'_, T, R, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, Dyn>>

Extracts from this matrix a compile-time number of columns regularly skipping step columns.

Source

pub fn columns_generic<CView>( &self, first_col: usize, ncols: CView, ) -> Matrix<T, R, CView, ViewStorage<'_, T, R, CView, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where CView: Dim,

Extracts from this matrix ncols columns. The number of columns may or may not be known at compile-time.

Source

pub fn columns_generic_with_step<CView>( &self, first_col: usize, ncols: CView, step: usize, ) -> Matrix<T, R, CView, ViewStorage<'_, T, R, CView, <S as RawStorage<T, R, C>>::RStride, Dyn>>
where CView: Dim,

Extracts from this matrix ncols columns skipping step columns. Both argument may or may not be values known at compile-time.

Source

pub fn slice( &self, start: (usize, usize), shape: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorage<'_, T, Dyn, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

👎Deprecated: Use view instead. See issue #1076 for more information.

Slices this matrix starting at its component (irow, icol) and with (nrows, ncols) consecutive elements.

Source

pub fn view( &self, start: (usize, usize), shape: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorage<'_, T, Dyn, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Return a view of this matrix starting at its component (irow, icol) and with (nrows, ncols) consecutive elements.

Source

pub fn slice_with_steps( &self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorage<'_, T, Dyn, Dyn, Dyn, Dyn>>

👎Deprecated: Use view_with_steps instead. See issue #1076 for more information.

Slices this matrix starting at its component (start.0, start.1) and with (shape.0, shape.1) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn view_with_steps( &self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorage<'_, T, Dyn, Dyn, Dyn, Dyn>>

Return a view of this matrix starting at its component (start.0, start.1) and with (shape.0, shape.1) components. Each row (resp. column) of the matrix view is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn fixed_slice<const RVIEW: usize, const CVIEW: usize>( &self, irow: usize, icol: usize, ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorage<'_, T, Const<RVIEW>, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

👎Deprecated: Use fixed_view instead. See issue #1076 for more information.

Slices this matrix starting at its component (irow, icol) and with (RVIEW, CVIEW) consecutive components.

Source

pub fn fixed_view<const RVIEW: usize, const CVIEW: usize>( &self, irow: usize, icol: usize, ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorage<'_, T, Const<RVIEW>, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Return a view of this matrix starting at its component (irow, icol) and with (RVIEW, CVIEW) consecutive components.

Source

pub fn fixed_slice_with_steps<const RVIEW: usize, const CVIEW: usize>( &self, start: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorage<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>>

👎Deprecated: Use fixed_view_with_steps instead. See issue #1076 for more information.

Slices this matrix starting at its component (start.0, start.1) and with (RVIEW, CVIEW) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn fixed_view_with_steps<const RVIEW: usize, const CVIEW: usize>( &self, start: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorage<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>>

Returns a view of this matrix starting at its component (start.0, start.1) and with (RVIEW, CVIEW) components. Each row (resp. column) of the matrix view is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn generic_slice<RView, CView>( &self, start: (usize, usize), shape: (RView, CView), ) -> Matrix<T, RView, CView, ViewStorage<'_, T, RView, CView, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim, CView: Dim,

👎Deprecated: Use generic_view instead. See issue #1076 for more information.

Creates a slice that may or may not have a fixed size and stride.

Source

pub fn generic_view<RView, CView>( &self, start: (usize, usize), shape: (RView, CView), ) -> Matrix<T, RView, CView, ViewStorage<'_, T, RView, CView, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim, CView: Dim,

Creates a matrix view that may or may not have a fixed size and stride.

Source

pub fn generic_slice_with_steps<RView, CView>( &self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize), ) -> Matrix<T, RView, CView, ViewStorage<'_, T, RView, CView, Dyn, Dyn>>
where RView: Dim, CView: Dim,

👎Deprecated: Use generic_view_with_steps instead. See issue #1076 for more information.

Creates a slice that may or may not have a fixed size and stride.

Source

pub fn generic_view_with_steps<RView, CView>( &self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize), ) -> Matrix<T, RView, CView, ViewStorage<'_, T, RView, CView, Dyn, Dyn>>
where RView: Dim, CView: Dim,

Creates a matrix view that may or may not have a fixed size and stride.

Source

pub fn rows_range_pair<Range1, Range2>( &self, r1: Range1, r2: Range2, ) -> (Matrix<T, <Range1 as DimRange<R>>::Size, C, ViewStorage<'_, T, <Range1 as DimRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, <Range2 as DimRange<R>>::Size, C, ViewStorage<'_, T, <Range2 as DimRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>)
where Range1: DimRange<R>, Range2: DimRange<R>,

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

Source

pub fn columns_range_pair<Range1, Range2>( &self, r1: Range1, r2: Range2, ) -> (Matrix<T, R, <Range1 as DimRange<C>>::Size, ViewStorage<'_, T, R, <Range1 as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, R, <Range2 as DimRange<C>>::Size, ViewStorage<'_, T, R, <Range2 as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>)
where Range1: DimRange<C>, Range2: DimRange<C>,

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

§Mutable views based on index and length

Source

pub fn row_mut( &mut self, i: usize, ) -> Matrix<T, Const<1>, C, ViewStorageMut<'_, T, Const<1>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the i-th row of this matrix.

Source

pub fn row_part_mut( &mut self, i: usize, n: usize, ) -> Matrix<T, Const<1>, Dyn, ViewStorageMut<'_, T, Const<1>, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the n first elements of the i-th row of this matrix.

Source

pub fn rows_mut( &mut self, first_row: usize, nrows: usize, ) -> Matrix<T, Dyn, C, ViewStorageMut<'_, T, Dyn, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a set of consecutive rows.

Source

pub fn rows_with_step_mut( &mut self, first_row: usize, nrows: usize, step: usize, ) -> Matrix<T, Dyn, C, ViewStorageMut<'_, T, Dyn, C, Dyn, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a set of consecutive rows regularly skipping step rows.

Source

pub fn fixed_rows_mut<const RVIEW: usize>( &mut self, first_row: usize, ) -> Matrix<T, Const<RVIEW>, C, ViewStorageMut<'_, T, Const<RVIEW>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts a compile-time number of consecutive rows from this matrix.

Source

pub fn fixed_rows_with_step_mut<const RVIEW: usize>( &mut self, first_row: usize, step: usize, ) -> Matrix<T, Const<RVIEW>, C, ViewStorageMut<'_, T, Const<RVIEW>, C, Dyn, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a compile-time number of rows regularly skipping step rows.

Source

pub fn rows_generic_mut<RView>( &mut self, row_start: usize, nrows: RView, ) -> Matrix<T, RView, C, ViewStorageMut<'_, T, RView, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim,

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

Source

pub fn rows_generic_with_step_mut<RView>( &mut self, row_start: usize, nrows: RView, step: usize, ) -> Matrix<T, RView, C, ViewStorageMut<'_, T, RView, C, Dyn, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim,

Extracts from this matrix nrows rows regularly skipping step rows. Both argument may or may not be values known at compile-time.

Source

pub fn column_mut( &mut self, i: usize, ) -> Matrix<T, R, Const<1>, ViewStorageMut<'_, T, R, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the i-th column of this matrix.

Source

pub fn column_part_mut( &mut self, i: usize, n: usize, ) -> Matrix<T, Dyn, Const<1>, ViewStorageMut<'_, T, Dyn, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Returns a view containing the n first elements of the i-th column of this matrix.

Source

pub fn columns_mut( &mut self, first_col: usize, ncols: usize, ) -> Matrix<T, R, Dyn, ViewStorageMut<'_, T, R, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts from this matrix a set of consecutive columns.

Source

pub fn columns_with_step_mut( &mut self, first_col: usize, ncols: usize, step: usize, ) -> Matrix<T, R, Dyn, ViewStorageMut<'_, T, R, Dyn, <S as RawStorage<T, R, C>>::RStride, Dyn>>

Extracts from this matrix a set of consecutive columns regularly skipping step columns.

Source

pub fn fixed_columns_mut<const CVIEW: usize>( &mut self, first_col: usize, ) -> Matrix<T, R, Const<CVIEW>, ViewStorageMut<'_, T, R, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Extracts a compile-time number of consecutive columns from this matrix.

Source

pub fn fixed_columns_with_step_mut<const CVIEW: usize>( &mut self, first_col: usize, step: usize, ) -> Matrix<T, R, Const<CVIEW>, ViewStorageMut<'_, T, R, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, Dyn>>

Extracts from this matrix a compile-time number of columns regularly skipping step columns.

Source

pub fn columns_generic_mut<CView>( &mut self, first_col: usize, ncols: CView, ) -> Matrix<T, R, CView, ViewStorageMut<'_, T, R, CView, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where CView: Dim,

Extracts from this matrix ncols columns. The number of columns may or may not be known at compile-time.

Source

pub fn columns_generic_with_step_mut<CView>( &mut self, first_col: usize, ncols: CView, step: usize, ) -> Matrix<T, R, CView, ViewStorageMut<'_, T, R, CView, <S as RawStorage<T, R, C>>::RStride, Dyn>>
where CView: Dim,

Extracts from this matrix ncols columns skipping step columns. Both argument may or may not be values known at compile-time.

Source

pub fn slice_mut( &mut self, start: (usize, usize), shape: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorageMut<'_, T, Dyn, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

👎Deprecated: Use view_mut instead. See issue #1076 for more information.

Slices this matrix starting at its component (irow, icol) and with (nrows, ncols) consecutive elements.

Source

pub fn view_mut( &mut self, start: (usize, usize), shape: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorageMut<'_, T, Dyn, Dyn, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Return a view of this matrix starting at its component (irow, icol) and with (nrows, ncols) consecutive elements.

Source

pub fn slice_with_steps_mut( &mut self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorageMut<'_, T, Dyn, Dyn, Dyn, Dyn>>

👎Deprecated: Use view_with_steps_mut instead. See issue #1076 for more information.

Slices this matrix starting at its component (start.0, start.1) and with (shape.0, shape.1) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn view_with_steps_mut( &mut self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Dyn, Dyn, ViewStorageMut<'_, T, Dyn, Dyn, Dyn, Dyn>>

Return a view of this matrix starting at its component (start.0, start.1) and with (shape.0, shape.1) components. Each row (resp. column) of the matrix view is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn fixed_slice_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, irow: usize, icol: usize, ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorageMut<'_, T, Const<RVIEW>, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

👎Deprecated: Use fixed_view_mut instead. See issue #1076 for more information.

Slices this matrix starting at its component (irow, icol) and with (RVIEW, CVIEW) consecutive components.

Source

pub fn fixed_view_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, irow: usize, icol: usize, ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorageMut<'_, T, Const<RVIEW>, Const<CVIEW>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>

Return a view of this matrix starting at its component (irow, icol) and with (RVIEW, CVIEW) consecutive components.

Source

pub fn fixed_slice_with_steps_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, start: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorageMut<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>>

👎Deprecated: Use fixed_view_with_steps_mut instead. See issue #1076 for more information.

Slices this matrix starting at its component (start.0, start.1) and with (RVIEW, CVIEW) components. Each row (resp. column) of the sliced matrix is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn fixed_view_with_steps_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, start: (usize, usize), steps: (usize, usize), ) -> Matrix<T, Const<RVIEW>, Const<CVIEW>, ViewStorageMut<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>>

Returns a view of this matrix starting at its component (start.0, start.1) and with (RVIEW, CVIEW) components. Each row (resp. column) of the matrix view is separated by steps.0 (resp. steps.1) ignored rows (resp. columns) of the original matrix.

Source

pub fn generic_slice_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView), ) -> Matrix<T, RView, CView, ViewStorageMut<'_, T, RView, CView, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim, CView: Dim,

👎Deprecated: Use generic_view_mut instead. See issue #1076 for more information.

Creates a slice that may or may not have a fixed size and stride.

Source

pub fn generic_view_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView), ) -> Matrix<T, RView, CView, ViewStorageMut<'_, T, RView, CView, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RView: Dim, CView: Dim,

Creates a matrix view that may or may not have a fixed size and stride.

Source

pub fn generic_slice_with_steps_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize), ) -> Matrix<T, RView, CView, ViewStorageMut<'_, T, RView, CView, Dyn, Dyn>>
where RView: Dim, CView: Dim,

👎Deprecated: Use generic_view_with_steps_mut instead. See issue #1076 for more information.

Creates a slice that may or may not have a fixed size and stride.

Source

pub fn generic_view_with_steps_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize), ) -> Matrix<T, RView, CView, ViewStorageMut<'_, T, RView, CView, Dyn, Dyn>>
where RView: Dim, CView: Dim,

Creates a matrix view that may or may not have a fixed size and stride.

Source

pub fn rows_range_pair_mut<Range1, Range2>( &mut self, r1: Range1, r2: Range2, ) -> (Matrix<T, <Range1 as DimRange<R>>::Size, C, ViewStorageMut<'_, T, <Range1 as DimRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, <Range2 as DimRange<R>>::Size, C, ViewStorageMut<'_, T, <Range2 as DimRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>)
where Range1: DimRange<R>, Range2: DimRange<R>,

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

Source

pub fn columns_range_pair_mut<Range1, Range2>( &mut self, r1: Range1, r2: Range2, ) -> (Matrix<T, R, <Range1 as DimRange<C>>::Size, ViewStorageMut<'_, T, R, <Range1 as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, R, <Range2 as DimRange<C>>::Size, ViewStorageMut<'_, T, R, <Range2 as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>)
where Range1: DimRange<C>, Range2: DimRange<C>,

Splits this NxM matrix into two parts delimited by two ranges.

Panics if the ranges overlap or if the first range is empty.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source

pub fn slice_range<RowRange, ColRange>( &self, rows: RowRange, cols: ColRange, ) -> Matrix<T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, ViewStorage<'_, T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RowRange: DimRange<R>, ColRange: DimRange<C>,

👎Deprecated: Use view_range instead. See issue #1076 for more information.

Slices a sub-matrix containing the rows indexed by the range rows and the columns indexed by the range cols.

Source

pub fn view_range<RowRange, ColRange>( &self, rows: RowRange, cols: ColRange, ) -> Matrix<T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, ViewStorage<'_, T, <RowRange as DimRange<R>>::Size, <ColRange as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RowRange: DimRange<R>, ColRange: DimRange<C>,

Returns a view containing the rows indexed by the range rows and the columns indexed by the range cols.

Source

pub fn rows_range<RowRange>( &self, rows: RowRange, ) -> Matrix<T, <RowRange as DimRange<R>>::Size, C, ViewStorage<'_, T, <RowRange as DimRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where RowRange: DimRange<R>,

View containing all the rows indexed by the range rows.

Source

pub fn columns_range<ColRange>( &self, cols: ColRange, ) -> Matrix<T, R, <ColRange as DimRange<C>>::Size, ViewStorage<'_, T, R, <ColRange as DimRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
where ColRange: DimRange<C>,

View containing all the columns indexed by the range rows.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source

pub fn iamax_full(&self) -> (usize, usize)

Computes the index of the matrix component with the largest absolute value.

§Examples:
let mat = Matrix2x3::new(11, -12, 13,
                         21, 22, -23);
assert_eq!(mat.iamax_full(), (1, 2));
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Find the min and max components

Source

pub fn amax(&self) -> T
where T: Zero + SimdSigned + SimdPartialOrd,

Returns the absolute value of the component with the largest absolute value.

§Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).amax(), 3.0);
assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0);
Source

pub fn camax(&self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

Returns the the 1-norm of the complex component with the largest 1-norm.

§Example
assert_eq!(Vector3::new(
    Complex::new(-3.0, -2.0),
    Complex::new(1.0, 2.0),
    Complex::new(1.0, 3.0)).camax(), 5.0);
Source

pub fn max(&self) -> T
where T: SimdPartialOrd + Zero,

Returns the component with the largest value.

§Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).max(), 3.0);
assert_eq!(Vector3::new(-1.0, -2.0, -3.0).max(), -1.0);
assert_eq!(Vector3::new(5u32, 2, 3).max(), 5);
Source

pub fn amin(&self) -> T
where T: Zero + SimdPartialOrd + SimdSigned,

Returns the absolute value of the component with the smallest absolute value.

§Example
assert_eq!(Vector3::new(-1.0, 2.0, -3.0).amin(), 1.0);
assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0);
Source

pub fn camin(&self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

Returns the the 1-norm of the complex component with the smallest 1-norm.

§Example
assert_eq!(Vector3::new(
    Complex::new(-3.0, -2.0),
    Complex::new(1.0, 2.0),
    Complex::new(1.0, 3.0)).camin(), 3.0);
Source

pub fn min(&self) -> T
where T: SimdPartialOrd + Zero,

Returns the component with the smallest value.

§Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).min(), -1.0);
assert_eq!(Vector3::new(1.0, 2.0, 3.0).min(), 1.0);
assert_eq!(Vector3::new(5u32, 2, 3).min(), 2);
Source

pub fn icamax_full(&self) -> (usize, usize)
where T: ComplexField,

Computes the index of the matrix component with the largest absolute value.

§Examples:
let mat = Matrix2x3::new(Complex::new(11.0, 1.0), Complex::new(-12.0, 2.0), Complex::new(13.0, 3.0),
                         Complex::new(21.0, 43.0), Complex::new(22.0, 5.0), Complex::new(-23.0, 0.0));
assert_eq!(mat.icamax_full(), (1, 0));
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>,

§Magnitude and norms

Source

pub fn norm_squared(&self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

The squared L2 norm of this vector.

Source

pub fn norm(&self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

The L2 norm of this matrix.

Use .apply_norm to apply a custom norm.

Source

pub fn metric_distance<R2, C2, S2>( &self, rhs: &Matrix<T, R2, C2, S2>, ) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField, R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Compute the distance between self and rhs using the metric induced by the euclidean norm.

Use .apply_metric_distance to apply a custom norm.

Source

pub fn apply_norm( &self, norm: &impl Norm<T>, ) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

Uses the given norm to compute the norm of self.

§Example

let v = Vector3::new(1.0, 2.0, 3.0);
assert_eq!(v.apply_norm(&UniformNorm), 3.0);
assert_eq!(v.apply_norm(&LpNorm(1)), 6.0);
assert_eq!(v.apply_norm(&EuclideanNorm), v.norm());
Source

pub fn apply_metric_distance<R2, C2, S2>( &self, rhs: &Matrix<T, R2, C2, S2>, norm: &impl Norm<T>, ) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField, R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,

Uses the metric induced by the given norm to compute the metric distance between self and rhs.

§Example

let v1 = Vector3::new(1.0, 2.0, 3.0);
let v2 = Vector3::new(10.0, 20.0, 30.0);

assert_eq!(v1.apply_metric_distance(&v2, &UniformNorm), 27.0);
assert_eq!(v1.apply_metric_distance(&v2, &LpNorm(1)), 27.0 + 18.0 + 9.0);
assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm());
Source

pub fn magnitude(&self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

A synonym for the norm of this matrix.

Aka the length.

This function is simply implemented as a call to norm()

Source

pub fn magnitude_squared(&self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

A synonym for the squared norm of this matrix.

Aka the squared length.

This function is simply implemented as a call to norm_squared()

Source

pub fn set_magnitude( &mut self, magnitude: <T as SimdComplexField>::SimdRealField, )
where T: SimdComplexField, S: StorageMut<T, R, C>,

Sets the magnitude of this vector.

Source

pub fn normalize( &self, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: SimdComplexField, DefaultAllocator: Allocator<R, C>,

Returns a normalized version of this matrix.

Source

pub fn lp_norm(&self, p: i32) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

The Lp norm of this matrix.

Source

pub fn simd_try_normalize( &self, min_norm: <T as SimdComplexField>::SimdRealField, ) -> SimdOption<Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>>
where T: SimdComplexField, <T as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<R, C>,

Attempts to normalize self.

The components of this matrix can be SIMD types.

Source

pub fn try_set_magnitude( &mut self, magnitude: <T as ComplexField>::RealField, min_magnitude: <T as ComplexField>::RealField, )
where T: ComplexField, S: StorageMut<T, R, C>,

Sets the magnitude of this vector unless it is smaller than min_magnitude.

If self.magnitude() is smaller than min_magnitude, it will be left unchanged. Otherwise this is equivalent to: *self = self.normalize() * magnitude.

Source

pub fn cap_magnitude( &self, max: <T as ComplexField>::RealField, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: ComplexField, DefaultAllocator: Allocator<R, C>,

Returns a new vector with the same magnitude as self clamped between 0.0 and max.

Source

pub fn simd_cap_magnitude( &self, max: <T as SimdComplexField>::SimdRealField, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: SimdComplexField, <T as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<R, C>,

Returns a new vector with the same magnitude as self clamped between 0.0 and max.

Source

pub fn try_normalize( &self, min_norm: <T as ComplexField>::RealField, ) -> Option<Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>>
where T: ComplexField, DefaultAllocator: Allocator<R, C>,

Returns a normalized version of this matrix unless its norm as smaller or equal to eps.

The components of this matrix cannot be SIMD types (see simd_try_normalize) instead.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>,

§In-place normalization

Source

pub fn normalize_mut(&mut self) -> <T as SimdComplexField>::SimdRealField
where T: SimdComplexField,

Normalizes this matrix in-place and returns its norm.

The components of the matrix cannot be SIMD types (see simd_try_normalize_mut instead).

Source

pub fn simd_try_normalize_mut( &mut self, min_norm: <T as SimdComplexField>::SimdRealField, ) -> SimdOption<<T as SimdComplexField>::SimdRealField>
where T: SimdComplexField, <T as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<R, C>,

Normalizes this matrix in-place and return its norm.

The components of the matrix can be SIMD types.

Source

pub fn try_normalize_mut( &mut self, min_norm: <T as ComplexField>::RealField, ) -> Option<<T as ComplexField>::RealField>
where T: ComplexField,

Normalizes this matrix in-place or does nothing if its norm is smaller or equal to eps.

If the normalization succeeded, returns the old norm of this matrix.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + ClosedNeg, S: StorageMut<T, R, C>,

Source

pub fn neg_mut(&mut self)

Negates self in-place.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source

pub fn len(&self) -> usize

The total number of elements of this matrix.

§Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.len(), 12);
Source

pub fn is_empty(&self) -> bool

Returns true if the matrix contains no elements.

§Examples:
let mat = Matrix3x4::<f32>::zeros();
assert!(!mat.is_empty());
Source

pub fn is_square(&self) -> bool

Indicates if this is a square matrix.

Source

pub fn is_identity(&self, eps: <T as AbsDiffEq>::Epsilon) -> bool
where T: Zero + One + RelativeEq, <T as AbsDiffEq>::Epsilon: Clone,

Indicated if this is the identity matrix within a relative error of eps.

If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates (i, i) for i from 0 to min(R, C)) are equal one; and that all other elements are zero.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>,

Source

pub fn is_orthogonal(&self, eps: <T as AbsDiffEq>::Epsilon) -> bool
where T: Zero + One + ClosedAddAssign + ClosedMulAssign + RelativeEq, S: Storage<T, R, C>, <T as AbsDiffEq>::Epsilon: Clone, DefaultAllocator: Allocator<R, C> + Allocator<C, C>,

Checks that Mᵀ × M = Id.

In this definition Id is approximately equal to the identity matrix with a relative error equal to eps.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Common statistics operations

Source

pub fn sum(&self) -> T
where T: ClosedAddAssign + Zero,

The sum of all the elements of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.sum(), 21.0);
Source

pub fn row_sum( &self, ) -> Matrix<T, Const<1>, C, <DefaultAllocator as Allocator<Const<1>, C>>::Buffer<T>>
where T: ClosedAddAssign + Zero, DefaultAllocator: Allocator<Const<1>, C>,

The sum of all the rows of this matrix.

Use .row_sum_tr if you need the result in a column vector instead.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_sum(), RowVector3::new(5.0, 7.0, 9.0));

let mint = Matrix3x2::new(1, 2,
                          3, 4,
                          5, 6);
assert_eq!(mint.row_sum(), RowVector2::new(9,12));
Source

pub fn row_sum_tr( &self, ) -> Matrix<T, C, Const<1>, <DefaultAllocator as Allocator<C>>::Buffer<T>>
where T: ClosedAddAssign + Zero, DefaultAllocator: Allocator<C>,

The sum of all the rows of this matrix. The result is transposed and returned as a column vector.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_sum_tr(), Vector3::new(5.0, 7.0, 9.0));

let mint = Matrix3x2::new(1, 2,
                          3, 4,
                          5, 6);
assert_eq!(mint.row_sum_tr(), Vector2::new(9, 12));
Source

pub fn column_sum( &self, ) -> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>
where T: ClosedAddAssign + Zero, DefaultAllocator: Allocator<R>,

The sum of all the columns of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.column_sum(), Vector2::new(6.0, 15.0));

let mint = Matrix3x2::new(1, 2,
                          3, 4,
                          5, 6);
assert_eq!(mint.column_sum(), Vector3::new(3, 7, 11));
Source

pub fn product(&self) -> T
where T: ClosedMulAssign + One,

The product of all the elements of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.product(), 720.0);
Source

pub fn row_product( &self, ) -> Matrix<T, Const<1>, C, <DefaultAllocator as Allocator<Const<1>, C>>::Buffer<T>>
where T: ClosedMulAssign + One, DefaultAllocator: Allocator<Const<1>, C>,

The product of all the rows of this matrix.

Use .row_sum_tr if you need the result in a column vector instead.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_product(), RowVector3::new(4.0, 10.0, 18.0));

let mint = Matrix3x2::new(1, 2,
                          3, 4,
                          5, 6);
assert_eq!(mint.row_product(), RowVector2::new(15, 48));
Source

pub fn row_product_tr( &self, ) -> Matrix<T, C, Const<1>, <DefaultAllocator as Allocator<C>>::Buffer<T>>
where T: ClosedMulAssign + One, DefaultAllocator: Allocator<C>,

The product of all the rows of this matrix. The result is transposed and returned as a column vector.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_product_tr(), Vector3::new(4.0, 10.0, 18.0));

let mint = Matrix3x2::new(1, 2,
                          3, 4,
                          5, 6);
assert_eq!(mint.row_product_tr(), Vector2::new(15, 48));
Source

pub fn column_product( &self, ) -> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>
where T: ClosedMulAssign + One, DefaultAllocator: Allocator<R>,

The product of all the columns of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.column_product(), Vector2::new(6.0, 120.0));

let mint = Matrix3x2::new(1, 2,
                          3, 4,
                          5, 6);
assert_eq!(mint.column_product(), Vector3::new(2, 12, 30));
Source

pub fn variance(&self) -> T
where T: Field + SupersetOf<f64>,

The variance of all the elements of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8);
Source

pub fn row_variance( &self, ) -> Matrix<T, Const<1>, C, <DefaultAllocator as Allocator<Const<1>, C>>::Buffer<T>>
where T: Field + SupersetOf<f64>, DefaultAllocator: Allocator<Const<1>, C>,

The variance of all the rows of this matrix.

Use .row_variance_tr if you need the result in a column vector instead.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25));
Source

pub fn row_variance_tr( &self, ) -> Matrix<T, C, Const<1>, <DefaultAllocator as Allocator<C>>::Buffer<T>>
where T: Field + SupersetOf<f64>, DefaultAllocator: Allocator<C>,

The variance of all the rows of this matrix. The result is transposed and returned as a column vector.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25));
Source

pub fn column_variance( &self, ) -> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>
where T: Field + SupersetOf<f64>, DefaultAllocator: Allocator<R>,

The variance of all the columns of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8);
Source

pub fn mean(&self) -> T
where T: Field + SupersetOf<f64>,

The mean of all the elements of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.mean(), 3.5);
Source

pub fn row_mean( &self, ) -> Matrix<T, Const<1>, C, <DefaultAllocator as Allocator<Const<1>, C>>::Buffer<T>>
where T: Field + SupersetOf<f64>, DefaultAllocator: Allocator<Const<1>, C>,

The mean of all the rows of this matrix.

Use .row_mean_tr if you need the result in a column vector instead.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5));
Source

pub fn row_mean_tr( &self, ) -> Matrix<T, C, Const<1>, <DefaultAllocator as Allocator<C>>::Buffer<T>>
where T: Field + SupersetOf<f64>, DefaultAllocator: Allocator<C>,

The mean of all the rows of this matrix. The result is transposed and returned as a column vector.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5));
Source

pub fn column_mean( &self, ) -> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>
where T: Field + SupersetOf<f64>, DefaultAllocator: Allocator<R>,

The mean of all the columns of this matrix.

§Example

let m = Matrix2x3::new(1.0, 2.0, 3.0,
                       4.0, 5.0, 6.0);
assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0));
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>,

§Folding on columns and rows

Source

pub fn compress_rows( &self, f: impl Fn(Matrix<T, R, Const<1>, ViewStorage<'_, T, R, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) -> T, ) -> Matrix<T, Const<1>, C, <DefaultAllocator as Allocator<Const<1>, C>>::Buffer<T>>

Returns a row vector where each element is the result of the application of f on the corresponding column of the original matrix.

Source

pub fn compress_rows_tr( &self, f: impl Fn(Matrix<T, R, Const<1>, ViewStorage<'_, T, R, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) -> T, ) -> Matrix<T, C, Const<1>, <DefaultAllocator as Allocator<C>>::Buffer<T>>

Returns a column vector where each element is the result of the application of f on the corresponding column of the original matrix.

This is the same as self.compress_rows(f).transpose().

Source

pub fn compress_columns( &self, init: Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>, f: impl Fn(&mut Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>, Matrix<T, R, Const<1>, ViewStorage<'_, T, R, Const<1>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>), ) -> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>

Returns a column vector resulting from the folding of f on each column of this matrix.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>,

§Rectangular matrix decomposition

This section contains the methods for computing some common decompositions of rectangular matrices with real or complex components. The following are currently supported:

DecompositionFactorsDetails
QRQ * RQ is an unitary matrix, and R is upper-triangular.
QR with column pivotingQ * R * P⁻¹Q is an unitary matrix, and R is upper-triangular. P is a permutation matrix.
LU with partial pivotingP⁻¹ * L * UL is lower-triangular with a diagonal filled with 1 and U is upper-triangular. P is a permutation matrix.
LU with full pivotingP⁻¹ * L * U * Q⁻¹L is lower-triangular with a diagonal filled with 1 and U is upper-triangular. P and Q are permutation matrices.
SVDU * Σ * VᵀU and V are two orthogonal matrices and Σ is a diagonal matrix containing the singular values.
Polar (Left Polar)P' * UU is semi-unitary/unitary and P' is a positive semi-definite Hermitian Matrix
Source

pub fn bidiagonalize(self) -> Bidiagonal<T, R, C>
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<R as DimMin<C>>::Output> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output>,

Computes the bidiagonalization using householder reflections.

Source

pub fn full_piv_lu(self) -> FullPivLU<T, R, C>
where R: DimMin<C>, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>,

Computes the LU decomposition with full pivoting of matrix.

This effectively computes P, L, U, Q such that P * matrix * Q = LU.

Source

pub fn lu(self) -> LU<T, R, C>
where R: DimMin<C>, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>,

Computes the LU decomposition with partial (row) pivoting of matrix.

Source

pub fn qr(self) -> QR<T, R, C>
where R: DimMin<C>, DefaultAllocator: Allocator<R, C> + Allocator<R> + Allocator<<R as DimMin<C>>::Output>,

Computes the QR decomposition of this matrix.

Source

pub fn col_piv_qr(self) -> ColPivQR<T, R, C>
where R: DimMin<C>, DefaultAllocator: Allocator<R, C> + Allocator<R> + Allocator<<R as DimMin<C>>::Output>,

Computes the QR decomposition (with column pivoting) of this matrix.

Source

pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output>,

Computes the Singular Value Decomposition using implicit shift. The singular values are guaranteed to be sorted in descending order. If this order is not required consider using svd_unordered.

Source

pub fn svd_unordered(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output>,

Computes the Singular Value Decomposition using implicit shift. The singular values are not guaranteed to be sorted in any particular order. If a descending order is required, consider using svd instead.

Source

pub fn try_svd( self, compute_u: bool, compute_v: bool, eps: <T as ComplexField>::RealField, max_niter: usize, ) -> Option<SVD<T, R, C>>
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output>,

Attempts to compute the Singular Value Decomposition of matrix using implicit shift. The singular values are guaranteed to be sorted in descending order. If this order is not required consider using try_svd_unordered.

§Arguments
  • compute_u − set this to true to enable the computation of left-singular vectors.
  • compute_v − set this to true to enable the computation of right-singular vectors.
  • eps − tolerance used to determine when a value converged to 0.
  • max_niter − maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded, None is returned. If niter == 0, then the algorithm continues indefinitely until convergence.
Source

pub fn try_svd_unordered( self, compute_u: bool, compute_v: bool, eps: <T as ComplexField>::RealField, max_niter: usize, ) -> Option<SVD<T, R, C>>
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output>,

Attempts to compute the Singular Value Decomposition of matrix using implicit shift. The singular values are not guaranteed to be sorted in any particular order. If a descending order is required, consider using try_svd instead.

§Arguments
  • compute_u − set this to true to enable the computation of left-singular vectors.
  • compute_v − set this to true to enable the computation of right-singular vectors.
  • eps − tolerance used to determine when a value converged to 0.
  • max_niter − maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded, None is returned. If niter == 0, then the algorithm continues indefinitely until convergence.
Source

pub fn polar( self, ) -> (Matrix<T, R, R, <DefaultAllocator as Allocator<R, R>>::Buffer<T>>, Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>)
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output, R> + Allocator<<R as DimMin<C>>::Output> + Allocator<R, R> + Allocator<<R as DimMin<C>>::Output, <R as DimMin<C>>::Output> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output>,

Computes the Polar Decomposition of a matrix (indirectly uses SVD).

Source

pub fn try_polar( self, eps: <T as ComplexField>::RealField, max_niter: usize, ) -> Option<(Matrix<T, R, R, <DefaultAllocator as Allocator<R, R>>::Buffer<T>>, Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>)>
where R: DimMin<C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output, R> + Allocator<<R as DimMin<C>>::Output> + Allocator<R, R> + Allocator<<R as DimMin<C>>::Output, <R as DimMin<C>>::Output> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output>,

Attempts to compute the Polar Decomposition of a matrix (indirectly uses SVD).

§Arguments
  • eps − tolerance used to determine when a value converged to 0 when computing the SVD.
  • max_niter − maximum total number of iterations performed by the SVD computation algorithm.
Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output>,

Source

pub fn singular_values_unordered( &self, ) -> Matrix<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1>, <DefaultAllocator as Allocator<<R as DimMin<C>>::Output>>::Buffer<<T as ComplexField>::RealField>>

Computes the singular values of this matrix. The singular values are not guaranteed to be sorted in any particular order. If a descending order is required, consider using singular_values instead.

Source

pub fn rank(&self, eps: <T as ComplexField>::RealField) -> usize

Computes the rank of this matrix.

All singular values below eps are considered equal to 0.

Source

pub fn pseudo_inverse( self, eps: <T as ComplexField>::RealField, ) -> Result<Matrix<T, C, R, <DefaultAllocator as Allocator<C, R>>::Buffer<T>>, &'static str>

Computes the pseudo-inverse of this matrix.

All singular values below eps are considered equal to 0.

Source§

impl<T, R, C, S> Matrix<T, R, C, S>
where T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>, <R as DimMin<C>>::Output: DimSub<Const<1>>, DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<<<R as DimMin<C>>::Output as DimSub<Const<1>>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output>,

Source

pub fn singular_values( &self, ) -> Matrix<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1>, <DefaultAllocator as Allocator<<R as DimMin<C>>::Output>>::Buffer<<T as ComplexField>::RealField>>

Computes the singular values of this matrix. The singular values are guaranteed to be sorted in descending order. If this order is not required consider using singular_values_unordered.

Source§

impl<T, R> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

§Constructors of matrices with a dynamic number of columns

Source

pub fn from_element( ncols: usize, elem: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Creates a matrix or vector with all its elements set to elem.

§Example

let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Source

pub fn repeat( ncols: usize, elem: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Creates a matrix or vector with all its elements set to elem.

Same as .from_element.

§Example

let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);

assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
        m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
        dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Source

pub fn zeros( ncols: usize, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero,

Creates a matrix or vector with all its elements set to 0.

§Example

let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);

assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
Source

pub fn from_iterator<I>( ncols: usize, iter: I, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by an iterator.

The output matrix is filled column-by-column.

§Example

let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Source

pub fn from_row_iterator<I>( ncols: usize, iter: I, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where I: IntoIterator<Item = T>,

Creates a matrix or vector with all its elements filled by a row-major iterator.

The output matrix is filled row-by-row.

§Example

let v = Vector3::from_row_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_row_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_row_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_iterator(2, 3, (0..6).into_iter());

// For Vectors from_row_iterator is identical to from_iterator
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Source

pub fn from_fn<F>( ncols: usize, f: F, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where F: FnMut(usize, usize) -> T,

Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.

§Example

let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Source

pub fn identity( ncols: usize, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero + One,

Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.

§Example

let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
Source

pub fn from_diagonal_element( ncols: usize, elt: T, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero + One,

Creates a matrix filled with its diagonal filled with elt and all other components set to zero.

§Example

let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);

assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
Source

pub fn from_partial_diagonal( ncols: usize, elts: &[T], ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
where T: Zero,

Creates a new matrix that may be rectangular. The first elts.len() diagonal elements are filled with the content of elts. Others are set to 0.

Panics if elts.len() is larger than the minimum among nrows and ncols.

§Example

let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);

assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
        m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
        m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
        dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
        dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
Source§

impl<T, R> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Source

pub fn from_row_slice( data: &[T], ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Creates a matrix with its elements filled with the components provided by a slice in row-major order.

The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.

§Example

let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(&[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
        m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
        dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Source

pub fn from_column_slice( data: &[T], ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Creates a matrix with its elements filled with the components provided by a slice in column-major order.

§Example

let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(&[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);

assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Source

pub fn from_vec( data: Vec<T>, ) -> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Creates a matrix backed by a given Vec.

The output matrix is filled column-by-column.

§Example

let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);

assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
        m.m21 == 1 && m.m22 == 3 && m.m23 == 5);


// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);

assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
        dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Source§

impl<T, R> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>

Source

pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T)
where DefaultAllocator: Reallocator<T, R, Dyn, R, Dyn>,

Changes the number of column of this matrix in-place.

The values are copied such that self[(i, j)] == result[(i, j)]. If the result has more columns than self, then the extra columns are filled with val.

Defined only for owned matrices with a dynamic number of columns (for example, DVector).

Source§

impl<T, R1, C1, S> Matrix<T, R1, C1, S>
where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

Source

pub fn ger<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

Computes self = alpha * x * y.transpose() + beta * self.

If beta is zero, self is never read.

§Example
let mut mat = Matrix2x3::repeat(4.0);
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;

mat.ger(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat, expected);
Source

pub fn gerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

Computes self = alpha * x * y.adjoint() + beta * self.

If beta is zero, self is never read.

§Example
let mut mat = Matrix2x3::repeat(Complex::new(4.0, 5.0));
let vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector3::new(Complex::new(0.6, 0.5), Complex::new(0.4, 0.5), Complex::new(0.2, 0.1));
let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0);

mat.gerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0));
assert_eq!(mat, expected);
Source

pub fn gemm<R2, C2, R3, C3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, b: &Matrix<T, R3, C3, SC>, beta: T, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, T: One, SB: Storage<T, R2, C2>, SC: Storage<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,

Computes self = alpha * a * b + beta * self, where a, b, self are matrices. alpha and beta are scalar.

If beta is zero, self is never read.

§Example
let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix2x3::new(1.0, 2.0, 3.0,
                          4.0, 5.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
                          0.5, 0.6, 0.7, 0.8,
                          0.9, 1.0, 1.1, 1.2);
let expected = mat2 * mat3 * 10.0 + mat1 * 5.0;

mat1.gemm(10.0, &mat2, &mat3, 5.0);
assert_relative_eq!(mat1, expected);
Source

pub fn gemm_tr<R2, C2, R3, C3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, b: &Matrix<T, R3, C3, SC>, beta: T, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, T: One, SB: Storage<T, R2, C2>, SC: Storage<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,

Computes self = alpha * a.transpose() * b + beta * self, where a, b, self are matrices. alpha and beta are scalar.

If beta is zero, self is never read.

§Example
let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix3x2::new(1.0, 4.0,
                          2.0, 5.0,
                          3.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
                          0.5, 0.6, 0.7, 0.8,
                          0.9, 1.0, 1.1, 1.2);
let expected = mat2.transpose() * mat3 * 10.0 + mat1 * 5.0;

mat1.gemm_tr(10.0, &mat2, &mat3, 5.0);
assert_eq!(mat1, expected);
Source

pub fn gemm_ad<R2, C2, R3, C3, SB, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, b: &Matrix<T, R3, C3, SC>, beta: T, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, T: SimdComplexField, SB: Storage<T, R2, C2>, SC: Storage<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,

Computes self = alpha * a.adjoint() * b + beta * self, where a, b, self are matrices. alpha and beta are scalar.

If beta is zero, self is never read.

§Example
let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix3x2::new(Complex::new(1.0, 4.0), Complex::new(7.0, 8.0),
                          Complex::new(2.0, 5.0), Complex::new(9.0, 10.0),
                          Complex::new(3.0, 6.0), Complex::new(11.0, 12.0));
let mat3 = Matrix3x4::new(Complex::new(0.1, 1.3), Complex::new(0.2, 1.4), Complex::new(0.3, 1.5), Complex::new(0.4, 1.6),
                          Complex::new(0.5, 1.7), Complex::new(0.6, 1.8), Complex::new(0.7, 1.9), Complex::new(0.8, 2.0),
                          Complex::new(0.9, 2.1), Complex::new(1.0, 2.2), Complex::new(1.1, 2.3), Complex::new(1.2, 2.4));
let expected = mat2.adjoint() * mat3 * Complex::new(10.0, 20.0) + mat1 * Complex::new(5.0, 15.0);

mat1.gemm_ad(Complex::new(10.0, 20.0), &mat2, &mat3, Complex::new(5.0, 15.0));
assert_eq!(mat1, expected);
Source§

impl<T, R1, C1, S> Matrix<T, R1, C1, S>
where R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>, T: Scalar + Zero + ClosedAddAssign + ClosedMulAssign,

Source

pub fn ger_symm<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

👎Deprecated: This is renamed syger to match the original BLAS terminology.

Computes self = alpha * x * y.transpose() + beta * self, where self is a symmetric matrix.

If beta is zero, self is never read. The result is symmetric. Only the lower-triangular (including the diagonal) part of self is read/written.

§Example
let mut mat = Matrix2::identity();
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
mat.m12 = 99999.99999; // This component is on the upper-triangular part and will not be read/written.

mat.ger_symm(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, 99999.99999); // This was untouched.
Source

pub fn syger<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: One, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

Computes self = alpha * x * y.transpose() + beta * self, where self is a symmetric matrix.

For hermitian complex matrices, use .hegerc instead. If beta is zero, self is never read. The result is symmetric. Only the lower-triangular (including the diagonal) part of self is read/written.

§Example
let mut mat = Matrix2::identity();
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
mat.m12 = 99999.99999; // This component is on the upper-triangular part and will not be read/written.

mat.syger(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, 99999.99999); // This was untouched.
Source

pub fn hegerc<D2, D3, SB, SC>( &mut self, alpha: T, x: &Matrix<T, D2, Const<1>, SB>, y: &Matrix<T, D3, Const<1>, SC>, beta: T, )
where D2: Dim, D3: Dim, T: SimdComplexField, SB: Storage<T, D2>, SC: Storage<T, D3>, ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,

Computes self = alpha * x * y.adjoint() + beta * self, where self is an hermitian matrix.

If beta is zero, self is never read. The result is symmetric. Only the lower-triangular (including the diagonal) part of self is read/written.

§Example
let mut mat = Matrix2::identity();
let vec1 = Vector2::new(Complex::new(1.0, 3.0), Complex::new(2.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.2, 0.4), Complex::new(0.1, 0.3));
let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0);
mat.m12 = Complex::new(99999.99999, 88888.88888); // This component is on the upper-triangular part and will not be read/written.

mat.hegerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0));
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, Complex::new(99999.99999, 88888.88888)); // This was untouched.
Source§

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,

§Componentwise operations

Source

pub fn component_mul<R2, C2, SB>( &self, rhs: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
where T: ClosedMulAssign, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Componentwise matrix or vector multiplication.

§Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);

assert_eq!(a.component_mul(&b), expected);
Source

pub fn cmpy<R2, C2, SB, R3, C3, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, b: &Matrix<T, R3, C3, SC>, beta: T, )
where T: ClosedMulAssign<Output = T> + Zero<Output = T> + Mul + Add, R2: Dim, C2: Dim, R3: Dim, C3: Dim, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, SC: Storage<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Computes componentwise self[i] = alpha * a[i] * b[i] + beta * self[i].

§Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_mul(&b) * 5.0) + m * 10.0;

m.cmpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);
Source

pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
where T: ClosedMulAssign, R2: Dim, C2: Dim, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Inplace componentwise matrix or vector multiplication.

§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);

a.component_mul_assign(&b);

assert_eq!(a, expected);
Source

pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
where T: ClosedMulAssign, R2: Dim, C2: Dim, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

👎Deprecated: This is renamed using the _assign suffix instead of the _mut suffix.

Inplace componentwise matrix or vector multiplication.

§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);

a.component_mul_assign(&b);

assert_eq!(a, expected);
Source

pub fn component_div<R2, C2, SB>( &self, rhs: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
where T: ClosedDivAssign, R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Componentwise matrix or vector division.

§Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);

assert_eq!(a.component_div(&b), expected);
Source

pub fn cdpy<R2, C2, SB, R3, C3, SC>( &mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, b: &Matrix<T, R3, C3, SC>, beta: T, )
where T: ClosedDivAssign + Zero<Output = T> + Mul<Output = T> + Add, R2: Dim, C2: Dim, R3: Dim, C3: Dim, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, SC: Storage<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Computes componentwise self[i] = alpha * a[i] / b[i] + beta * self[i].

§Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_div(&b) * 5.0) + m * 10.0;

m.cdpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);
Source

pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
where T: ClosedDivAssign, R2: Dim, C2: Dim, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Inplace componentwise matrix or vector division.

§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);

a.component_div_assign(&b);

assert_eq!(a, expected);
Source

pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
where T: ClosedDivAssign, R2: Dim, C2: Dim, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

👎Deprecated: This is renamed using the _assign suffix instead of the _mut suffix.

Inplace componentwise matrix or vector division.

§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);

a.component_div_assign(&b);

assert_eq!(a, expected);
Source

pub fn inf( &self, other: &Matrix<T, R1, C1, SA>, ) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>
where T: SimdPartialOrd, DefaultAllocator: Allocator<R1, C1>,

Computes the infimum (aka. componentwise min) of two matrices/vectors.

§Example
let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = Matrix2::new(2.0, 2.0, -2.0, -2.0);
assert_eq!(u.inf(&v), expected)
Source

pub fn sup( &self, other: &Matrix<T, R1, C1, SA>, ) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>
where T: SimdPartialOrd, DefaultAllocator: Allocator<R1, C1>,

Computes the supremum (aka. componentwise max) of two matrices/vectors.

§Example
let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = Matrix2::new(4.0, 4.0, 1.0, 1.0);
assert_eq!(u.sup(&v), expected)
Source

pub fn inf_sup( &self, other: &Matrix<T, R1, C1, SA>, ) -> (Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>, Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>)
where T: SimdPartialOrd, DefaultAllocator: Allocator<R1, C1>,

Computes the (infimum, supremum) of two matrices/vectors.

§Example
let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = (Matrix2::new(2.0, 2.0, -2.0, -2.0), Matrix2::new(4.0, 4.0, 1.0, 1.0));
assert_eq!(u.inf_sup(&v), expected)
Source

pub fn add_scalar( &self, rhs: T, ) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T>>
where T: ClosedAddAssign, DefaultAllocator: Allocator<R1, C1>,

Adds a scalar to self.

§Example
let u = Matrix2::new(1.0, 2.0, 3.0, 4.0);
let s = 10.0;
let expected = Matrix2::new(11.0, 12.0, 13.0, 14.0);
assert_eq!(u.add_scalar(s), expected)
Source

pub fn add_scalar_mut(&mut self, rhs: T)
where T: ClosedAddAssign, SA: StorageMut<T, R1, C1>,

Adds a scalar to self in-place.

§Example
let mut u = Matrix2::new(1.0, 2.0, 3.0, 4.0);
let s = 10.0;
u.add_scalar_mut(s);
let expected = Matrix2::new(11.0, 12.0, 13.0, 14.0);
assert_eq!(u, expected)
Source§

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, T: Scalar + ClosedAddAssign,

Source

pub fn add_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<T, R2, C2, SB>, out: &mut Matrix<T, R3, C3, SC>, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB: Storage<T, R2, C2>, SC: StorageMut<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Equivalent to self + rhs but stores the result into out to avoid allocations.

Source§

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, T: Scalar + ClosedSubAssign,

Source

pub fn sub_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<T, R2, C2, SB>, out: &mut Matrix<T, R3, C3, SC>, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB: Storage<T, R2, C2>, SC: StorageMut<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,

Equivalent to self + rhs but stores the result into out to avoid allocations.

Source§

impl<T, R1, C1, SA> Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SA: Storage<T, R1, C1>,

§Special multiplications.

Source

pub fn tr_mul<R2, C2, SB>( &self, rhs: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, C1, C2, <DefaultAllocator as Allocator<C1, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>,

Equivalent to self.transpose() * rhs.

Source

pub fn ad_mul<R2, C2, SB>( &self, rhs: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, C1, C2, <DefaultAllocator as Allocator<C1, C2>>::Buffer<T>>
where R2: Dim, C2: Dim, T: SimdComplexField, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<C1, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>,

Equivalent to self.adjoint() * rhs.

Source

pub fn tr_mul_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<T, R2, C2, SB>, out: &mut Matrix<T, R3, C3, SC>, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB: Storage<T, R2, C2>, SC: StorageMut<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,

Equivalent to self.transpose() * rhs but stores the result into out to avoid allocations.

Source

pub fn ad_mul_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<T, R2, C2, SB>, out: &mut Matrix<T, R3, C3, SC>, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, T: SimdComplexField, SB: Storage<T, R2, C2>, SC: StorageMut<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,

Equivalent to self.adjoint() * rhs but stores the result into out to avoid allocations.

Source

pub fn mul_to<R2, C2, SB, R3, C3, SC>( &self, rhs: &Matrix<T, R2, C2, SB>, out: &mut Matrix<T, R3, C3, SC>, )
where R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB: Storage<T, R2, C2>, SC: StorageMut<T, R3, C3>, ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,

Equivalent to self * rhs but stores the result into out to avoid allocations.

Source

pub fn kronecker<R2, C2, SB>( &self, rhs: &Matrix<T, R2, C2, SB>, ) -> Matrix<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<<R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer<T>>
where R2: Dim, C2: Dim, T: ClosedMulAssign, R1: DimMul<R2>, C1: DimMul<C2>, SB: Storage<T, R2, C2>, DefaultAllocator: Allocator<<R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,

The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).

Trait Implementations

Source§

impl<T, R, C, S> AbsDiffEq for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + AbsDiffEq, S: RawStorage<T, R, C>, <T as AbsDiffEq>::Epsilon: Clone,

Source§

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.
Source§

fn default_epsilon() -> <Matrix<T, R, C, S> as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together. Read more
Source§

fn abs_diff_eq( &self, other: &Matrix<T, R, C, S>, epsilon: <Matrix<T, R, C, S> as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.
§

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].
Source§

impl<'b, T, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedAddAssign, SA: Storage<T, R1, C1>, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>

The resulting type after applying the + operator.
Source§

fn add( self, rhs: &'b Matrix<T, R2, C2, SB>, ) -> <Matrix<T, R1, C1, SA> as Add<&'b Matrix<T, R2, C2, SB>>>::Output

Performs the + operation. Read more
Source§

impl<T, R1, C1, R2, C2, SA, SB> Add<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedAddAssign, SA: Storage<T, R1, C1>, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>

The resulting type after applying the + operator.
Source§

fn add( self, rhs: Matrix<T, R2, C2, SB>, ) -> <Matrix<T, R1, C1, SA> as Add<Matrix<T, R2, C2, SB>>>::Output

Performs the + operation. Read more
Source§

impl<'b, T, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedAddAssign, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

fn add_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>)

Performs the += operation. Read more
Source§

impl<T, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedAddAssign, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

fn add_assign(&mut self, rhs: Matrix<T, R2, C2, SB>)

Performs the += operation. Read more
Source§

impl<T, R, C, S> AsRef<[T]> for Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous,

Source§

fn as_ref(&self) -> &[T]

Extracts a slice containing the entire matrix entries ordered column-by-columns.

Source§

impl<T, R, C, S> Binary for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + Binary, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, R, C> Bounded for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Source§

fn max_value() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Returns the largest finite number this type can represent
Source§

fn min_value() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Returns the smallest finite number this type can represent
Source§

impl<T, R, C, S> Clone for Matrix<T, R, C, S>
where T: Clone, R: Clone, C: Clone, S: Clone,

Source§

fn clone(&self) -> Matrix<T, R, C, S>

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

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

Performs copy-assignment from source. Read more
Source§

impl<T, R, C, S> Debug for Matrix<T, R, C, S>
where R: Dim, C: Dim, S: Debug,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, R, C, S> Default for Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Default,

Source§

fn default() -> Matrix<T, R, C, S>

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

impl<'de, T, R, C, S> Deserialize<'de> for Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Deserialize<'de>,

Source§

fn deserialize<D>( deserializer: D, ) -> Result<Matrix<T, R, C, S>, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl<T, R, C, S> Display for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + Display, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA>
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

Source§

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<R1, Const<D2>>>::Buffer<T>>

The resulting type after applying the / operator.
Source§

fn div( self, right: &'b Rotation<T, D2>, ) -> <Matrix<T, R1, C1, SA> as Div<&'b Rotation<T, D2>>>::Output

Performs the / operation. Read more
Source§

impl<T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for Matrix<T, R1, C1, SA>
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

Source§

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<R1, Const<D2>>>::Buffer<T>>

The resulting type after applying the / operator.
Source§

fn div( self, right: Rotation<T, D2>, ) -> <Matrix<T, R1, C1, SA> as Div<Rotation<T, D2>>>::Output

Performs the / operation. Read more
Source§

impl<T, R, C, S> Div<T> for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + ClosedDivAssign, S: Storage<T, R, C>, DefaultAllocator: Allocator<R, C>,

Source§

type Output = Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

The resulting type after applying the / operator.
Source§

fn div(self, rhs: T) -> <Matrix<T, R, C, S> as Div<T>>::Output

Performs the / operation. Read more
Source§

impl<T, R, C, S> DivAssign<T> for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + ClosedDivAssign, S: StorageMut<T, R, C>,

Source§

fn div_assign(&mut self, rhs: T)

Performs the /= operation. Read more
Source§

impl<T, R, S, RV, SV> Extend<Matrix<T, RV, Const<1>, SV>> for Matrix<T, R, Dyn, S>
where T: Scalar, R: Dim, S: Extend<Matrix<T, RV, Const<1>, SV>>, RV: Dim, SV: RawStorage<T, RV>, ShapeConstraint: SameNumberOfRows<R, RV>,

Source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = Matrix<T, RV, Const<1>, SV>>,

Extends the number of columns of a Matrix with Vectors from a given iterator.

§Example

let data = vec![0, 1, 2,          // column 1
                3, 4, 5];         // column 2

let mut matrix = DMatrix::from_vec(3, 2, data);

matrix.extend(
  vec![Vector3::new(6,  7,  8),   // column 3
       Vector3::new(9, 10, 11)]); // column 4

assert!(matrix.eq(&Matrix3x4::new(0, 3, 6,  9,
                                  1, 4, 7, 10,
                                  2, 5, 8, 11)));
§Panics

This function panics if the dimension of each Vector yielded by the given iterator is not equal to the number of rows of this Matrix.

let mut matrix =
  DMatrix::from_vec(3, 2,
                    vec![0, 1, 2,   // column 1
                         3, 4, 5]); // column 2

// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
  vec![Vector2::new(6,  7)]); // too few dimensions!
let mut matrix =
  DMatrix::from_vec(3, 2,
                    vec![0, 1, 2,   // column 1
                         3, 4, 5]); // column 2

// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
  vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!
Source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
Source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
Source§

impl<T, R, S> Extend<T> for Matrix<T, R, Dyn, S>
where T: Scalar, R: Dim, S: Extend<T>,

Extend the number of columns of the Matrix with elements from a given iterator.

Source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = T>,

Extend the number of columns of the Matrix with elements from the given iterator.

§Example

let data = vec![0, 1, 2,      // column 1
                3, 4, 5];     // column 2

let mut matrix = DMatrix::from_vec(3, 2, data);

matrix.extend(vec![6, 7, 8]); // column 3

assert!(matrix.eq(&Matrix3::new(0, 3, 6,
                                1, 4, 7,
                                2, 5, 8)));
§Panics

This function panics if the number of elements yielded by the given iterator is not a multiple of the number of rows of the Matrix.

let data = vec![0, 1, 2,  // column 1
                3, 4, 5]; // column 2

let mut matrix = DMatrix::from_vec(3, 2, data);

// The following panics because the vec length is not a multiple of 3.
matrix.extend(vec![6, 7, 8, 9]);
Source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
Source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
Source§

impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 16]> for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 16]>, R: Dim, C: Dim, <T as SimdValue>::Element: Scalar + SimdValue, DefaultAllocator: Allocator<R, C>,

Source§

fn from( arr: [Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 16], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 2]> for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 2]>, R: Dim, C: Dim, <T as SimdValue>::Element: Scalar + SimdValue, DefaultAllocator: Allocator<R, C>,

Source§

fn from( arr: [Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 2], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 4]> for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 4]>, R: Dim, C: Dim, <T as SimdValue>::Element: Scalar + SimdValue, DefaultAllocator: Allocator<R, C>,

Source§

fn from( arr: [Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 4], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 8]> for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 8]>, R: Dim, C: Dim, <T as SimdValue>::Element: Scalar + SimdValue, DefaultAllocator: Allocator<R, C>,

Source§

fn from( arr: [Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>; 8], ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, R, const D: usize> From<Isometry<T, R, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>
where T: SimdRealField, Const<D>: DimNameAdd<Const<1>>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>>, DefaultAllocator: Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

Source§

fn from( iso: Isometry<T, R, D>, ) -> Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<'a, T, R, RStride, CStride> From<Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, RStride, CStride>>> for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
where T: Scalar, R: DimName, RStride: Dim, CStride: Dim,

Source§

fn from( matrix_view: Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, RStride, CStride>>, ) -> Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>

Converts to this type from the input type.
Source§

impl<'a, T, R, RStride, CStride> From<Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, RStride, CStride>>> for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
where T: Scalar, R: DimName, RStride: Dim, CStride: Dim,

Source§

fn from( matrix_view: Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, RStride, CStride>>, ) -> Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>

Converts to this type from the input type.
Source§

impl<T, const D: usize> From<Scale<T, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Source§

fn from( t: Scale<T, D>, ) -> Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, R, const D: usize> From<Similarity<T, R, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>
where T: SimdRealField, Const<D>: DimNameAdd<Const<1>>, R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>>, DefaultAllocator: Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

Source§

fn from( sim: Similarity<T, R, D>, ) -> Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, C, const D: usize> From<Transform<T, C, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>
where T: RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

Source§

fn from( t: Transform<T, C, D>, ) -> Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, const D: usize> From<Translation<T, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Source§

fn from( t: Translation<T, D>, ) -> Matrix<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T>>

Converts to this type from the input type.
Source§

impl<T, R, C, S> Hash for Matrix<T, R, C, S>
where T: Scalar + Hash, R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source§

fn hash<H>(&self, state: &mut H)
where H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl<T, R, C, S> Index<(usize, usize)> for Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source§

type Output = T

The returned type after indexing.
Source§

fn index( &self, ij: (usize, usize), ) -> &<Matrix<T, R, C, S> as Index<(usize, usize)>>::Output

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

impl<T, R, C, S> Index<usize> for Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorage<T, R, C>,

Source§

type Output = T

The returned type after indexing.
Source§

fn index(&self, i: usize) -> &<Matrix<T, R, C, S> as Index<usize>>::Output

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

impl<T, R, C, S> IndexMut<(usize, usize)> for Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

Source§

fn index_mut(&mut self, ij: (usize, usize)) -> &mut T

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

impl<T, R, C, S> IndexMut<usize> for Matrix<T, R, C, S>
where R: Dim, C: Dim, S: RawStorageMut<T, R, C>,

Source§

fn index_mut(&mut self, i: usize) -> &mut T

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

impl<T, R, C, S> LowerExp for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + LowerExp, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, R, C, S> LowerHex for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + LowerHex, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SB: Storage<T, R2, C2>, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

Source§

type Output = Matrix<T, R1, C2, <DefaultAllocator as Allocator<R1, C2>>::Buffer<T>>

The resulting type after applying the * operator.
Source§

fn mul( self, rhs: &'b Matrix<T, R2, C2, SB>, ) -> <Matrix<T, R1, C1, SA> as Mul<&'b Matrix<T, R2, C2, SB>>>::Output

Performs the * operation. Read more
Source§

impl<'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA>
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

Source§

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<R1, Const<D2>>>::Buffer<T>>

The resulting type after applying the * operator.
Source§

fn mul( self, right: &'b Rotation<T, D2>, ) -> <Matrix<T, R1, C1, SA> as Mul<&'b Rotation<T, D2>>>::Output

Performs the * operation. Read more
Source§

impl<T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SB: Storage<T, R2, C2>, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<R1, C2>, ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,

Source§

type Output = Matrix<T, R1, C2, <DefaultAllocator as Allocator<R1, C2>>::Buffer<T>>

The resulting type after applying the * operator.
Source§

fn mul( self, rhs: Matrix<T, R2, C2, SB>, ) -> <Matrix<T, R1, C1, SA> as Mul<Matrix<T, R2, C2, SB>>>::Output

Performs the * operation. Read more
Source§

impl<T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for Matrix<T, R1, C1, SA>
where T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,

Source§

type Output = Matrix<T, R1, Const<D2>, <DefaultAllocator as Allocator<R1, Const<D2>>>::Buffer<T>>

The resulting type after applying the * operator.
Source§

fn mul( self, right: Rotation<T, D2>, ) -> <Matrix<T, R1, C1, SA> as Mul<Rotation<T, D2>>>::Output

Performs the * operation. Read more
Source§

impl<T, R, C, S> Mul<T> for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + ClosedMulAssign, S: Storage<T, R, C>, DefaultAllocator: Allocator<R, C>,

Source§

type Output = Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: T) -> <Matrix<T, R, C, S> as Mul<T>>::Output

Performs the * operation. Read more
Source§

impl<'b, T, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SB: Storage<T, R2, C1>, SA: StorageMut<T, R1, C1> + IsContiguous + Clone, ShapeConstraint: AreMultipliable<R1, C1, R2, C1>, DefaultAllocator: Allocator<R1, C1, Buffer<T> = SA>,

Source§

fn mul_assign(&mut self, rhs: &'b Matrix<T, R2, C1, SB>)

Performs the *= operation. Read more
Source§

impl<T, R1, C1, R2, SA, SB> MulAssign<Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign, SB: Storage<T, R2, C1>, SA: StorageMut<T, R1, C1> + IsContiguous + Clone, ShapeConstraint: AreMultipliable<R1, C1, R2, C1>, DefaultAllocator: Allocator<R1, C1, Buffer<T> = SA>,

Source§

fn mul_assign(&mut self, rhs: Matrix<T, R2, C1, SB>)

Performs the *= operation. Read more
Source§

impl<T, R, C, S> MulAssign<T> for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + ClosedMulAssign, S: StorageMut<T, R, C>,

Source§

fn mul_assign(&mut self, rhs: T)

Performs the *= operation. Read more
Source§

impl<T, R, C, S> Neg for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + ClosedNeg, S: Storage<T, R, C>, DefaultAllocator: Allocator<R, C>,

Source§

type Output = Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

The resulting type after applying the - operator.
Source§

fn neg(self) -> <Matrix<T, R, C, S> as Neg>::Output

Performs the unary - operation. Read more
Source§

impl<T, R, C> Normed for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: SimdComplexField, R: Dim, C: Dim, DefaultAllocator: Allocator<R, C>,

Source§

type Norm = <T as SimdComplexField>::SimdRealField

The type of the norm.
Source§

fn norm(&self) -> <T as SimdComplexField>::SimdRealField

Computes the norm.
Source§

fn norm_squared(&self) -> <T as SimdComplexField>::SimdRealField

Computes the squared norm.
Source§

fn scale_mut( &mut self, n: <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as Normed>::Norm, )

Multiply self by n.
Source§

fn unscale_mut( &mut self, n: <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as Normed>::Norm, )

Divides self by n.
Source§

impl<T, R, C, S> Octal for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + Octal, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, D> One for Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimName, T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, DefaultAllocator: Allocator<D, D>,

Source§

fn one() -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>

Returns the multiplicative identity element of Self, 1. Read more
Source§

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.
Source§

fn is_one(&self) -> bool
where Self: PartialEq,

Returns true if self is equal to the multiplicative identity. Read more
Source§

impl<T, R, R2, C, C2, S, S2> PartialEq<Matrix<T, R2, C2, S2>> for Matrix<T, R, C, S>
where T: PartialEq, C: Dim, C2: Dim, R: Dim, R2: Dim, S: RawStorage<T, R, C>, S2: RawStorage<T, R2, C2>,

Source§

fn eq(&self, right: &Matrix<T, R2, C2, S2>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<T, R, C, S> PartialOrd for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + PartialOrd, S: RawStorage<T, R, C>,

Source§

fn partial_cmp(&self, other: &Matrix<T, R, C, S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
Source§

fn lt(&self, right: &Matrix<T, R, C, S>) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
Source§

fn le(&self, right: &Matrix<T, R, C, S>) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
Source§

fn gt(&self, right: &Matrix<T, R, C, S>) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
Source§

fn ge(&self, right: &Matrix<T, R, C, S>) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl<T, R, C, S> Pointer for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + Pointer, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<'a, T, D> Product<&'a Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>> for Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimName, T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, DefaultAllocator: Allocator<D, D>,

Source§

fn product<I>( iter: I, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where I: Iterator<Item = &'a Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>>,

Takes an iterator and generates Self from the elements by multiplying the items.
Source§

impl<T, D> Product for Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where D: DimName, T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, DefaultAllocator: Allocator<D, D>,

Source§

fn product<I>( iter: I, ) -> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
where I: Iterator<Item = Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>>,

Takes an iterator and generates Self from the elements by multiplying the items.
Source§

impl<T, R, C, S> RelativeEq for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + RelativeEq, S: Storage<T, R, C>, <T as AbsDiffEq>::Epsilon: Clone,

Source§

fn default_max_relative() -> <Matrix<T, R, C, S> as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart. Read more
Source§

fn relative_eq( &self, other: &Matrix<T, R, C, S>, epsilon: <Matrix<T, R, C, S> as AbsDiffEq>::Epsilon, max_relative: <Matrix<T, R, C, S> as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.
§

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of [RelativeEq::relative_eq].
Source§

impl<T, R, C, S> Serialize for Matrix<T, R, C, S>
where T: Scalar, R: Dim, C: Dim, S: Serialize,

Source§

fn serialize<Ser>( &self, serializer: Ser, ) -> Result<<Ser as Serializer>::Ok, <Ser as Serializer>::Error>
where Ser: Serializer,

Serialize this value into the given Serde serializer. Read more
Source§

impl<T, R, C> SimdValue for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where T: Scalar + SimdValue, R: Dim, C: Dim, <T as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<R, C>,

Source§

const LANES: usize = T::LANES

The number of lanes of this SIMD value.
Source§

type Element = Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<<T as SimdValue>::Element>>

The type of the elements of each lane of this SIMD value.
Source§

type SimdBool = <T as SimdValue>::SimdBool

Type of the result of comparing two SIMD values like self.
Source§

fn splat( val: <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as SimdValue>::Element, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Initializes an SIMD value with each lanes set to val.
Source§

fn extract( &self, i: usize, ) -> <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as SimdValue>::Element

Extracts the i-th lane of self. Read more
Source§

unsafe fn extract_unchecked( &self, i: usize, ) -> <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as SimdValue>::Element

Extracts the i-th lane of self without bound-checking. Read more
Source§

fn replace( &mut self, i: usize, val: <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as SimdValue>::Element, )

Replaces the i-th lane of self by val. Read more
Source§

unsafe fn replace_unchecked( &mut self, i: usize, val: <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as SimdValue>::Element, )

Replaces the i-th lane of self by val without bound-checking. Read more
Source§

fn select( self, cond: <Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>> as SimdValue>::SimdBool, other: Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Merges self and other depending on the lanes of cond. Read more
§

fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self
where Self: Clone,

Applies a function to each lane of self. Read more
§

fn zip_map_lanes( self, b: Self, f: impl Fn(Self::Element, Self::Element) -> Self::Element, ) -> Self
where Self: Clone,

Applies a function to each lane of self paired with the corresponding lane of b. Read more
Source§

impl<'b, T, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedSubAssign, SA: Storage<T, R1, C1>, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>

The resulting type after applying the - operator.
Source§

fn sub( self, rhs: &'b Matrix<T, R2, C2, SB>, ) -> <Matrix<T, R1, C1, SA> as Sub<&'b Matrix<T, R2, C2, SB>>>::Output

Performs the - operation. Read more
Source§

impl<T, R1, C1, R2, C2, SA, SB> Sub<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedSubAssign, SA: Storage<T, R1, C1>, SB: Storage<T, R2, C2>, DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>

The resulting type after applying the - operator.
Source§

fn sub( self, rhs: Matrix<T, R2, C2, SB>, ) -> <Matrix<T, R1, C1, SA> as Sub<Matrix<T, R2, C2, SB>>>::Output

Performs the - operation. Read more
Source§

impl<'b, T, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedSubAssign, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

fn sub_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>)

Performs the -= operation. Read more
Source§

impl<T, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T: Scalar + ClosedSubAssign, SA: StorageMut<T, R1, C1>, SB: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

fn sub_assign(&mut self, rhs: Matrix<T, R2, C2, SB>)

Performs the -= operation. Read more
Source§

impl<T1, T2, R1, C1, R2, C2> SubsetOf<Matrix<T2, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T2>>> for Matrix<T1, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T1>>
where R1: Dim, C1: Dim, R2: Dim, C2: Dim, T1: Scalar, T2: Scalar + SupersetOf<T1>, DefaultAllocator: Allocator<R2, C2> + Allocator<R1, C1> + SameShapeAllocator<R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,

Source§

fn to_superset( &self, ) -> Matrix<T2, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T2>>

The inclusion map: converts self to the equivalent element of its superset.
Source§

fn is_in_subset( m: &Matrix<T2, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T2>>, ) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).
Source§

fn from_superset_unchecked( m: &Matrix<T2, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T2>>, ) -> Matrix<T1, R1, C1, <DefaultAllocator as Allocator<R1, C1>>::Buffer<T1>>

Use with care! Same as self.to_superset but without any property checks. Always succeeds.
§

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
Source§

impl<'a, T, R, C> Sum<&'a Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>> for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where R: DimName, C: DimName, T: Scalar + ClosedAddAssign + Zero, DefaultAllocator: Allocator<R, C>,

Source§

fn sum<I>( iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: Iterator<Item = &'a Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>>,

Takes an iterator and generates Self from the elements by “summing up” the items.
Source§

impl<T, R, C> Sum for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where R: DimName, C: DimName, T: Scalar + ClosedAddAssign + Zero, DefaultAllocator: Allocator<R, C>,

Source§

fn sum<I>( iter: I, ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where I: Iterator<Item = Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>>,

Takes an iterator and generates Self from the elements by “summing up” the items.
Source§

impl<T, R, C, S> UlpsEq for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + UlpsEq, S: RawStorage<T, R, C>, <T as AbsDiffEq>::Epsilon: Clone,

Source§

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart. Read more
Source§

fn ulps_eq( &self, other: &Matrix<T, R, C, S>, epsilon: <Matrix<T, R, C, S> as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.
§

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of [UlpsEq::ulps_eq].
Source§

impl<T, R, C, S> UpperExp for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + UpperExp, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, R, C, S> UpperHex for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Scalar + UpperHex, S: RawStorage<T, R, C>,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, R, C> Zero for Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>
where R: DimName, C: DimName, T: Scalar + Zero + ClosedAddAssign, DefaultAllocator: Allocator<R, C>,

Source§

fn zero() -> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>

Returns the additive identity element of Self, 0. Read more
Source§

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.
Source§

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.
Source§

impl<T, R, C, S> Copy for Matrix<T, R, C, S>
where T: Copy, R: Copy, C: Copy, S: Copy,

Source§

impl<T, R, C, S> Eq for Matrix<T, R, C, S>
where R: Dim, C: Dim, T: Eq, S: RawStorage<T, R, C>,