Struct ScaledUnderlier

#[repr(transparent)]
pub struct ScaledUnderlier<U, const N: usize>(pub [U; N]);

A type that represents a pair of elements of the same underlier type. We use it as an underlier for the ScaledPAckedField type.

Tuple Fields

0: [U; N]

Trait Implementations

impl<U: BitAnd<Output = U> + Copy, const N: usize> BitAnd for ScaledUnderlier<U, N>

type Output = ScaledUnderlier<U, N>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<U: BitAndAssign + Copy, const N: usize> BitAndAssign for ScaledUnderlier<U, N>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<U: BitOr<Output = U> + Copy, const N: usize> BitOr for ScaledUnderlier<U, N>

type Output = ScaledUnderlier<U, N>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<U: BitOrAssign + Copy, const N: usize> BitOrAssign for ScaledUnderlier<U, N>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<U: BitXor<Output = U> + Copy, const N: usize> BitXor for ScaledUnderlier<U, N>

type Output = ScaledUnderlier<U, N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<U: BitXorAssign + Copy, const N: usize> BitXorAssign for ScaledUnderlier<U, N>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<U: Clone, const N: usize> Clone for ScaledUnderlier<U, N>

fn clone(&self) -> ScaledUnderlier<U, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<U: ConstantTimeEq, const N: usize> ConstantTimeEq for ScaledUnderlier<U, N>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<U: Debug, const N: usize> Debug for ScaledUnderlier<U, N>

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

Formats the value using the given formatter.

impl<U: Default, const N: usize> Default for ScaledUnderlier<U, N>

fn default() -> Self

Returns the “default value” for a type.

impl<U> Divisible<U> for ScaledUnderlier<ScaledUnderlier<U, 2>, 2>

where Self: UnderlierType + NoUninit, U: UnderlierType + Pod,

type Array = [U; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[U]

fn split_mut(&mut self) -> &mut [U]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl<U, const N: usize> Divisible<U> for ScaledUnderlier<U, N>

where Self: UnderlierType, U: UnderlierType,

type Array = [U; N]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[U]

fn split_mut(&mut self) -> &mut [U]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u128> for ScaledUnderlier<M128, 2>

type Array = [u128; 2]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u128]

fn split_mut(&mut self) -> &mut [u128]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u128> for ScaledUnderlier<ScaledUnderlier<M128, 2>, 2>

type Array = [u128; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u128]

fn split_mut(&mut self) -> &mut [u128]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<M128, 2>

type Array = [u16; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<ScaledUnderlier<M128, 2>, 2>

type Array = [u16; 32]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<ScaledUnderlier<u128, 2>, 2>

type Array = [u16; 32]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<ScaledUnderlier<u32, 2>, 2>

type Array = [u16; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<ScaledUnderlier<u64, 2>, 2>

type Array = [u16; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<u128, 2>

type Array = [u16; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<u32, 2>

type Array = [u16; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u16> for ScaledUnderlier<u64, 2>

type Array = [u16; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u16]

fn split_mut(&mut self) -> &mut [u16]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u32> for ScaledUnderlier<M128, 2>

type Array = [u32; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u32]

fn split_mut(&mut self) -> &mut [u32]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u32> for ScaledUnderlier<ScaledUnderlier<M128, 2>, 2>

type Array = [u32; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u32]

fn split_mut(&mut self) -> &mut [u32]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u32> for ScaledUnderlier<ScaledUnderlier<u128, 2>, 2>

type Array = [u32; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u32]

fn split_mut(&mut self) -> &mut [u32]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u32> for ScaledUnderlier<ScaledUnderlier<u64, 2>, 2>

type Array = [u32; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u32]

fn split_mut(&mut self) -> &mut [u32]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u32> for ScaledUnderlier<u128, 2>

type Array = [u32; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u32]

fn split_mut(&mut self) -> &mut [u32]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u32> for ScaledUnderlier<u64, 2>

type Array = [u32; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u32]

fn split_mut(&mut self) -> &mut [u32]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u64> for ScaledUnderlier<M128, 2>

type Array = [u64; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u64]

fn split_mut(&mut self) -> &mut [u64]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u64> for ScaledUnderlier<ScaledUnderlier<M128, 2>, 2>

type Array = [u64; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u64]

fn split_mut(&mut self) -> &mut [u64]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u64> for ScaledUnderlier<ScaledUnderlier<u128, 2>, 2>

type Array = [u64; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u64]

fn split_mut(&mut self) -> &mut [u64]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u64> for ScaledUnderlier<u128, 2>

type Array = [u64; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u64]

fn split_mut(&mut self) -> &mut [u64]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<M128, 2>

type Array = [u8; 32]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<ScaledUnderlier<M128, 2>, 2>

type Array = [u8; 64]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<ScaledUnderlier<u128, 2>, 2>

type Array = [u8; 64]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<ScaledUnderlier<u16, 2>, 2>

type Array = [u8; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<ScaledUnderlier<u32, 2>, 2>

type Array = [u8; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<ScaledUnderlier<u64, 2>, 2>

type Array = [u8; 32]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<u128, 2>

type Array = [u8; 32]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<u16, 2>

type Array = [u8; 4]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<u32, 2>

type Array = [u8; 8]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl Divisible<u8> for ScaledUnderlier<u64, 2>

type Array = [u8; 16]

This is actually [U; Self::WIDTH] but we can’t use it as the default value in the trait definition without generic_const_exprs feature enabled.

fn split_val(self) -> Self::Array

fn split_ref(&self) -> &[u8]

fn split_mut(&mut self) -> &mut [u8]

const WIDTH: usize = _

fn split_slice(values: &[Self]) -> &[U]

fn split_slice_mut(values: &mut [Self]) -> &mut [U]

impl<T: Copy, U: From<[T; 2]>> From<[T; 4]> for ScaledUnderlier<U, 2>

fn from(value: [T; 4]) -> Self

Converts to this type from the input type.

impl<T, U: From<T>, const N: usize> From<[T; N]> for ScaledUnderlier<U, N>

fn from(value: [T; N]) -> Self

Converts to this type from the input type.

impl<U, const N: usize> From<ScaledUnderlier<U, N>> for [U; N]

fn from(val: ScaledUnderlier<U, N>) -> Self

Converts to this type from the input type.

impl<U: Not<Output = U>, const N: usize> Not for ScaledUnderlier<U, N>

type Output = ScaledUnderlier<U, N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<U: Ord, const N: usize> Ord for ScaledUnderlier<U, N>

fn cmp(&self, other: &ScaledUnderlier<U, N>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<U, F, const N: usize> PackScalar<F> for ScaledUnderlier<U, N>

where U: PackScalar<F> + UnderlierType + Pod, F: Field, ScaledPackedField<U::Packed, N>: PackedField<Scalar = F> + WithUnderlier<Underlier = Self>,

type Packed = ScaledPackedField<<U as PackScalar<F>>::Packed, N>

impl<U: PartialEq, const N: usize> PartialEq for ScaledUnderlier<U, N>

fn eq(&self, other: &ScaledUnderlier<U, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<U: PartialOrd, const N: usize> PartialOrd for ScaledUnderlier<U, N>

fn partial_cmp(&self, other: &ScaledUnderlier<U, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U: Random, const N: usize> Random for ScaledUnderlier<U, N>

fn random(rng: impl RngCore) -> Self

Generate random value

impl<U: UnderlierWithBitOps, const N: usize> Shl<usize> for ScaledUnderlier<U, N>

type Output = ScaledUnderlier<U, N>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

impl<U: UnderlierWithBitOps, const N: usize> Shr<usize> for ScaledUnderlier<U, N>

type Output = ScaledUnderlier<U, N>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl<U: UnderlierType + Pod, const N: usize> UnderlierType for ScaledUnderlier<U, N>

const LOG_BITS: usize

Number of bits in value

const BITS: usize = _

Number of bits used to represent a value. This may not be equal to the number of bits in a type instance.

impl<U: UnderlierWithBitOps + Pod, const N: usize> UnderlierWithBitOps for ScaledUnderlier<U, N>

const ZERO: Self

const ONE: Self

const ONES: Self

fn fill_with_bit(val: u8) -> Self

Fill value with the given bit val must be 0 or 1.

fn shl_128b_lanes(self, rhs: usize) -> Self

Left shift within 128-bit lanes. This can be more efficient than the full Shl implementation.

fn shr_128b_lanes(self, rhs: usize) -> Self

Right shift within 128-bit lanes. This can be more efficient than the full Shr implementation.

fn unpack_lo_128b_lanes(self, other: Self, log_block_len: usize) -> Self

Unpacks 1 << log_block_len-bit values from low parts of self and other within 128-bit lanes.

fn unpack_hi_128b_lanes(self, other: Self, log_block_len: usize) -> Self

Unpacks 1 << log_block_len-bit values from high parts of self and other within 128-bit lanes.

fn from_fn<T>(f: impl FnMut(usize) -> T) -> Self

where T: UnderlierType, Self: From<T>,

fn broadcast_subvalue<T>(value: T) -> Self

where T: UnderlierType, Self: From<T>,

Broadcast subvalue to fill Self. Self::BITS/T::BITS is supposed to be a power of 2.

unsafe fn get_subvalue<T>(&self, i: usize) -> T

where T: UnderlierType + NumCast<Self>,

Gets the subvalue from the given position. Function panics in case when index is out of range.

unsafe fn set_subvalue<T>(&mut self, i: usize, val: T)

where T: UnderlierWithBitOps, Self: From<T>,

Sets the subvalue in the given position. Function panics in case when index is out of range.

unsafe fn spread<T>(self, log_block_len: usize, block_idx: usize) -> Self

where T: UnderlierWithBitOps + NumCast<Self>, Self: From<T>,

Spread takes a block of sub_elements of T type within the current value and repeats them to the full underlier width.

impl<U: Zeroable, const N: usize> Zeroable for ScaledUnderlier<U, N>

fn zeroed() -> Self

Calls zeroed.

impl<U: Copy, const N: usize> Copy for ScaledUnderlier<U, N>

impl<U: Eq, const N: usize> Eq for ScaledUnderlier<U, N>

impl<U: Pod, const N: usize> Pod for ScaledUnderlier<U, N>

impl<U, const N: usize> StructuralPartialEq for ScaledUnderlier<U, N>