Struct Packed4Slice 

pub struct Packed4Slice<'a, T>
where
    T: Packable4,
{ /* private fields */ }

A read-only view over a packed slice of 4-bit values, stored 2 per byte.

Implementations

impl<'a, T> Packed4Slice<'a, T>

where T: Packable4,

pub fn new(data: &'a [u8], len: usize) -> Option<Packed4Slice<'a, T>>

Create a new Packed4Slice from packed bytes and logical length. Returns None if the backing buffer is too small for the requested length.

pub fn len(&self) -> usize

Returns the logical length (number of elements).

pub fn as_packed_slice(&self) -> &'a [u8]

Returns the underlying packed byte slice.

pub fn is_empty(&self) -> bool

Returns true if empty.

pub fn get(&self, index: usize) -> Option<T>

Get an element at the given logical index.

pub fn sub_slice(self, range: Range<usize>) -> Option<Packed4Slice<'a, T>>

Attempts to create a zero-copy sub-slice of the packed slice.

This is only possible without allocation if the range starts at an even logical index (aligned to byte boundaries). If the range starts at an odd index, returns None.

impl<'a, T> Packed4Slice<'a, T>

where T: Packable4,

pub fn unpack(&self, dest: &mut [<T as Packable4>::Unpacked])

Unpack all elements into a destination slice.

impl<'a> Packed4Slice<'a, Bf4>

pub fn unpack_to_bf16(&self, dest: &mut [Bf16])

Unpack all elements into a destination slice of Bf16.

impl<'a> Packed4Slice<'a, F4>

pub fn unpack_to_f32(&self, dest: &mut [F32])

Unpack all elements into a destination slice of F32.

Trait Implementations

impl<'a, T> Clone for Packed4Slice<'a, T>

where T: Clone + Packable4,

fn clone(&self) -> Packed4Slice<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Copy for Packed4Slice<'a, T>

where T: Copy + Packable4,

impl<'a, T> Debug for Packed4Slice<'a, T>

where T: Debug + Packable4,

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

Formats the value using the given formatter.

impl<'a, T> Eq for Packed4Slice<'a, T>

where T: Eq + Packable4,

impl<'a, T> IntoIterator for Packed4Slice<'a, T>

where T: Packable4,

type Item = T

The type of the elements being iterated over.

type IntoIter = Packed4Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Packed4Slice<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> PartialEq for Packed4Slice<'a, T>

where T: PartialEq + Packable4,

fn eq(&self, other: &Packed4Slice<'a, T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a, T> StructuralPartialEq for Packed4Slice<'a, T>

where T: PartialEq + Packable4,