Struct AllocatedNonNativeFieldVar 

pub struct AllocatedNonNativeFieldVar<TargetField: PrimeField, BaseField: PrimeField> {
    pub cs: ConstraintSystemRef<BaseField>,
    pub limbs: Vec<FpVar<BaseField>>,
    pub num_of_additions_over_normal_form: BaseField,
    pub is_in_the_normal_form: bool,
    /* private fields */
}

The allocated version of NonNativeFieldVar (introduced below)

Fields

cs: ConstraintSystemRef<BaseField>

Constraint system reference

limbs: Vec<FpVar<BaseField>>

The limbs, each of which is a BaseField gadget.

num_of_additions_over_normal_form: BaseField

Number of additions done over this gadget, using which the gadget decides when to reduce.

is_in_the_normal_form: bool

Whether the limb representation is the normal form (using only the bits specified in the parameters, and the representation is strictly within the range of TargetField).

Implementations

impl<TargetField: PrimeField, BaseField: PrimeField> AllocatedNonNativeFieldVar<TargetField, BaseField>

pub fn cs(&self) -> ConstraintSystemRef<BaseField>

Return cs

pub fn limbs_to_value( limbs: Vec<BaseField>, optimization_type: OptimizationType, ) -> TargetField

Obtain the value of limbs

pub fn value(&self) -> R1CSResult<TargetField>

Obtain the value of a nonnative field element

pub fn constant( cs: ConstraintSystemRef<BaseField>, value: TargetField, ) -> R1CSResult<Self>

Obtain the nonnative field element of a constant value

pub fn one(cs: ConstraintSystemRef<BaseField>) -> R1CSResult<Self>

Obtain the nonnative field element of one

pub fn zero(cs: ConstraintSystemRef<BaseField>) -> R1CSResult<Self>

Obtain the nonnative field element of zero

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

Add a nonnative field element

pub fn add_constant(&self, other: &TargetField) -> R1CSResult<Self>

Add a constant

pub fn sub_without_reduce(&self, other: &Self) -> R1CSResult<Self>

Subtract a nonnative field element, without the final reduction step

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

Subtract a nonnative field element

pub fn sub_constant(&self, other: &TargetField) -> R1CSResult<Self>

Subtract a constant

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

Multiply a nonnative field element

pub fn mul_constant(&self, other: &TargetField) -> R1CSResult<Self>

Multiply a constant

pub fn negate(&self) -> R1CSResult<Self>

Compute the negate of a nonnative field element

pub fn inverse(&self) -> R1CSResult<Self>

Compute the inverse of a nonnative field element

pub fn get_limbs_representations( elem: &TargetField, optimization_type: OptimizationType, ) -> R1CSResult<Vec<BaseField>>

Convert a TargetField element into limbs (not constraints) This is an internal function that would be reused by a number of other functions

pub fn get_limbs_representations_from_big_integer( elem: &<TargetField as PrimeField>::BigInt, optimization_type: OptimizationType, ) -> R1CSResult<Vec<BaseField>>

Obtain the limbs directly from a big int

pub fn mul_without_reduce( &self, other: &Self, ) -> R1CSResult<AllocatedNonNativeFieldMulResultVar<TargetField, BaseField>>

for advanced use, multiply and output the intermediate representations (without reduction) This intermediate representations can be added with each other, and they can later be reduced back to the NonNativeFieldVar.

Trait Implementations

impl<TargetField: PrimeField, BaseField: PrimeField> AllocVar<TargetField, BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

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

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>( cs: impl Into<Namespace<F>>, f: impl FnOnce() -> Result<T, SynthesisError>, ) -> Result<Self, SynthesisError>

where T: Borrow<V>,

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

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

where T: Borrow<V>,

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

impl<TargetField: PrimeField, BaseField: PrimeField> Clone for AllocatedNonNativeFieldVar<TargetField, BaseField>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TargetField: PrimeField, BaseField: PrimeField> CondSelectGadget<BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

fn conditionally_select( cond: &Boolean<BaseField>, true_value: &Self, false_value: &Self, ) -> R1CSResult<Self>

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<TargetField: Debug + PrimeField, BaseField: Debug + PrimeField> Debug for AllocatedNonNativeFieldVar<TargetField, BaseField>

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

Formats the value using the given formatter.

impl<TargetField: PrimeField, BaseField: PrimeField> From<&AllocatedNonNativeFieldVar<TargetField, BaseField>> for AllocatedNonNativeFieldMulResultVar<TargetField, BaseField>

fn from(src: &AllocatedNonNativeFieldVar<TargetField, BaseField>) -> Self

Converts to this type from the input type.

impl<TargetField: PrimeField, BaseField: PrimeField> From<AllocatedNonNativeFieldVar<TargetField, BaseField>> for NonNativeFieldVar<TargetField, BaseField>

fn from(other: AllocatedNonNativeFieldVar<TargetField, BaseField>) -> Self

Converts to this type from the input type.

impl<TargetField: PrimeField, BaseField: PrimeField> ThreeBitCondNegLookupGadget<BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

type TableConstant = TargetField

The type of values being looked up.

fn three_bit_cond_neg_lookup( bits: &[Boolean<BaseField>], b0b1: &Boolean<BaseField>, constants: &[Self::TableConstant], ) -> R1CSResult<Self>

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<TargetField: PrimeField, BaseField: PrimeField> ToBitsGadget<BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

fn to_bits_le(&self) -> R1CSResult<Vec<Boolean<BaseField>>>

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

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<TargetField: PrimeField, BaseField: PrimeField> ToBytesGadget<BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

fn to_bytes(&self) -> R1CSResult<Vec<UInt8<BaseField>>>

Outputs a canonical, little-endian, byte decomposition of self.

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

Outputs a possibly non-unique byte decomposition of self.

impl<TargetField: PrimeField, BaseField: PrimeField> ToConstraintFieldGadget<BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

fn to_constraint_field(&self) -> R1CSResult<Vec<FpVar<BaseField>>>

Converts self to FpVar<ConstraintF> variables.

impl<TargetField: PrimeField, BaseField: PrimeField> TwoBitLookupGadget<BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField>

type TableConstant = TargetField

The type of values being looked up.

fn two_bit_lookup( bits: &[Boolean<BaseField>], constants: &[Self::TableConstant], ) -> R1CSResult<Self>

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