Struct nanovec::array::NanoArrayRadix

pub struct NanoArrayRadix<T, const RADIX: usize>(_)
where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul;

A NanoArray with element range 0..RADIX, encoded as a base-RADIX unsigned integer with 1 “digit” per element.

• T: a backing unsigned integer used to store the encoded number; (n bits).
• RADIX: determines the range of each element.

The length of the array m is defined by argmax(m) RADIX.pow(m) <= 2.pow(n), i.e. the largest m-digit base-RADIX number must fit in T. Solving the inequality: m = floor(n / log2(RADIX)).

See NanoArray for the supported operations.

Iterator support

• This array is Copy and offers Self::into_iter() which consumes the array into an iterator of its elements. A non-consuming iterator can be emulated using .clone().

• This array implements FromIterator and can therefore be Iterator::collected into. It consumes at most Self::LENGTH elements; if the iterator is short, 0 is filled.

Example:

use nanovec::array::*;
type A = NanoArrayRadix<u32, 84>;
let a = [0x4A, 0x3B, 0x2C, 0x1D, 0x0E].iter().collect::<A>();
assert_eq!(a.get(0), 0x4A);
assert_eq!(a.get(1), 0x3B);
let v = a.clone().into_iter().collect::<Vec<_>>();
assert_eq!(v, vec![0x4A, 0x3B, 0x2C, 0x1D, 0x0E]);
assert_eq!(a.get(2), 0x2C);
assert_eq!(a.get(3), 0x1D);
assert_eq!(a.get(4), 0x0E);

Implementations

impl<T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul, const RADIX: usize> NanoArrayRadix<T, RADIX>

pub const NUM_BYTES: usize = _

Width of T, in Bytes.

pub const NUM_BITS: usize = _

Width of T, in bits.

pub const LENGTH: usize = _

The fixed length of this array.

pub const POW: [u128; 64] = _

Powers of RADIX; POW[i] == RADIX.pow(i).

Note that we want [u128; Self::LENGTH] but this is not possible in Rust Edition 2021.

pub fn into_iter(self) -> impl Iterator<Item = T>

Converts this array into an iterator of its elements.

Trait Implementations

impl<T: Clone, const RADIX: usize> Clone for NanoArrayRadix<T, RADIX>where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul,

fn clone(&self) -> NanoArrayRadix<T, RADIX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul + Debug, const RADIX: usize> Debug for NanoArrayRadix<T, RADIX>

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

Formats the value using the given formatter.

impl<T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul, const RADIX: usize> Default for NanoArrayRadix<T, RADIX>

fn default() -> Self

Returns the “default value” for a type.

impl<T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul, const RADIX: usize> From<T> for NanoArrayRadix<T, RADIX>

fn from(packed: T) -> Self

Converts to this type from the input type.

impl<'a, T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul + 'a, const RADIX: usize> FromIterator<&'a T> for NanoArrayRadix<T, RADIX>

fn from_iter<It: IntoIterator<Item = &'a T>>(iter: It) -> Self

Creates a value from an iterator.

impl<T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul, const RADIX: usize> FromIterator<T> for NanoArrayRadix<T, RADIX>

fn from_iter<It: IntoIterator<Item = T>>(iter: It) -> Self

Creates a value from an iterator.

impl<T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul, const RADIX: usize> NanoArray for NanoArrayRadix<T, RADIX>

type Packed = T

The underlying representation of this array.

type Element = T

The element type of this array; must be an unsigned primitive integer. Note that it’s not guaranteed that all values that can fit the type is allowed; see Self::max_elem().

const LENGTH: usize = Self::LENGTH

The fixed length of this array.

fn new() -> Self

Creates an all-zero array.

fn from_packed(packed: T) -> Self

Creates an array from its underlying representation.

fn packed(self) -> T

Converts the array to its underlying representation.

fn max_elem() -> T

Returns the maximum element allowed in this array.

fn with(self, i: usize, elem: T) -> Self

Returns a new array = this array with the i-th element set to elem (a.k.a. immutable set index). Panics if the index is out of bounds or the element is out of range.

fn set(&mut self, i: usize, elem: T)

Sets the i-th element of this array to elem. Panics if the index is out of bounds or the element is out of range.

fn get_unchecked(self, i: usize) -> T

Returns the i-th element of this array. Behavior when the index is out of bounds is unspecified (okay to panic).

fn with_unchecked(self, i: usize, elem: T) -> Self

Returns a new array = this array with the i-th element set to elem (a.k.a. immutable set index). Behavior when the index is out of bounds is unspecified (okay to panic).

fn set_unchecked(&mut self, i: usize, elem: T)

Sets the i-th element of this array to elem. Behavior when the index is out of bounds is unspecified (okay to panic).

fn shift_high(self, n: usize) -> Self

Shifts this array n elements towards the higher index. The lower indices will be left as 0. Behavior when n > Self::LENGTH is unspecified (okay to panic).

fn shift_low(self, n: usize) -> Self

Shifts this array n elements towards the lower index The higher indices will be left as 0. Behavior when n > Self::LENGTH is unspecified (okay to panic).

fn rotate_high(self, n: usize) -> Self

Rotates this array n elements towards the higher index. This is equivalent to rotate_low(Self::LENGTH - n). Panics when n > Self::LENGTH.

fn get(self, i: usize) -> Self::Element

Returns the i-th element of this array. Panics if the index is out of bounds.

fn rotate_low(self, n: usize) -> Self

Rotates this array n elements towards the lower index. This is equivalent to rotate_high(Self::LENGTH - n). Panics when n > Self::LENGTH.

impl<T: PartialEq, const RADIX: usize> PartialEq<NanoArrayRadix<T, RADIX>> for NanoArrayRadix<T, RADIX>where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul,

fn eq(&self, other: &NanoArrayRadix<T, RADIX>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy, const RADIX: usize> Copy for NanoArrayRadix<T, RADIX>where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul,

impl<T: Eq, const RADIX: usize> Eq for NanoArrayRadix<T, RADIX>where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul,

impl<T, const RADIX: usize> StructuralEq for NanoArrayRadix<T, RADIX>where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul,

impl<T, const RADIX: usize> StructuralPartialEq for NanoArrayRadix<T, RADIX>where
    T: PrimInt + Unsigned + WrappingAdd + WrappingSub + WrappingMul,