Type Alias nalgebra::base::MatrixSlice

pub type MatrixSlice<'a, T, R, C, RStride = U1, CStride = R> = Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>;

A matrix slice.

Aliased Type

struct MatrixSlice<'a, T, R, C, RStride = U1, CStride = R> {
    pub data: SliceStorage<'a, T, R, C, RStride, CStride>,
    /* private fields */
}

Fields

data: SliceStorage<'a, T, R, C, RStride, CStride>

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

impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> MatrixSlice<'a, T, R, C, RStride, CStride>

Creating matrix slices from &[T]

pub unsafe fn from_slice_with_strides_generic_unchecked( data: &'a [T], start: usize, nrows: R, ncols: C, rstride: RStride, cstride: CStride, ) -> Self

Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances.

Safety

This method is unsafe because the input data array is not checked to contain enough elements. The generic types R, C, RStride, CStride can either be type-level integers or integers wrapped with Dynamic::new().

pub fn from_slice_with_strides_generic( data: &'a [T], nrows: R, ncols: C, rstride: RStride, cstride: CStride, ) -> Self

Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.

Panics if the input data array dose not contain enough elements. The generic types R, C, RStride, CStride can either be type-level integers or integers wrapped with Dynamic::new().

impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSlice<'a, T, R, C>

pub unsafe fn from_slice_generic_unchecked( data: &'a [T], start: usize, nrows: R, ncols: C, ) -> Self

Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances.

Safety

This method is unsafe because the input data array is not checked to contain enough elements. The generic types R and C can either be type-level integers or integers wrapped with Dynamic::new().

pub fn from_slice_generic(data: &'a [T], nrows: R, ncols: C) -> Self

Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.

Panics if the input data array dose not contain enough elements. The generic types R and C can either be type-level integers or integers wrapped with Dynamic::new().

impl<'a, T: Scalar, R: DimName, C: DimName> MatrixSlice<'a, T, R, C>

pub fn from_slice(data: &'a [T]) -> Self

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_unchecked(data: &'a [T], start: usize) -> Self

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, T: Scalar, R: DimName, C: DimName> MatrixSlice<'a, T, R, C, Dynamic, Dynamic>

pub fn from_slice_with_strides( data: &'a [T], rstride: usize, cstride: usize, ) -> Self

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, rstride: usize, cstride: usize, ) -> Self

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, T: Scalar, R: DimName> MatrixSlice<'a, T, R, Dynamic>

pub fn from_slice(data: &'a [T], ncols: usize) -> Self

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_unchecked( data: &'a [T], start: usize, ncols: usize, ) -> Self

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, T: Scalar, R: DimName> MatrixSlice<'a, T, R, Dynamic, Dynamic, Dynamic>

pub fn from_slice_with_strides( data: &'a [T], ncols: usize, rstride: usize, cstride: usize, ) -> Self

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, ncols: usize, rstride: usize, cstride: usize, ) -> Self

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, T: Scalar, C: DimName> MatrixSlice<'a, T, Dynamic, C>

pub fn from_slice(data: &'a [T], nrows: usize) -> Self

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_unchecked( data: &'a [T], start: usize, nrows: usize, ) -> Self

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, T: Scalar, C: DimName> MatrixSlice<'a, T, Dynamic, C, Dynamic, Dynamic>

pub fn from_slice_with_strides( data: &'a [T], nrows: usize, rstride: usize, cstride: usize, ) -> Self

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, nrows: usize, rstride: usize, cstride: usize, ) -> Self

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

impl<'a, T: Scalar> MatrixSlice<'a, T, Dynamic, Dynamic>

pub fn from_slice(data: &'a [T], nrows: usize, ncols: usize) -> Self

Creates a new matrix slice from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_unchecked( data: &'a [T], start: usize, nrows: usize, ncols: usize, ) -> Self

Creates, without bound checking, a new matrix slice from the given data array.

impl<'a, T: Scalar> MatrixSlice<'a, T, Dynamic, Dynamic, Dynamic, Dynamic>

pub fn from_slice_with_strides( data: &'a [T], nrows: usize, ncols: usize, rstride: usize, cstride: usize, ) -> Self

Creates a new matrix slice with the specified strides from the given data array.

Panics if data does not contain enough elements.

pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, nrows: usize, ncols: usize, rstride: usize, cstride: usize, ) -> Self

Creates, without bound checking, a new matrix slice with the specified strides from the given data array.

Trait Implementations

impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix<T, R, C, S>> for MatrixSlice<'a, T, RSlice, CSlice, RStride, CStride>

where T: Scalar, R: Dim, C: Dim, RSlice: Dim, CSlice: Dim, RStride: Dim, CStride: Dim, S: RawStorage<T, R, C>, ShapeConstraint: DimEq<R, RSlice> + DimEq<C, CSlice> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,

fn from(m: &'a Matrix<T, R, C, S>) -> Self

Converts to this type from the input type.

impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for MatrixSlice<'a, T, RSlice, CSlice, RStride, CStride>

where T: Scalar, R: Dim, C: Dim, RSlice: Dim, CSlice: Dim, RStride: Dim, CStride: Dim, S: RawStorage<T, R, C>, ShapeConstraint: DimEq<R, RSlice> + DimEq<C, CSlice> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,

fn from(m: &'a mut Matrix<T, R, C, S>) -> Self

Converts to this type from the input type.

impl<'a, T, R, C, RStride, CStride> From<Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>> for MatrixSlice<'a, T, R, C, RStride, CStride>

where R: Dim, C: Dim, RStride: Dim, CStride: Dim,

fn from(slice_mut: MatrixSliceMut<'a, T, R, C, RStride, CStride>) -> Self

Converts to this type from the input type.