Struct Poly 

pub struct Poly { /* private fields */ }

Struct that holds a polynomial for a specific context.

Implementations

impl Poly

pub fn zero(ctx: &Arc<Context>, representation: Representation) -> Self

Creates a polynomial holding the constant 0.

pub unsafe fn allow_variable_time_computations(&mut self)

Enable variable time computations when this polynomial is involved.

Safety

By default, this is marked as unsafe, but is usually safe when only public data is processed.

pub fn disallow_variable_time_computations(&mut self)

Disable variable time computations when this polynomial is involved.

pub const fn representation(&self) -> &Representation

Current representation of the polynomial.

pub fn change_representation(&mut self, to: Representation)

Change the representation of the underlying polynomial.

pub unsafe fn override_representation(&mut self, to: Representation)

Override the internal representation to a given representation.

Safety

Prefer the change_representation function to safely modify the polynomial representation. If the to representation is NttShoup, the coefficients are still computed correctly to avoid being in an unstable state. If we override a polynomial with Shoup coefficients, we zeroize them.

pub fn random<R: RngCore + CryptoRng>( ctx: &Arc<Context>, representation: Representation, rng: &mut R, ) -> Self

Generate a random polynomial.

pub fn random_from_seed( ctx: &Arc<Context>, representation: Representation, seed: <ChaCha8Rng as SeedableRng>::Seed, ) -> Self

Generate a random polynomial deterministically from a seed.

pub fn small<T: RngCore + CryptoRng>( ctx: &Arc<Context>, representation: Representation, variance: usize, rng: &mut T, ) -> Result<Self>

Generate a small polynomial and convert into the specified representation.

Returns an error if the variance does not belong to [1, …, 16].

pub fn coefficients(&self) -> ArrayView2<'_, u64>

Access the polynomial coefficients in RNS representation.

pub fn substitute(&self, i: &SubstitutionExponent) -> Result<Poly>

Substitute x by x^i in a polynomial. In PowerBasis representation, i can be any integer that is not a multiple of 2 * degree. In Ntt and NttShoup representation, i can be any odd integer that is not a multiple of 2 * degree.

pub unsafe fn create_constant_ntt_polynomial_with_lazy_coefficients_and_variable_time( power_basis_coefficients: &[u64], ctx: &Arc<Context>, ) -> Self

Create a polynomial which can only be multiplied by a polynomial in NttShoup representation. All other operations may panic.

Safety

This operation also creates a polynomial that allows variable time operations.

pub fn switch_down(&mut self) -> Result<()>

Modulus switch down the polynomial by dividing and rounding each coefficient by the last modulus in the chain, then drops the last modulus, as described in Algorithm 2 of https://eprint.iacr.org/2018/931.pdf.

Returns an error if there is no next context or if the representation is not PowerBasis.

pub fn switch_down_to(&mut self, context: &Arc<Context>) -> Result<()>

Modulo switch down to a smaller context.

Returns an error if there is the provided context is not a child of the current context, or if the polynomial is not in PowerBasis representation.

pub fn switch(&self, switcher: &Switcher) -> Result<Poly>

Modulo switch to another context. The target context needs not to be related to the current context.

pub fn scale(&self, scaler: &Scaler) -> Result<Poly>

Scale a polynomial using a scaler.

pub fn ctx(&self) -> &Arc<Context>

Returns the context of the underlying polynomial

pub fn multiply_inverse_power_of_x(&mut self, power: usize) -> Result<()>

Multiplies a polynomial in PowerBasis representation by x^(-power).

Trait Implementations

impl Add<&Poly> for &Poly

type Output = Poly

The resulting type after applying the + operator.

fn add(self, p: &Poly) -> Poly

Performs the + operation.

impl Add for Poly

type Output = Poly

The resulting type after applying the + operator.

fn add(self, p: Poly) -> Poly

Performs the + operation.

impl AddAssign<&Poly> for Poly

fn add_assign(&mut self, p: &Poly)

Performs the += operation.

impl AsMut<Poly> for Poly

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

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

impl AsRef<Poly> for Poly

fn as_ref(&self) -> &Poly

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

impl Clone for Poly

fn clone(&self) -> Poly

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Poly

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

Formats the value using the given formatter.

impl Default for Poly

fn default() -> Poly

Returns the “default value” for a type.

impl DeserializeWithContext for Poly

type Error = Error

The type of error returned.

type Context = Context

The type of context.

fn from_bytes(bytes: &[u8], ctx: &Arc<Context>) -> Result<Self, Self::Error>

Attempt to deserialize from a vector of bytes

impl From<&Poly> for Vec<BigUint>

fn from(p: &Poly) -> Self

Converts to this type from the input type.

impl From<&Poly> for Vec<u64>

fn from(p: &Poly) -> Self

Converts to this type from the input type.

impl Mul<&BigUint> for &Poly

type Output = Poly

The resulting type after applying the * operator.

fn mul(self, p: &BigUint) -> Poly

Performs the * operation.

impl Mul<&Poly> for &BigUint

type Output = Poly

The resulting type after applying the * operator.

fn mul(self, p: &Poly) -> Poly

Performs the * operation.

impl Mul<&Poly> for &Poly

type Output = Poly

The resulting type after applying the * operator.

fn mul(self, p: &Poly) -> Poly

Performs the * operation.

impl MulAssign<&BigUint> for Poly

fn mul_assign(&mut self, p: &BigUint)

Performs the *= operation.

impl MulAssign<&Poly> for Poly

fn mul_assign(&mut self, p: &Poly)

Performs the *= operation.

impl Neg for &Poly

type Output = Poly

The resulting type after applying the - operator.

fn neg(self) -> Poly

Performs the unary - operation.

impl Neg for Poly

type Output = Poly

The resulting type after applying the - operator.

fn neg(self) -> Poly

Performs the unary - operation.

impl PartialEq for Poly

fn eq(&self, other: &Poly) -> 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 Serialize for Poly

fn to_bytes(&self) -> Vec<u8>

Serialize Self into a vector of bytes.

impl Sub<&Poly> for &Poly

type Output = Poly

The resulting type after applying the - operator.

fn sub(self, p: &Poly) -> Poly

Performs the - operation.

impl SubAssign<&Poly> for Poly

fn sub_assign(&mut self, p: &Poly)

Performs the -= operation.

impl<'a> TryConvertFrom<&'a [BigUint]> for Poly

fn try_convert_from<R>( v: &'a [BigUint], ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a, const N: usize> TryConvertFrom<&'a [BigUint; N]> for Poly

fn try_convert_from<R>( v: &'a [BigUint; N], ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a> TryConvertFrom<&'a [i64]> for Poly

fn try_convert_from<R>( v: &'a [i64], ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a, const N: usize> TryConvertFrom<&'a [i64; N]> for Poly

fn try_convert_from<R>( v: &'a [i64; N], ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a> TryConvertFrom<&'a [u64]> for Poly

fn try_convert_from<R>( v: &'a [u64], ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a, const N: usize> TryConvertFrom<&'a [u64; N]> for Poly

fn try_convert_from<R>( v: &'a [u64; N], ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a> TryConvertFrom<&'a Vec<i64>> for Poly

fn try_convert_from<R>( v: &'a Vec<i64>, ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl<'a> TryConvertFrom<&'a Vec<u64>> for Poly

fn try_convert_from<R>( v: &'a Vec<u64>, ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl TryConvertFrom<ArrayBase<OwnedRepr<u64>, Dim<[usize; 2]>>> for Poly

fn try_convert_from<R>( a: Array2<u64>, ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl TryConvertFrom<Vec<u64>> for Poly

fn try_convert_from<R>( v: Vec<u64>, ctx: &Arc<Context>, variable_time: bool, representation: R, ) -> Result<Self>

where R: Into<Option<Representation>>,

Attempt to convert the value into a polynomial with a specific context and under a specific representation. The representation may optional and be specified as None; this is useful for example when converting from a value that encodes the representation (e.g., serialization, protobuf, etc.).

impl Zeroize for Poly

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Poly

impl StructuralPartialEq for Poly