Struct AllocatedFp 

pub struct AllocatedFp<F: PrimeField> {
    pub variable: Variable,
    pub cs: ConstraintSystemRef<F>,
    /* private fields */
}

Represents a variable in the constraint system whose value can be an arbitrary field element.

Fields

variable: Variable

The allocated variable corresponding to self in self.cs.

cs: ConstraintSystemRef<F>

The constraint system that self was allocated in.

Implementations

impl<F: PrimeField> AllocatedFp<F>

pub fn new( value: Option<F>, variable: Variable, cs: ConstraintSystemRef<F>, ) -> Self

Constructs a new AllocatedFp from a (optional) value, a low-level Variable, and a ConstraintSystemRef.

impl<F: PrimeField> AllocatedFp<F>

pub fn from(other: Boolean<F>) -> Self

Constructs Self from a Boolean: if other is false, this outputs zero, else it outputs one.

pub fn value(&self) -> Result<F, SynthesisError>

Returns the value assigned to self in the underlying constraint system (if a value was assigned).

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

Outputs self + other.

This does not create any constraints.

pub fn add_many<B: Borrow<Self>>(iter: &[B]) -> Option<Self>

Add many allocated Fp elements together.

This does not create any constraints and only creates one linear combination.

Returns None if you pass an empty iterator.

pub fn linear_combination<B1, B2, I1>(this: I1, other: &[B2]) -> Option<Self>

where B1: Borrow<F>, B2: Borrow<Self>, I1: IntoIterator<Item = B1, IntoIter: Clone>,

Computes the inner product of two iterators of AllocatedFp elements.

This does not create any constraints and only creates one linear combination.

Panics

Panics if the iterators are of different lengths.

pub fn inner_product<B1, B2, I1, I2>(this: I1, other: I2) -> Option<Self>

where B1: Borrow<Self>, B2: Borrow<Self>, I1: IntoIterator<Item = B1>, I2: IntoIterator<Item = B2>,

Computes the inner product of two iterators of AllocatedFp elements.

This does not create any constraints and only creates one linear combination.

Panics

Panics if the iterators are of different lengths.

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

Outputs self - other.

This does not create any constraints.

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

Outputs self * other.

This requires one constraint.

pub fn add_constant(&self, other: F) -> Self

Output self + other

This does not create any constraints.

pub fn sub_constant(&self, other: F) -> Self

Output self - other

This does not create any constraints.

pub fn mul_constant(&self, other: F) -> Self

Output self * other

This does not create any constraints.

pub fn double(&self) -> Result<Self, SynthesisError>

Output self + self

This does not create any constraints.

pub fn negate(&self) -> Self

Output -self

This does not create any constraints.

pub fn negate_in_place(&mut self) -> &mut Self

Sets self = -self

This does not create any constraints.

pub fn square(&self) -> Result<Self, SynthesisError>

Outputs self * self

This requires one constraint.

pub fn inverse(&self) -> Result<Self, SynthesisError>

Outputs result such that result * self = 1.

This requires one constraint.

pub fn frobenius_map(&self, _: usize) -> Result<Self, SynthesisError>

This is a no-op for prime fields.

pub fn mul_equals( &self, other: &Self, result: &Self, ) -> Result<(), SynthesisError>

Enforces that self * other = result.

This requires one constraint.

pub fn square_equals(&self, result: &Self) -> Result<(), SynthesisError>

Enforces that self * self = result.

This requires one constraint.

pub fn is_eq(&self, other: &Self) -> Result<Boolean<F>, SynthesisError>

Outputs the bit self == other.

This requires two constraints.

pub fn is_neq(&self, other: &Self) -> Result<Boolean<F>, SynthesisError>

Outputs the bit self != other.

This requires two constraints.

pub fn conditional_enforce_equal( &self, other: &Self, should_enforce: &Boolean<F>, ) -> Result<(), SynthesisError>

Enforces that self == other if should_enforce.is_eq(&Boolean::TRUE).

This requires one constraint.

pub fn conditional_enforce_not_equal( &self, other: &Self, should_enforce: &Boolean<F>, ) -> Result<(), SynthesisError>

Enforces that self != other if should_enforce.is_eq(&Boolean::TRUE).

This requires one constraint.

Trait Implementations

impl<F: PrimeField> AllocVar<F, F> for AllocatedFp<F>

fn new_variable<T: Borrow<F>>( cs: impl Into<Namespace<F>>, f: impl FnOnce() -> Result<T, SynthesisError>, mode: AllocationMode, ) -> Result<Self, SynthesisError>

Allocates a new variable of type Self in the ConstraintSystem cs. The mode of allocation is decided by mode.

fn new_constant( cs: impl Into<Namespace<F>>, t: impl Borrow<V>, ) -> Result<Self, SynthesisError>

Allocates a new constant of type Self in the ConstraintSystem cs.

fn new_input<T: Borrow<V>>( cs: impl Into<Namespace<F>>, f: impl FnOnce() -> Result<T, SynthesisError>, ) -> Result<Self, SynthesisError>

Allocates a new public input of type Self in the ConstraintSystem cs.

fn new_witness<T: Borrow<V>>( cs: impl Into<Namespace<F>>, f: impl FnOnce() -> Result<T, SynthesisError>, ) -> Result<Self, SynthesisError>

Allocates a new private witness of type Self in the ConstraintSystem cs.

fn new_variable_with_inferred_mode<T: Borrow<V>>( cs: impl Into<Namespace<F>>, f: impl FnOnce() -> Result<T, SynthesisError>, ) -> Result<Self, SynthesisError>

Allocates a new constant or private witness of type Self in the ConstraintSystem cs with the allocation mode inferred from cs. A constant is allocated if cs is None, and a private witness is allocated otherwise.

impl<F: Clone + PrimeField> Clone for AllocatedFp<F>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: PrimeField> CondSelectGadget<F> for AllocatedFp<F>

fn conditionally_select( cond: &Boolean<F>, true_val: &Self, false_val: &Self, ) -> Result<Self, SynthesisError>

If cond == &Boolean::TRUE, then this returns true_value; else, returns false_value.

fn conditionally_select_power_of_two_vector( position: &[Boolean<ConstraintF>], values: &[Self], ) -> Result<Self, SynthesisError>

Returns an element of values whose index in represented by position. position is an array of boolean that represents an unsigned integer in big endian order.

impl<F: Debug + PrimeField> Debug for AllocatedFp<F>

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

Formats the value using the given formatter.

impl<F: PrimeField> From<AllocatedFp<F>> for FpVar<F>

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

Converts to this type from the input type.

impl<F: PrimeField> ThreeBitCondNegLookupGadget<F> for AllocatedFp<F>

type TableConstant = F

The type of values being looked up.

fn three_bit_cond_neg_lookup( b: &[Boolean<F>], b0b1: &Boolean<F>, c: &[Self::TableConstant], ) -> Result<Self, SynthesisError>

Interprets the slice bits as a two-bit integer b = bits[0] + (bits[1] << 1), and then outputs constants[b] * c, where c = if bits[2] { -1 } else { 1 };.

impl<F: PrimeField> ToBitsGadget<F> for AllocatedFp<F>

---

---

fn to_bits_le(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs the unique bit-wise decomposition of self in little-endian form.

This method enforces that the output is in the field, i.e. it invokes Boolean::enforce_in_field_le on the bit decomposition.

fn to_non_unique_bits_le(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs a possibly non-unique little-endian bit-wise representation of self.

fn to_bits_be(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs the canonical big-endian bit-wise representation of self.

fn to_non_unique_bits_be(&self) -> Result<Vec<Boolean<F>>, SynthesisError>

Outputs a possibly non-unique big-endian bit-wise representation of self.

impl<F: PrimeField> ToBytesGadget<F> for AllocatedFp<F>

fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError>

Outputs the unique byte decomposition of self in little-endian form.

This method enforces that the decomposition represents an integer that is less than F::MODULUS.

fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError>

Outputs a possibly non-unique byte decomposition of self.

impl<F: PrimeField> ToConstraintFieldGadget<F> for AllocatedFp<F>

fn to_constraint_field(&self) -> Result<Vec<FpVar<F>>, SynthesisError>

Converts self to FpVar<ConstraintF> variables.

impl<F: PrimeField> TwoBitLookupGadget<F> for AllocatedFp<F>

Uses two bits to perform a lookup into a table b is little-endian: b[0] is LSB.

type TableConstant = F

The type of values being looked up.

fn two_bit_lookup( b: &[Boolean<F>], c: &[Self::TableConstant], ) -> Result<Self, SynthesisError>

Interprets the slice bits as a two-bit integer b = bits[0] + (bits[1] << 1), and then outputs constants[b].