# [−][src]Type Definition nalgebra::base::MatrixSliceMutMN

    type MatrixSliceMutMN<'a, N, R, C, RStride = U1, CStride = R> = Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>;

A column-major mutable matrix slice with `R` rows and `C` columns.

## Methods

### `impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> MatrixSliceMutMN<'a, N, R, C, RStride, CStride>`[src]

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

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

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 mut [N],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Self`[src]

Creates a mutable 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, N: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, N, R, C>`[src]

#### `pub unsafe fn from_slice_generic_unchecked(
data: &'a mut [N],
start: usize,
nrows: R,
ncols: C
) -> Self`[src]

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

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 mut [N], nrows: R, ncols: C) -> Self`[src]

Creates a mutable 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, N: Scalar, R: DimName, C: DimName> MatrixSliceMutMN<'a, N, R, C>`[src]

#### `pub fn from_slice(data: &'a mut [N]) -> Self`[src]

Creates a new mutable matrix slice from the given data array.

Panics if `data` does not contain enough elements.

#### `pub unsafe fn from_slice_unchecked(data: &'a mut [N], start: usize) -> Self`[src]

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

### `impl<'a, N: Scalar, R: DimName, C: DimName> MatrixSliceMutMN<'a, N, R, C, Dynamic, Dynamic>`[src]

#### `pub fn from_slice_with_strides_mut(
data: &'a mut [N],
rstride: usize,
cstride: usize
) -> Self`[src]

Creates a new mutable 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 mut [N],
start: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

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

### `impl<'a, N: Scalar, R: DimName> MatrixSliceMutMN<'a, N, R, Dynamic>`[src]

#### `pub fn from_slice(data: &'a mut [N], ncols: usize) -> Self`[src]

Creates a new mutable matrix slice from the given data array.

Panics if `data` does not contain enough elements.

#### `pub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize,
ncols: usize
) -> Self`[src]

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

### `impl<'a, N: Scalar, R: DimName> MatrixSliceMutMN<'a, N, R, Dynamic, Dynamic, Dynamic>`[src]

#### `pub fn from_slice_with_strides_mut(
data: &'a mut [N],
ncols: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

Creates a new mutable 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 mut [N],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

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

### `impl<'a, N: Scalar, C: DimName> MatrixSliceMutMN<'a, N, Dynamic, C>`[src]

#### `pub fn from_slice(data: &'a mut [N], nrows: usize) -> Self`[src]

Creates a new mutable matrix slice from the given data array.

Panics if `data` does not contain enough elements.

#### `pub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize,
nrows: usize
) -> Self`[src]

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

### `impl<'a, N: Scalar, C: DimName> MatrixSliceMutMN<'a, N, Dynamic, C, Dynamic, Dynamic>`[src]

#### `pub fn from_slice_with_strides_mut(
data: &'a mut [N],
nrows: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

Creates a new mutable 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 mut [N],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

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

### `impl<'a, N: Scalar> MatrixSliceMutMN<'a, N, Dynamic, Dynamic>`[src]

#### `pub fn from_slice(data: &'a mut [N], nrows: usize, ncols: usize) -> Self`[src]

Creates a new mutable matrix slice from the given data array.

Panics if `data` does not contain enough elements.

#### `pub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize,
nrows: usize,
ncols: usize
) -> Self`[src]

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

### `impl<'a, N: Scalar> MatrixSliceMutMN<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>`[src]

#### `pub fn from_slice_with_strides_mut(
data: &'a mut [N],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

Creates a new mutable 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 mut [N],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self`[src]

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

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)