Struct simd_aligned::MatrixD

pub struct MatrixD<T, A> where
    T: Simd + Default + Clone,
    A: AccessStrategy,  { /* fields omitted */ }

A dynamic (heap allocated) matrix with one axis aligned for fast and safe SIMD access that also provides a flat view on its data.

You can use MatrixD when you need to deal with multiple SIMD vectors, but want them arranged in a compact cache-friendly manner. Internally this struct is backed by a continuous vector of aligned vectors, and dynamically sliced according to row / column access.

Example

use packed_simd::*;
use simd_aligned::*;

// Create a matrix of height 10x`f32` and width 5x`f32`, optimized for row access.
let mut m = MatrixD::<f32s, Rows>::with_dimension(10, 5);

// A `RowOptimized` matrix provides `row` access. In this example, you could query
// rows `0` to `9` and receive vectors that can hold a total of at least `5` elements.
let _ = m.row(4);

// But accessing columns doesn't work, as there is no continuous view in memory.
// m.column(3); --> panic!

// However, you can always get a flat view of the matrix, for "scalar-speed"
// query and update all elements:
let mut m_flat = m.flat_mut();

m_flat[(2, 4)] = 42_f32;

Methods

impl<T, O> MatrixD<T, O> where
    T: Simd + Default + Clone,
    O: AccessStrategy, 

pub fn with_dimension(width: usize, height: usize) -> Self

Creates a new MatrixD with the given dimension.

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

Returns the size as (rows, columns).

pub fn flat(&self) -> MatrixFlat<T, O>

Provides a flat, immutable view of the contained data.

pub fn flat_mut(&mut self) -> MatrixFlatMut<T, O>

Provides a flat mutable view of the contained data.

impl<T> MatrixD<T, Rows> where
    T: Simd + Default + Clone, 

pub fn row(&self, i: usize) -> &[T]

pub fn row_iter(&self) -> Matrix2DIter<T, Rows>

pub fn row_mut(&mut self, i: usize) -> &mut [T]

pub fn row_as_flat(&self, i: usize) -> &[T::Element]

pub fn row_as_flat_mut(&mut self, i: usize) -> &mut [T::Element]

impl<T> MatrixD<T, Columns> where
    T: Simd + Default + Clone, 

pub fn column(&self, i: usize) -> &[T]

pub fn column_iter(&self) -> Matrix2DIter<T, Columns>

pub fn column_mut(&mut self, i: usize) -> &mut [T]

pub fn column_as_flat(&self, i: usize) -> &[T::Element]

pub fn column_as_flat_mut(&mut self, i: usize) -> &mut [T::Element]

Trait Implementations

impl<T: Clone, A: Clone> Clone for MatrixD<T, A> where
    T: Simd + Default + Clone,
    A: AccessStrategy, 

fn clone(&self) -> MatrixD<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, A: Debug> Debug for MatrixD<T, A> where
    T: Simd + Default + Clone,
    A: AccessStrategy, 

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

Formats the value using the given formatter.