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: 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 ScaledUnderlier<ScaledUnderlier<U, 2>, 2>: UnderlierType + NoUninit, U: UnderlierType + Pod,

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 ScaledUnderlier<U, N>: UnderlierType, U: UnderlierType,

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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: 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 = ScaledUnderlier<U, N>>,

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: 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: 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>