Struct HeapArray 

pub struct HeapArray<T: Sized, M: Positive> { /* private fields */ }

An array on the heap that encodes its length in the type system.

Implementations

impl<T: Pod, M: Positive> HeapArray<T, M>

pub fn into_box_bytes(self) -> BoxBytes

pub fn from_box_bytes(buf: BoxBytes) -> Self

impl<T: Sized, M: Positive> HeapArray<T, M>

pub fn map<F, U>(self, f: F) -> HeapArray<U, M>

where F: FnMut(T) -> U,

impl<T: Sized + Default, M: Positive> HeapArray<T, M>

pub fn from_single_value(val: T) -> Self

impl<T: Sized + Copy, M: Positive> HeapArray<T, M>

pub fn split<M1, M2>(&self) -> (HeapArray<T, M1>, HeapArray<T, M2>)

where M1: Positive, M2: Positive + Add<M1, Output = M>,

pub fn split_halves<MDiv2>(&self) -> (HeapArray<T, MDiv2>, HeapArray<T, MDiv2>)

where MDiv2: Positive + Mul<U2, Output = M>,

pub fn merge_halves(this: Self, other: Self) -> HeapArray<T, Prod<M, U2>>

where M: Mul<U2, Output: Positive>,

pub fn split3<M1, M2, M3>( &self, ) -> (HeapArray<T, M1>, HeapArray<T, M2>, HeapArray<T, M3>)

where M1: Positive, M2: Positive + Add<M1>, M3: Positive + Add<Sum<M2, M1>, Output = M>,

pub fn split_thirds<MDiv3>( &self, ) -> (HeapArray<T, MDiv3>, HeapArray<T, MDiv3>, HeapArray<T, MDiv3>)

where MDiv3: Positive + Mul<U3, Output = M>,

pub fn merge_thirds( first: Self, second: Self, third: Self, ) -> HeapArray<T, Prod<M, U3>>

where M: Mul<U3, Output: Positive>,

impl<T: Sized, M: Positive> HeapArray<T, M>

pub fn split_last<N: Positive>( self, ) -> (HeapArray<T, Diff<M, N>>, HeapArray<T, N>)

where M: Sub<N, Output: Positive>,

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

pub fn from_constant(c: T) -> Self

where T: Copy,

impl<T: Sized + Default + Field, M: Positive> HeapArray<T, M>

pub fn square(&self) -> Self

Squares each element in the array.

pub fn double(&self) -> Self

Doubles each element in the array.

pub fn invert(&self) -> Option<Self>

Inverts each element in the array.

pub fn pow<S: AsRef<[u64]> + Clone>(&self, exp: S) -> Self

Exponentiates self by exp, where exp is a little-endian order integer exponent.

impl<T: Sized + ConditionallySelectable, M: Positive> HeapArray<T, M>

pub fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

Returns

• a if choice == Choice(0);
• b if choice == Choice(1).

impl<T: Sized + ConditionallySelectable, M: Positive, L: Positive> HeapArray<HeapArray<T, M>, L>

pub fn conditional_select_2d(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

Returns

• a if choice == Choice(0);
• b if choice == Choice(1).

Trait Implementations

impl<T, M: Positive> Add<&HeapArray<T, M>> for &HeapArray<T, M>

where T: for<'b> Add<&'b T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the + operator.

fn add(self, rhs: &HeapArray<T, M>) -> Self::Output

Performs the + operation.

impl<T, M: Positive> Add<&HeapArray<T, M>> for HeapArray<T, M>

where T: for<'b> Add<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the + operator.

fn add(self, other: &HeapArray<T, M>) -> Self::Output

Performs the + operation.

impl<T, M: Positive> Add<&T> for HeapArray<T, M>

where T: for<'a> Add<&'a T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the + operator.

fn add(self, other: &T) -> Self::Output

Performs the + operation.

impl<T, M: Positive> Add<HeapArray<T, M>> for &HeapArray<T, M>

where T: for<'b> Add<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the + operator.

fn add(self, rhs: HeapArray<T, M>) -> Self::Output

Performs the + operation.

impl<T, M: Positive> Add<T> for HeapArray<T, M>

where T: for<'a> Add<&'a T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T, M: Positive> Add for HeapArray<T, M>

where T: for<'b> Add<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the + operator.

fn add(self, rhs: HeapArray<T, M>) -> Self::Output

Performs the + operation.

impl<T, M: Positive> AddAssign<&HeapArray<T, M>> for HeapArray<T, M>

where T: for<'b> AddAssign<&'b T> + Sized,

fn add_assign(&mut self, other: &Self)

Performs the += operation.

impl<T, M: Positive> AddAssign<&T> for HeapArray<T, M>

where T: for<'a> AddAssign<&'a T> + Sized,

fn add_assign(&mut self, other: &T)

Performs the += operation.

impl<T, M: Positive> AddAssign<T> for HeapArray<T, M>

where T: for<'a> AddAssign<&'a T> + Sized,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T, M: Positive> AddAssign for HeapArray<T, M>

where T: for<'b> AddAssign<&'b T> + Sized,

fn add_assign(&mut self, rhs: HeapArray<T, M>)

Performs the += operation.

impl<T: Sized, M: Positive, __AsT: ?Sized> AsMut<__AsT> for HeapArray<T, M>

where Box<[T]>: AsMut<__AsT>,

fn as_mut(&mut self) -> &mut __AsT

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Sized, M: Positive, __AsT: ?Sized> AsRef<__AsT> for HeapArray<T, M>

where Box<[T]>: AsRef<__AsT>,

fn as_ref(&self) -> &__AsT

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone + Sized, M: Clone + Positive> Clone for HeapArray<T, M>

fn clone(&self) -> HeapArray<T, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, M: Positive> ConstantTimeEq for HeapArray<T, M>

where T: ConstantTimeEq + Sized,

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<T: Sized + Debug, M: Positive> Debug for HeapArray<T, M>

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

Formats the value using the given formatter.

impl<T: Sized + Default, M: Positive> Default for HeapArray<T, M>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Sized, M: Positive> Deref for HeapArray<T, M>

type Target = Box<[T]>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Sized, M: Positive> DerefMut for HeapArray<T, M>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T: Sized + Deserialize<'de>, M: Positive> Deserialize<'de> for HeapArray<T, M>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T, M: Positive> Display for HeapArray<T, M>

where T: Display + Sized,

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

Formats the value using the given formatter.

impl<T: Sized + Clone, M: Positive + ArraySize> From<Array<T, M>> for HeapArray<T, M>

fn from(array: Array<T, M>) -> Self

Converts to this type from the input type.

impl<F: FieldExtension, M: Positive> From<HeapArray<FieldShare<F>, M>> for FieldShares<F, M>

fn from(shares: HeapArray<FieldShare<F>, M>) -> Self

Converts to this type from the input type.

impl<T: Sized, M: Positive> From<HeapArray<T, M>> for Vec<T>

fn from(array: HeapArray<T, M>) -> Self

Converts to this type from the input type.

impl<T: Sized> From<T> for HeapArray<T, U1>

fn from(element: T) -> Self

Converts to this type from the input type.

impl<T: Sized, M: Positive> FromIterator<T> for HeapArray<T, M>

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

Creates a value from an iterator.

impl<'__deriveMoreLifetime, T: Sized, M: Positive> IntoIterator for &'__deriveMoreLifetime HeapArray<T, M>

where &'__deriveMoreLifetime Box<[T]>: IntoIterator,

type Item = <&'__deriveMoreLifetime Box<[T]> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime Box<[T]> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'__deriveMoreLifetime, T: Sized, M: Positive> IntoIterator for &'__deriveMoreLifetime mut HeapArray<T, M>

where &'__deriveMoreLifetime mut Box<[T]>: IntoIterator,

type Item = <&'__deriveMoreLifetime mut Box<[T]> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime mut Box<[T]> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Sized, M: Positive> IntoIterator for HeapArray<T, M>

where Box<[T]>: IntoIterator,

type Item = <Box<[T]> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <Box<[T]> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Sized + Send, M: Positive> IntoParallelIterator for HeapArray<T, M>

type Item = T

The type of item that the parallel iterator will produce.

type Iter = IntoIter<T>

The parallel iterator type that will be created.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for &CurveKeys<C, M>

where CurveKeys<C, M>: Clone,

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for &CurvePoints<C, M>

where CurvePoints<C, M>: Clone,

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for &PointShares<C, M>

where PointShares<C, M>: Clone,

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<&'a HeapArray<FieldElement<F>, M>> for FieldShareKeys<F, M>

type Output = FieldShareKeys<F, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a FieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for &ScalarKeys<C, M>

where ScalarKeys<C, M>: Clone,

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for &ScalarShares<C, M>

where ScalarShares<C, M>: Clone,

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for &ScalarsAsExtension<C, M>

where ScalarsAsExtension<C, M>: Clone,

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for &Scalars<C, M>

where Scalars<C, M>: Clone,

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for ScalarKeys<C, M>

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for ScalarShares<C, M>

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for ScalarsAsExtension<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<Point<C>, M>> for Scalars<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for &CurveKeys<C, M>

where CurveKeys<C, M>: Clone,

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for &CurvePoints<C, M>

where CurvePoints<C, M>: Clone,

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for &PointShares<C, M>

where PointShares<C, M>: Clone,

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<&'a HeapArray<SubfieldElement<F>, M>> for &FieldShares<F, M>

where FieldShares<F, M>: Clone,

type Output = FieldShares<F, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<&'a HeapArray<SubfieldElement<F>, M>> for FieldShareKeys<F, M>

type Output = FieldShareKeys<F, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<&'a HeapArray<SubfieldElement<F>, M>> for FieldShares<F, M>

type Output = FieldShares<F, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a SubfieldElements<F, M>) -> FieldShares<F, M>

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<&'a HeapArray<SubfieldElement<F>, M>> for FieldElements<F, M>

type Output = HeapArray<FieldElement<F>, M>

The resulting type after applying the * operator.

fn mul(self, other: &'a SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<&HeapArray<T, M>> for &HeapArray<T, M>

where T: for<'b> Mul<&'b T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &HeapArray<T, M>) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<&HeapArray<T, M>> for HeapArray<T, M>

where T: for<'b> Mul<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, other: &HeapArray<T, M>) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<&T> for &HeapArray<T, M>

where T: for<'a> Mul<&'a T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<&T> for HeapArray<T, M>

where T: for<'a> Mul<&'a T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, other: &T) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for &CurvePoints<C, M>

where CurvePoints<C, M>: Clone,

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: ScalarsAsExtension<C, M>) -> Self::Output

Performs the * operation.

impl<F: FieldExtension, M: Positive> Mul<HeapArray<FieldElement<F>, M>> for FieldShareKeys<F, M>

type Output = FieldShareKeys<F, M>

The resulting type after applying the * operator.

fn mul(self, other: FieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for &ScalarKeys<C, M>

where ScalarKeys<C, M>: Clone,

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for &ScalarShares<C, M>

where ScalarShares<C, M>: Clone,

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for &ScalarsAsExtension<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for &Scalars<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for ScalarKeys<C, M>

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for ScalarShares<C, M>

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for ScalarsAsExtension<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<Point<C>, M>> for Scalars<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: CurvePoints<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for &CurvePoints<C, M>

where CurvePoints<C, M>: Clone,

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

type Output = CurveKeys<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

type Output = HeapArray<Point<C>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> Mul<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

type Output = PointShares<C, M>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalars<C, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<HeapArray<SubfieldElement<F>, M>> for &FieldShares<F, M>

where FieldShares<F, M>: Clone,

type Output = FieldShares<F, M>

The resulting type after applying the * operator.

fn mul(self, rhs: SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<F: FieldExtension, M: Positive> Mul<HeapArray<SubfieldElement<F>, M>> for FieldShareKeys<F, M>

type Output = FieldShareKeys<F, M>

The resulting type after applying the * operator.

fn mul(self, other: SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<HeapArray<SubfieldElement<F>, M>> for FieldShares<F, M>

type Output = FieldShares<F, M>

The resulting type after applying the * operator.

fn mul(self, rhs: SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<'a, F: FieldExtension, M: Positive> Mul<HeapArray<SubfieldElement<F>, M>> for FieldElements<F, M>

type Output = HeapArray<FieldElement<F>, M>

The resulting type after applying the * operator.

fn mul(self, rhs: SubfieldElements<F, M>) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<HeapArray<T, M>> for &HeapArray<T, M>

where T: for<'b> Mul<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: HeapArray<T, M>) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<T> for &HeapArray<T, M>

where T: for<'a> Mul<&'a T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul<T> for HeapArray<T, M>

where T: for<'a> Mul<&'a T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, M: Positive> Mul for HeapArray<T, M>

where T: for<'b> Mul<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: HeapArray<T, M>) -> Self::Output

Performs the * operation.

impl<'a, C: Curve, M: Positive> MulAssign<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

fn mul_assign(&mut self, rhs: &'a ScalarsAsExtension<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

fn mul_assign(&mut self, other: &'a ScalarsAsExtension<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<&'a HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

fn mul_assign(&mut self, other: &'a ScalarsAsExtension<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

fn mul_assign(&mut self, rhs: &'a Scalars<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

fn mul_assign(&mut self, other: &'a Scalars<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<&'a HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

fn mul_assign(&mut self, other: &'a Scalars<C, M>)

Performs the *= operation.

impl<'a, F: FieldExtension, M: Positive> MulAssign<&'a HeapArray<SubfieldElement<F>, M>> for FieldShareKeys<F, M>

fn mul_assign(&mut self, other: &'a SubfieldElements<F, M>)

Performs the *= operation.

impl<'a, F: FieldExtension, M: Positive> MulAssign<&'a HeapArray<SubfieldElement<F>, M>> for FieldShares<F, M>

fn mul_assign(&mut self, other: &'a SubfieldElements<F, M>)

Performs the *= operation.

impl<'a, F: FieldExtension, M: Positive> MulAssign<&'a HeapArray<SubfieldElement<F>, M>> for FieldElements<F, M>

fn mul_assign(&mut self, other: &'a SubfieldElements<F, M>)

Performs the *= operation.

impl<T, M: Positive> MulAssign<&HeapArray<T, M>> for HeapArray<T, M>

where T: for<'b> MulAssign<&'b T> + Sized,

fn mul_assign(&mut self, other: &Self)

Performs the *= operation.

impl<T, M: Positive> MulAssign<&T> for HeapArray<T, M>

where T: for<'a> MulAssign<&'a T> + Sized,

fn mul_assign(&mut self, other: &T)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

fn mul_assign(&mut self, rhs: ScalarsAsExtension<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

fn mul_assign(&mut self, rhs: ScalarsAsExtension<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<HeapArray<FieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

fn mul_assign(&mut self, rhs: ScalarsAsExtension<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurveKeys<C, M>

fn mul_assign(&mut self, rhs: Scalars<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for CurvePoints<C, M>

fn mul_assign(&mut self, rhs: Scalars<C, M>)

Performs the *= operation.

impl<'a, C: Curve, M: Positive> MulAssign<HeapArray<SubfieldElement<<C as Curve>::Scalar>, M>> for PointShares<C, M>

fn mul_assign(&mut self, rhs: Scalars<C, M>)

Performs the *= operation.

impl<'a, F: FieldExtension, M: Positive> MulAssign<HeapArray<SubfieldElement<F>, M>> for FieldShares<F, M>

fn mul_assign(&mut self, rhs: SubfieldElements<F, M>)

Performs the *= operation.

impl<'a, F: FieldExtension, M: Positive> MulAssign<HeapArray<SubfieldElement<F>, M>> for FieldElements<F, M>

fn mul_assign(&mut self, rhs: SubfieldElements<F, M>)

Performs the *= operation.

impl<T, M: Positive> MulAssign<T> for HeapArray<T, M>

where T: for<'a> MulAssign<&'a T> + Sized,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, M: Positive> MulAssign for HeapArray<T, M>

where T: for<'b> MulAssign<&'b T> + Sized,

fn mul_assign(&mut self, rhs: HeapArray<T, M>)

Performs the *= operation.

impl<T, M: Positive> Neg for &HeapArray<T, M>

where T: Neg<Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, M: Positive> Neg for HeapArray<T, M>

where T: Neg<Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Sized + Default + One + Eq + for<'b> Mul<&'b T, Output = T>, M: Positive + Eq> One for HeapArray<T, M>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<T, M: Positive> PartialEq for HeapArray<T, M>

where T: PartialEq + Sized,

fn eq(&self, other: &Self) -> 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<T: Sized + Random, M: Positive> Random for HeapArray<T, M>

fn random(rng: impl CryptoRngCore) -> Self

Generate a random array of length M.

fn random_n<Container: FromIterator<Self>>( rng: impl CryptoRngCore, size: usize, ) -> Container

impl<C: Curve, M: Positive> RandomWith<HeapArray<Point<C>, M>> for PointShares<C, M>

fn random_n_with<Container: FromIterator<Self>>( rng: impl CryptoRngCore, n_parties: usize, value: CurvePoints<C, M>, ) -> Container

Secret share a value among n parties, generating an authenticated share for each peer with consistent MACs and keys across all peers.

fn random_n_with_each<Container: FromIterator<Self>>( rng: impl CryptoRngCore, n_parties_and_value: impl IntoExactSizeIterator<Item = CurvePoints<C, M>>, ) -> Container

Generate a random field share with a specific secret share as value, with consistent random MACs and keys across all peers.

fn random_with(_rng: impl CryptoRngCore, _data: CurvePoints<C, M>) -> Self

impl<F: FieldExtension, M: Positive> RandomWith<HeapArray<SubfieldElement<F>, M>> for FieldShares<F, M>

fn random_n_with<Container: FromIterator<Self>>( rng: impl CryptoRngCore, n_parties: usize, value: SubfieldElements<F, M>, ) -> Container

Secret share a value among n parties, generating an authenticated share for each peer with consistent MACs and keys across all peers.

fn random_n_with_each<Container: FromIterator<Self>>( rng: impl CryptoRngCore, unauth_shares: impl IntoExactSizeIterator<Item = SubfieldElements<F, M>>, ) -> Container

Generate an authenticated share given for each peer given its additve share with consistent MACs and keys across all peers.

fn random_with(_rng: impl CryptoRngCore, _data: SubfieldElements<F, M>) -> Self

impl<T: Sized + Serialize, M: Positive> Serialize for HeapArray<T, M>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T, M: Positive> Sub<&HeapArray<T, M>> for &HeapArray<T, M>

where T: for<'b> Sub<&'b T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &HeapArray<T, M>) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub<&HeapArray<T, M>> for HeapArray<T, M>

where T: for<'b> Sub<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, other: &HeapArray<T, M>) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub<&T> for &HeapArray<T, M>

where T: for<'a> Sub<&'a T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub<&T> for HeapArray<T, M>

where T: for<'a> Sub<&'a T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, other: &T) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub<HeapArray<T, M>> for &HeapArray<T, M>

where T: for<'b> Sub<&'b T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, rhs: HeapArray<T, M>) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub<T> for &HeapArray<T, M>

where T: for<'a> Sub<&'a T, Output = T> + Sized, HeapArray<T, M>: Clone,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub<T> for HeapArray<T, M>

where T: for<'a> Sub<&'a T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T, M: Positive> Sub for HeapArray<T, M>

where T: for<'b> Sub<&'b T, Output = T> + Sized,

type Output = HeapArray<T, M>

The resulting type after applying the - operator.

fn sub(self, rhs: HeapArray<T, M>) -> Self::Output

Performs the - operation.

impl<T, M: Positive> SubAssign<&HeapArray<T, M>> for HeapArray<T, M>

where T: for<'b> SubAssign<&'b T> + Sized,

fn sub_assign(&mut self, other: &Self)

Performs the -= operation.

impl<T, M: Positive> SubAssign<&T> for HeapArray<T, M>

where T: for<'a> SubAssign<&'a T> + Sized,

fn sub_assign(&mut self, other: &T)

Performs the -= operation.

impl<T, M: Positive> SubAssign<T> for HeapArray<T, M>

where T: for<'a> SubAssign<&'a T> + Sized,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T, M: Positive> SubAssign for HeapArray<T, M>

where T: for<'b> SubAssign<&'b T> + Sized,

fn sub_assign(&mut self, rhs: HeapArray<T, M>)

Performs the -= operation.

impl<T: Clone + Default + for<'b> Add<&'b T, Output = T>, M: Positive> Sum for HeapArray<T, M>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: Sized, M: Positive> TryFrom<Vec<T>> for HeapArray<T, M>

type Error = PrimitiveError

The type returned in the event of a conversion error.

fn try_from(data: Vec<T>) -> Result<Self, PrimitiveError>

Performs the conversion.

impl<T: Clone + Zero + Eq + for<'b> Add<&'b T, Output = T>, M: Positive + Eq> Zero for HeapArray<T, M>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Eq + Sized, M: Eq + Positive> Eq for HeapArray<T, M>