Struct AllocatedNum

pub struct AllocatedNum<E: Engine> { /* private fields */ }

Implementations

impl<E: Engine> AllocatedNum<E>

pub fn get_variable(&self) -> Variable

pub fn get_value(&self) -> Option<E::Fr>

pub fn alloc<CS, F>(cs: &mut CS, value: F) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>, F: FnOnce() -> Result<E::Fr, SynthesisError>,

pub fn alloc_input<CS, F>(cs: &mut CS, value: F) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>, F: FnOnce() -> Result<E::Fr, SynthesisError>,

pub fn from_boolean_is(boolean: Boolean) -> Self

pub fn alloc_cnst<CS>(cs: &mut CS, fr: E::Fr) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn inputize<CS: ConstraintSystem<E>>( &self, cs: &mut CS, ) -> Result<(), SynthesisError>

pub fn one<CS: ConstraintSystem<E>>(cs: &mut CS) -> Self

pub fn zero<CS: ConstraintSystem<E>>(cs: &mut CS) -> Self

pub fn enforce_equal<CS>( &self, cs: &mut CS, other: &Self, ) -> Result<(), SynthesisError>

where CS: ConstraintSystem<E>,

pub fn inverse<CS: ConstraintSystem<E>>( &self, cs: &mut CS, ) -> Result<Self, SynthesisError>

pub fn assert_not_zero<CS>(&self, cs: &mut CS) -> Result<(), SynthesisError>

where CS: ConstraintSystem<E>,

pub fn assert_is_zero<CS>(&self, cs: &mut CS) -> Result<(), SynthesisError>

where CS: ConstraintSystem<E>,

pub fn assert_equal_to_constant<CS>( &self, cs: &mut CS, constant: E::Fr, ) -> Result<(), SynthesisError>

where CS: ConstraintSystem<E>,

pub fn is_zero<CS>(&self, cs: &mut CS) -> Result<Boolean, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn conditionally_reverse<CS>( cs: &mut CS, a: &Self, b: &Self, condition: &Boolean, ) -> Result<(Self, Self), SynthesisError>

where CS: ConstraintSystem<E>,

Takes two allocated numbers (a, b) and returns (b, a) if the condition is true, and (a, b) otherwise.

pub fn equals<CS: ConstraintSystem<E>>( cs: &mut CS, a: &Self, b: &Self, ) -> Result<Boolean, SynthesisError>

pub fn add<CS>(&self, cs: &mut CS, other: &Self) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn sub<CS>(&self, cs: &mut CS, other: &Self) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn add_constant<CS>( &self, cs: &mut CS, constant: E::Fr, ) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn sub_constant<CS>( &self, cs: &mut CS, constant: E::Fr, ) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn fma<CS: ConstraintSystem<E>>( &self, cs: &mut CS, b: Self, c: Self, ) -> Result<Self, SynthesisError>

pub fn fma_with_coefficients<CS: ConstraintSystem<E>>( &self, cs: &mut CS, b: (E::Fr, Self), c: (E::Fr, Self), ) -> Result<Self, SynthesisError>

pub fn mask_by_boolean_into_accumulator<CS: ConstraintSystem<E>>( &self, cs: &mut CS, boolean: &Boolean, accumulator: &Self, ) -> Result<Self, SynthesisError>

pub fn add_two<CS: ConstraintSystem<E>>( &self, cs: &mut CS, x: Self, y: Self, ) -> Result<Self, SynthesisError>

pub fn mul_constant<CS>( &self, cs: &mut CS, constant: E::Fr, ) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn mul<CS>(&self, cs: &mut CS, other: &Self) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn square<CS>(&self, cs: &mut CS) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn conditionally_select<CS>( cs: &mut CS, a: &Self, b: &Self, condition: &Boolean, ) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

Takes two allocated numbers (a, b) and returns a if the condition is true, and b otherwise. Most often to be used with b = 0

pub fn mask<CS>( cs: &mut CS, a: &Self, condition: &Boolean, ) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

Masks a value with a Boolean

pub fn div<CS>(&self, cs: &mut CS, other: &Self) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>,

pub fn pow<CS, F>( cs: &mut CS, base: &Self, d: F, ) -> Result<Self, SynthesisError>

where CS: ConstraintSystem<E>, F: AsRef<[Boolean]>,

pub fn into_bits_le<CS>( &self, cs: &mut CS, bit_length: Option<usize>, ) -> Result<Vec<Boolean>, SynthesisError>

where CS: ConstraintSystem<E>,

Return (fixed) amount of bits of the allocated number. Can be used when there is a priori knowledge of bit length of the number

Trait Implementations

impl<E: Engine> Clone for AllocatedNum<E>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Engine> Debug for AllocatedNum<E>

where E::Fr: Debug,

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

Formats the value using the given formatter.

impl<E: Engine> From<AllocatedNum<E>> for AmplifiedLinearCombination<E>

fn from(num: AllocatedNum<E>) -> AmplifiedLinearCombination<E>

Converts to this type from the input type.

impl<E: Engine> From<AllocatedNum<E>> for LinearCombination<E>

fn from(num: AllocatedNum<E>) -> LinearCombination<E>

Converts to this type from the input type.

impl<E: Engine> Copy for AllocatedNum<E>