Struct RnsParameters

pub struct RnsParameters<E: Engine, F: PrimeField> {

    pub binary_limbs_params: LimbedRepresentationParameters<E>,
    pub num_binary_limbs: usize,
    pub binary_modulus: BigUint,
    pub num_limbs_for_in_field_representation: usize,
    pub base_field_modulus: BigUint,
    pub binary_representation_max_value: BigUint,
    pub represented_field_modulus: BigUint,
    pub binary_limbs_bit_widths: Vec<usize>,
    pub binary_limbs_max_values: Vec<BigUint>,
    pub represented_field_modulus_limbs: Vec<E::Fr>,
    pub represented_field_modulus_negated_limbs_biguints: Vec<BigUint>,
    pub represented_field_modulus_negated_limbs: Vec<E::Fr>,
    pub represented_field_modulus_in_base_field: E::Fr,
    pub represented_field_modulus_negated_in_base_field: E::Fr,
    pub range_check_info: RangeConstraintInfo,
    pub prefer_single_limb_allocation: bool,
    pub prefer_single_limb_carry_propagation: bool,
    /* private fields */
}

Fields

binary_limbs_params: LimbedRepresentationParameters<E>

num_binary_limbs: usize

binary_modulus: BigUint

num_limbs_for_in_field_representation: usize

base_field_modulus: BigUint

binary_representation_max_value: BigUint

represented_field_modulus: BigUint

binary_limbs_bit_widths: Vec<usize>

binary_limbs_max_values: Vec<BigUint>

represented_field_modulus_limbs: Vec<E::Fr>

represented_field_modulus_negated_limbs_biguints: Vec<BigUint>

represented_field_modulus_negated_limbs: Vec<E::Fr>

represented_field_modulus_in_base_field: E::Fr

represented_field_modulus_negated_in_base_field: E::Fr

range_check_info: RangeConstraintInfo

prefer_single_limb_allocation: bool

prefer_single_limb_carry_propagation: bool

Implementations

impl<'a, E: Engine, F: PrimeField> RnsParameters<E, F>

pub fn max_representable_value(&self) -> BigUint

pub fn rns_system_max_value(&self) -> BigUint

pub fn new_for_field( limb_size: usize, intermediate_limb_capacity: usize, num_binary_limbs: usize, ) -> Self

pub fn new_for_field_with_strategy( limb_size: usize, intermediate_limb_capacity: usize, num_binary_limbs: usize, strategy: RangeConstraintInfo, prefer_single_limb_allocation: bool, ) -> Self

pub fn can_allocate_from_double_limb_witness(&self) -> bool

pub fn set_prefer_single_limb_allocation(&mut self, new_value: bool)

pub fn set_prefer_double_limb_carry_propagation(&mut self, value: bool)

pub fn propagate_carries_using_double_limbs(&self) -> bool

Trait Implementations

impl<E: Clone + Engine, F: Clone + PrimeField> Clone for RnsParameters<E, F>

where E::Fr: Clone,

fn clone(&self) -> RnsParameters<E, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Engine, F: Debug + PrimeField> Debug for RnsParameters<E, F>

where E::Fr: Debug,

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

Formats the value using the given formatter.

impl<'de, E: Engine, F: PrimeField> Deserialize<'de> for RnsParameters<E, F>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: PartialEq + Engine, F: PartialEq + PrimeField> PartialEq for RnsParameters<E, F>

where E::Fr: PartialEq,

fn eq(&self, other: &RnsParameters<E, F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Engine, F: PrimeField> Serialize for RnsParameters<E, F>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Eq + Engine, F: Eq + PrimeField> Eq for RnsParameters<E, F>

where E::Fr: Eq,

impl<E: Engine, F: PrimeField> StructuralPartialEq for RnsParameters<E, F>