Struct BlockTransposed 

pub struct BlockTransposed<T: Copy, const GROUP: usize, const PACK: usize = 1> { /* private fields */ }

An owning block-transposed matrix.

Wraps an owned allocation of T elements laid out in block-transposed order. See the module-level documentation for layout details.

For shared and mutable views, see BlockTransposedRef and BlockTransposedMut.

Row Types

Because rows are not contiguous in memory, the row types are view structs:

• Row — a Copy handle supporting Index<usize> and .iter().
• RowMut — a mutable handle supporting IndexMut<usize>.

Implementations

impl<T: Copy, const GROUP: usize, const PACK: usize> BlockTransposed<T, GROUP, PACK>

pub fn as_view(&self) -> BlockTransposedRef<'_, T, GROUP, PACK>

Borrow as an immutable BlockTransposedRef.

pub fn as_view_mut(&mut self) -> BlockTransposedMut<'_, T, GROUP, PACK>

Borrow as a mutable BlockTransposedMut.

pub fn nrows(&self) -> usize

See BlockTransposedRef::nrows.

pub fn ncols(&self) -> usize

See BlockTransposedRef::ncols.

pub fn padded_ncols(&self) -> usize

See BlockTransposedRef::padded_ncols.

pub fn full_blocks(&self) -> usize

See BlockTransposedRef::full_blocks.

pub fn num_blocks(&self) -> usize

See BlockTransposedRef::num_blocks.

pub fn remainder(&self) -> usize

See BlockTransposedRef::remainder.

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

See BlockTransposedRef::as_ptr.

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

See BlockTransposedRef::as_slice.

pub unsafe fn block_ptr_unchecked(&self, block: usize) -> *const T

See BlockTransposedRef::block_ptr_unchecked.

pub fn block(&self, block: usize) -> MatrixView<'_, T>

See BlockTransposedRef::block.

pub fn remainder_block(&self) -> Option<MatrixView<'_, T>>

See BlockTransposedRef::remainder_block.

pub fn get_element(&self, row: usize, col: usize) -> T

See BlockTransposedRef::get_element.

pub const fn group_size(&self) -> usize

Group size (blocking factor GROUP).

pub const fn const_group_size() -> usize

Group size (blocking factor GROUP) as a const function on the type.

pub const fn pack_size(&self) -> usize

Packing factor PACK.

pub fn get_row(&self, i: usize) -> Option<Row<'_, T, GROUP, PACK>>

Get an immutable row view, or None if i is out of bounds.

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

See BlockTransposedMut::as_mut_slice.

pub fn block_mut(&mut self, block: usize) -> MutMatrixView<'_, T>

See BlockTransposedMut::block_mut.

pub fn remainder_block_mut(&mut self) -> Option<MutMatrixView<'_, T>>

See BlockTransposedMut::remainder_block_mut.

pub fn get_row_mut(&mut self, i: usize) -> Option<RowMut<'_, T, GROUP, PACK>>

Get a mutable row view, or None if i is out of bounds.

impl<T: Copy + Default, const GROUP: usize, const PACK: usize> BlockTransposed<T, GROUP, PACK>

pub fn new(nrows: usize, ncols: usize) -> Self

Construct a default-initialized block-transposed matrix from dimensions.

Panics

Panics if the dimensions overflow the allocation budget.

pub fn try_new(nrows: usize, ncols: usize) -> Result<Self, Overflow>

Fallible variant of new.

pub fn from_strided(v: StridedView<'_, T>) -> Self

Construct a block-transposed matrix by copying data from a StridedView.

Each source element at (row, col) is placed at the correct offset in the block-transposed layout. Padding positions (both partial-block rows and column-group padding when ncols % PACK != 0) are filled with T::default().

The loop iterates in physical (block-transposed) order — block, column-group, row-within-block, pack-lane — so that writes to the backing allocation are sequential. Source reads stride across rows of the StridedView, which is acceptable because read-side prefetch is more effective than write-side.

pub fn from_matrix_view(v: MatrixView<'_, T>) -> Self

Construct a block-transposed matrix by copying data from a MatrixView.

Trait Implementations

impl<T: Debug + Copy, const GROUP: usize, const PACK: usize> Debug for BlockTransposed<T, GROUP, PACK>

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

Formats the value using the given formatter.

impl<T: Copy, const GROUP: usize, const PACK: usize> Index<(usize, usize)> for BlockTransposed<T, GROUP, PACK>

type Output = T

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.