Enum folding::Alphas

pub enum Alphas<F: Field> {
    Powers(F, Rc<AtomicUsize>),
    Combinations(Vec<F>),
}

Combinators that will be used to fold the constraints, called the “alphas”. The alphas are exceptional, their number cannot be known ahead of time as it will be defined by folding. The values will be computed as powers in new instances, but after folding each alpha will be a linear combination of other alphas, instand of a power of other element. This type represents that, allowing to also recognize which case is present.

Variants

Powers(F, Rc<AtomicUsize>)

Combinations(Vec<F>)

Implementations

impl<F: Field> Alphas<F>

pub fn new(alpha: F) -> Self

pub fn new_sized(alpha: F, count: usize) -> Self

pub fn get(&self, i: usize) -> Option<F>

pub fn powers(self) -> Vec<F>

Trait Implementations

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

fn clone(&self) -> Alphas<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 Alphas<F>

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

Formats the value using the given formatter.

impl<F: Field> Foldable<F> for Alphas<F>

fn combine(a: Self, b: Self, challenge: F) -> Self

Combine two objects ‘a’ and ‘b’ into a new object using the challenge.

impl<F: Field> PartialEq<Alphas<F>> for Alphas<F>

fn eq(&self, other: &Self) -> 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> Eq for Alphas<F>