Struct ArkFieldWrapper 

pub struct ArkFieldWrapper<F: Field> { /* private fields */ }

Wrapper struct that allows arkworks Field types to be used as feanor-math rings.

This is a zero-sized type that acts as a bridge between the two type systems. All arkworks field operations are mapped to their feanor-math equivalents.

Implementations

impl<F: Field> ArkFieldWrapper<F>

pub const fn new() -> Self

Create a new instance of the field wrapper.

Example

use ark_bn254::Fr;
use ark_feanor::ArkFieldWrapper;
 
let field = ArkFieldWrapper::<Fr>::new();

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Field> Debug for ArkFieldWrapper<F>

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

Formats the value using the given formatter.

impl<F: Field> Default for ArkFieldWrapper<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Field> Display for ArkFieldWrapper<F>

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

Formats the value using the given formatter.

impl<F: PrimeField> DivisibilityRing for ArkFieldWrapper<F>

fn checked_left_div( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Checks whether there is an element x such that rhs * x = lhs, and returns it if it exists.

fn is_unit(&self, el: &Self::Element) -> bool

Returns whether the given element is a unit, i.e. has an inverse.

type PreparedDivisorData = ()

Additional data associated to a fixed ring element that can be used to speed up division by this ring element.

fn divides_left(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Returns whether there is an element x such that rhs * x = lhs. If you need such an element, consider using DivisibilityRing::checked_left_div().

fn divides(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

Same as DivisibilityRing::divides_left(), but requires a commutative ring.

fn checked_div( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Same as DivisibilityRing::checked_left_div(), but requires a commutative ring.

fn balance_factor<'a, I>(&self, _elements: I) -> Option<Self::Element>

where I: Iterator<Item = &'a Self::Element>, Self: 'a,

Function that computes a “balancing” factor of a sequence of ring elements. The only use of the balancing factor is to increase performance, in particular, dividing all elements in the sequence by this factor should make them “smaller” resp. cheaper to process.

fn prepare_divisor(&self, _: &Self::Element) -> Self::PreparedDivisorData

“Prepares” an element of this ring for division.

fn checked_left_div_prepared( &self, lhs: &Self::Element, rhs: &Self::Element, _rhs_prep: &Self::PreparedDivisorData, ) -> Option<Self::Element>

Same as DivisibilityRing::checked_left_div() but for a prepared divisor.

fn divides_left_prepared( &self, lhs: &Self::Element, rhs: &Self::Element, _rhs_prep: &Self::PreparedDivisorData, ) -> bool

Same as DivisibilityRing::divides_left() but for a prepared divisor.

fn is_unit_prepared(&self, x: &PreparedDivisor<Self>) -> bool

Same as DivisibilityRing::is_unit() but for a prepared divisor.

fn invert(&self, el: &Self::Element) -> Option<Self::Element>

If the given element is a unit, returns its inverse, otherwise None.

impl<F: PrimeField> EuclideanRing for ArkFieldWrapper<F>

fn euclidean_div_rem( &self, lhs: Self::Element, rhs: &Self::Element, ) -> (Self::Element, Self::Element)

Computes euclidean division with remainder.

fn euclidean_deg(&self, el: &Self::Element) -> Option<usize>

Defines how “small” an element is. For details, see EuclideanRing.

fn euclidean_div( &self, lhs: Self::Element, rhs: &Self::Element, ) -> Self::Element

Computes euclidean division without remainder.

fn euclidean_rem( &self, lhs: Self::Element, rhs: &Self::Element, ) -> Self::Element

Computes only the remainder of euclidean division.

impl<F: PrimeField> Field for ArkFieldWrapper<F>

fn div(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

Computes the division lhs / rhs, where rhs != 0.

impl<F: PrimeField> FieldProperties for ArkFieldWrapper<F>

fn field_characteristic_biguint(&self) -> BigUint

Get the characteristic of the field as a BigUint

fn is_prime_field(&self) -> bool

Check if the field is a prime field

fn field_size(&self) -> BigUint

Get the field size (number of elements)

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

fn eq(&self, _other: &Self) -> 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<F: PrimeField> PrincipalIdealRing for ArkFieldWrapper<F>

fn ideal_gen(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

Computes a generator g of the ideal (lhs, rhs) = (g), also known as greatest common divisor.

fn extended_ideal_gen( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> (Self::Element, Self::Element, Self::Element)

Computes a Bezout identity for the generator g of the ideal (lhs, rhs) as g = s * lhs + t * rhs.

fn checked_div_min( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Similar to DivisibilityRing::checked_left_div() this computes a “quotient” q of lhs and rhs, if it exists. However, we impose the additional constraint that this quotient be minimal, i.e. there is no q' with q' | q properly and q' * rhs = lhs.

fn annihilator(&self, val: &Self::Element) -> Self::Element

Returns the (w.r.t. divisibility) smallest element x such that x * val = 0.

fn create_elimination_matrix( &self, a: &Self::Element, b: &Self::Element, ) -> ([Self::Element; 4], Self::Element)

Creates a matrix A of unit determinant such that A * (a, b)^T = (d, 0). Returns (A, d).

fn ideal_gen_with_controller<Controller>( &self, lhs: &Self::Element, rhs: &Self::Element, _: Controller, ) -> Self::Element

where Controller: ComputationController,

As PrincipalIdealRing::ideal_gen(), this computes a generator of the ideal (lhs, rhs). However, it additionally accepts a ComputationController to customize the performed computation.

fn lcm(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

Computes a generator of the ideal (lhs) ∩ (rhs), also known as least common multiple.

impl<F: Field> RingBase for ArkFieldWrapper<F>

type Element = F

Type of elements of the ring

fn clone_el(&self, el: &Self::Element) -> Self::Element

fn add_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn add_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn negate_inplace(&self, el: &mut Self::Element)

fn mul_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn mul_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn from_int(&self, value: i32) -> Self::Element

fn eq_el(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

fn is_zero(&self, el: &Self::Element) -> bool

fn is_one(&self, el: &Self::Element) -> bool

fn is_neg_one(&self, el: &Self::Element) -> bool

fn zero(&self) -> Self::Element

fn one(&self) -> Self::Element

fn neg_one(&self) -> Self::Element

fn is_commutative(&self) -> bool

Returns whether the ring is commutative, i.e. a * b = b * a for all elements a, b. Note that addition is assumed to be always commutative.

fn is_noetherian(&self) -> bool

Returns whether the ring is noetherian, i.e. every ideal is finitely generated.

fn is_approximate(&self) -> bool

Returns whether this ring computes with approximations to elements. This would usually be the case for rings that are based on f32 or f64, to represent real or complex numbers.

fn dbg<'a>(&self, el: &Self::Element, out: &mut Formatter<'a>) -> Result

Writes a human-readable representation of value to out.

fn dbg_within<'a>( &self, el: &Self::Element, out: &mut Formatter<'a>, _env: EnvBindingStrength, ) -> Result

Writes a human-readable representation of value to out, taking into account the possible context to place parenthesis as needed.

fn characteristic<I>( &self, _int_ring: I, ) -> Option<<I::Type as RingBase>::Element>

where I: RingStore + Copy, I::Type: IntegerRing,

Returns the characteristic of this ring as an element of the given implementation of ZZ.

fn add_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn sub_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn mul_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn fma( &self, lhs: &Self::Element, rhs: &Self::Element, summand: Self::Element, ) -> Self::Element

Fused-multiply-add. This computes summand + lhs * rhs.

fn square(&self, value: &mut Self::Element)

fn negate(&self, value: Self::Element) -> Self::Element

fn sub_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn mul_assign_int(&self, lhs: &mut Self::Element, rhs: i32)

fn mul_int(&self, lhs: Self::Element, rhs: i32) -> Self::Element

fn mul_int_ref(&self, lhs: &Self::Element, rhs: i32) -> Self::Element

fn fma_int( &self, lhs: &Self::Element, rhs: i32, summand: Self::Element, ) -> Self::Element

Fused-multiply-add with an integer. This computes summand + lhs * rhs.

fn sub_self_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

Computes lhs := rhs - lhs.

fn sub_self_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

Computes lhs := rhs - lhs.

fn add_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn add_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn add(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn sub_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn sub(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn mul(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn pow_gen<R>( &self, x: Self::Element, power: &<<R as RingStore>::Type as RingBase>::Element, integers: R, ) -> Self::Element

where R: RingStore, <R as RingStore>::Type: IntegerRing,

Raises x to the power of an arbitrary, nonnegative integer given by a custom integer ring implementation.

fn sum<I>(&self, els: I) -> Self::Element

where I: IntoIterator<Item = Self::Element>,

Sums the elements given by the iterator.

fn prod<I>(&self, els: I) -> Self::Element

where I: IntoIterator<Item = Self::Element>,

Computes the product of the elements given by the iterator.

impl<F: Copy + Field> Copy for ArkFieldWrapper<F>

impl<F: PrimeField> Domain for ArkFieldWrapper<F>

impl<F: Field> Eq for ArkFieldWrapper<F>