# [−][src]Struct nalgebra::base::SliceStorageMut

    pub struct SliceStorageMut<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> { /* fields omitted */ }

A mutable matrix data storage for mutable matrix slice. Only contains an internal mutable reference to another matrix data storage.

## Methods

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

#### `pub unsafe fn from_raw_parts(
ptr: *mut N,
shape: (R, C),
strides: (RStride, CStride)
) -> Self where
RStride: Dim,
CStride: Dim,` [src]

Create a new matrix slice without bound checking and from a raw pointer.

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

#### `pub unsafe fn new_unchecked<RStor, CStor, S>(
storage: &'a mut S,
start: (usize, usize),
shape: (R, C)
) -> SliceStorageMut<'a, N, R, C, S::RStride, S::CStride> where
RStor: Dim,
CStor: Dim,
S: StorageMut<N, RStor, CStor>,` [src]

Create a new matrix slice without bound checking.

#### `pub unsafe fn new_with_strides_unchecked<S, RStor, CStor, RStride, CStride>(
storage: &'a mut S,
start: (usize, usize),
shape: (R, C),
strides: (RStride, CStride)
) -> SliceStorageMut<'a, N, R, C, RStride, CStride> where
RStor: Dim,
CStor: Dim,
S: StorageMut<N, RStor, CStor>,
RStride: Dim,
CStride: Dim,` [src]

Create a new matrix slice without bound checking.

## Trait Implementations

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

#### `type RStride = RStride`

The static stride of this storage's rows.

#### `type CStride = CStride`

The static stride of this storage's columns.

#### `fn ptr(&self) -> *const N`[src]

The matrix data pointer.

#### `fn shape(&self) -> (R, C)`[src]

The dimension of the matrix at run-time. Arr length of zero indicates the additive identity element of any dimension. Must be equal to `Self::dimension()` if it is not `None`. Read more

#### `fn strides(&self) -> (Self::RStride, Self::CStride)`[src]

The spacing between consecutive row elements and consecutive column elements. Read more

#### `fn is_contiguous(&self) -> bool`[src]

Indicates whether this data buffer stores its elements contiguously.

#### `fn into_owned(self) -> Owned<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,` [src]

Builds a matrix data storage that does not contain any reference.

#### `fn clone_owned(&self) -> Owned<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,` [src]

Clones this data storage to one that does not contain any reference.

#### `fn as_slice(&self) -> &[N]`[src]

Retrieves the data buffer as a contiguous slice. Read more

#### `fn linear_index(&self, irow: usize, icol: usize) -> usize`[src]

Compute the index corresponding to the irow-th row and icol-th column of this matrix. The index must be such that the following holds: Read more

#### `unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N`[src]

Gets the address of the i-th matrix component without performing bound-checking.

#### `unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N`[src]

Gets the address of the i-th matrix component without performing bound-checking.

#### `unsafe fn get_unchecked_linear(&self, i: usize) -> &N`[src]

Retrieves a reference to the i-th element without bound-checking.

#### `unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N`[src]

Retrieves a reference to the i-th element without bound-checking.

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

#### `fn ptr_mut(&mut self) -> *mut N`[src]

The matrix mutable data pointer.

#### `fn as_mut_slice(&mut self) -> &mut [N]`[src]

Retrieves the mutable data buffer as a contiguous slice. Read more

#### `unsafe fn get_address_unchecked_linear_mut(&mut self, i: usize) -> *mut N`[src]

Gets the mutable address of the i-th matrix component without performing bound-checking.

#### `unsafe fn get_address_unchecked_mut(
&mut self,
irow: usize,
icol: usize
) -> *mut N`[src]

Gets the mutable address of the i-th matrix component without performing bound-checking.

#### `unsafe fn get_unchecked_linear_mut(&mut self, i: usize) -> &mut N`[src]

Retrieves a mutable reference to the i-th element without bound-checking.

#### `unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut N`[src]

Retrieves a mutable reference to the element at `(irow, icol)` without bound-checking.

#### `unsafe fn swap_unchecked_linear(&mut self, i1: usize, i2: usize)`[src]

Swaps two elements using their linear index without bound-checking.

#### `unsafe fn swap_unchecked(
&mut self,
row_col1: (usize, usize),
row_col2: (usize, usize)
)`[src]

Swaps two elements without bound-checking.

### `impl<'a, N: Scalar, R: Dim, CStride: Dim> ContiguousStorage<N, R, U1> for SliceStorageMut<'a, N, R, U1, U1, CStride>`[src]

### `impl<'a, N: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorage<N, R, C> for SliceStorageMut<'a, N, R, C, U1, R>`[src]

### `impl<'a, N: Scalar, R: Dim, CStride: Dim> ContiguousStorageMut<N, R, U1> for SliceStorageMut<'a, N, R, U1, U1, CStride>`[src]

### `impl<'a, N: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorageMut<N, R, C> for SliceStorageMut<'a, N, R, C, U1, R>`[src]

### `impl<'a, N: Scalar + Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Send for SliceStorageMut<'a, N, R, C, RStride, CStride>`[src]

### `impl<'a, N: Scalar + Sync, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Sync for SliceStorageMut<'a, N, R, C, RStride, CStride>`[src]

### `impl<'a, N: Debug + Scalar, R: Debug + Dim, C: Debug + Dim, RStride: Debug + Dim, CStride: Debug + Dim> Debug for SliceStorageMut<'a, N, R, C, RStride, CStride>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl<'a, N, R, C, RStride, CStride> Unpin for SliceStorageMut<'a, N, R, C, RStride, CStride> where
C: Unpin,
CStride: Unpin,
R: Unpin,
RStride: Unpin,`

### `impl<'a, N, R, C, RStride, CStride> !UnwindSafe for SliceStorageMut<'a, N, R, C, RStride, CStride>`

### `impl<'a, N, R, C, RStride, CStride> RefUnwindSafe for SliceStorageMut<'a, N, R, C, RStride, CStride> where
C: RefUnwindSafe,
CStride: RefUnwindSafe,
N: RefUnwindSafe,
R: RefUnwindSafe,
RStride: RefUnwindSafe,`

## Blanket Implementations

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Same<T> for T`[src]

#### `type Output = T`

Should always be `Self`

### `impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,` [src]

#### `fn to_subset(&self) -> Option<SS>`[src]

The inverse inclusion map: attempts to construct `self` from the equivalent element of its superset. Read more

#### `fn is_in_subset(&self) -> bool`[src]

Checks if `self` is actually part of its subset `T` (and can be converted to it).

#### `unsafe fn to_subset_unchecked(&self) -> SS`[src]

Use with care! Same as `self.to_subset` but without any property checks. Always succeeds.

#### `fn from_subset(element: &SS) -> SP`[src]

The inclusion map: converts `self` to the equivalent element of its superset.

# 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`)