Struct snarkvm_algorithms::polycommit::sonic_pc::LabeledPolynomial

pub struct LabeledPolynomial<F: Field> {
    pub info: PolynomialInfo,
    pub polynomial: Polynomial<'static, F>,
}

A polynomial along with information about its degree bound (if any), and the maximum number of queries that will be made to it. This latter number determines the amount of protection that will be provided to a commitment for this polynomial.

Fields

info: PolynomialInfo

polynomial: Polynomial<'static, F>

Implementations

impl<F: Field> LabeledPolynomial<F>

pub fn new(
    label: PolynomialLabel,
    polynomial: impl Into<Polynomial<'static, F>>,
    degree_bound: Option<usize>,
    hiding_bound: Option<usize>
) -> Self

Construct a new labeled polynomial by consuming polynomial.

pub fn info(&self) -> &PolynomialInfo

pub fn label(&self) -> &str

Return the label for self.

pub fn polynomial(&self) -> &Polynomial<'_, F>

Retrieve the polynomial from self.

pub fn polynomial_mut(&mut self) -> &mut Polynomial<'static, F>

Retrieve a mutable reference to the enclosed polynomial.

pub fn evaluate(&self, point: F) -> F

Evaluate the polynomial in self.

pub fn degree_bound(&self) -> Option<usize>

Retrieve the degree bound in self.

pub fn is_hiding(&self) -> bool

Retrieve whether the polynomial in self should be hidden.

pub fn hiding_bound(&self) -> Option<usize>

Retrieve the hiding bound for the polynomial in self.

Methods from Deref<Target = Polynomial<'static, F>>

pub fn is_zero(&self) -> bool

Checks if the given polynomial is zero.

pub fn degree(&self) -> usize

Return the degree of `self.

pub fn leading_coefficient(&self) -> Option<&F>

pub fn as_dense(&self) -> Option<&DensePolynomial<F>>

pub fn to_dense(&self) -> Cow<'_, DensePolynomial<F>>

pub fn as_sparse(&self) -> Option<&SparsePolynomial<F>>

pub fn into_dense(&self) -> DensePolynomial<F>

pub fn evaluate(&self, point: F) -> F

pub fn coeffs(&'a self) -> Box<dyn Iterator<Item = (usize, &'a F)> + 'a>

pub fn divide_with_q_and_r(
    &self,
    divisor: &Self
) -> Option<(DensePolynomial<F>, DensePolynomial<F>)>

Divide self by another (sparse or dense) polynomial, and returns the quotient and remainder.

Trait Implementations

impl<F: Field> CanonicalDeserialize for LabeledPolynomial<F>

fn deserialize_with_mode<R: Read>(
    reader: R,
    compress: Compress,
    validate: Validate
) -> Result<Self, SerializationError>

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>where
    R: Read,

fn deserialize_compressed_unchecked<R>(
    reader: R
) -> Result<Self, SerializationError>where
    R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>where
    R: Read,

fn deserialize_uncompressed_unchecked<R>(
    reader: R
) -> Result<Self, SerializationError>where
    R: Read,

impl<F: Field> CanonicalSerialize for LabeledPolynomial<F>

fn serialize_with_mode<W: Write>(
    &self,
    writer: W,
    compress: Compress
) -> Result<(), SerializationError>

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>where
    W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>where
    W: Write,

fn uncompressed_size(&self) -> usize

impl<F: Clone + Field> Clone for LabeledPolynomial<F>

fn clone(&self) -> LabeledPolynomial<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for LabeledPolynomial<F>

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

Formats the value using the given formatter.

impl<F: Field> Deref for LabeledPolynomial<F>

type Target = Polynomial<'static, F>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, F: PrimeField> From<&'a LabeledPolynomial<F>> for LabeledPolynomialWithBasis<'a, F>

fn from(other: &'a LabeledPolynomial<F>) -> Self

Converts to this type from the input type.

impl<'a, F: PrimeField> From<LabeledPolynomial<F>> for LabeledPolynomialWithBasis<'a, F>

fn from(other: LabeledPolynomial<F>) -> Self

Converts to this type from the input type.

impl<F: PartialEq + Field> PartialEq<LabeledPolynomial<F>> for LabeledPolynomial<F>

fn eq(&self, other: &LabeledPolynomial<F>) -> 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<F: Field> Valid for LabeledPolynomial<F>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>(
    batch: impl Iterator<Item = &'a Self> + Send
) -> Result<(), SerializationError>where
    Self: 'a,

impl<F: Eq + Field> Eq for LabeledPolynomial<F>

impl<F: Field> StructuralEq for LabeledPolynomial<F>

impl<F: Field> StructuralPartialEq for LabeledPolynomial<F>