Struct ForeignElement 

pub struct ForeignElement<F: Field, const B: usize, const N: usize> {
    pub limbs: [F; N],
    len: usize,
}

Represents a foreign field element Represents a foreign field element

Fields

limbs: [F; N]

limbs in little endian order

len: usize

number of limbs used for the foreign field element

Implementations

impl<F: Field, const B: usize, const N: usize> ForeignElement<F, B, N>

pub const fn new(limbs: [F; N]) -> Self

Creates a new foreign element from an array containing N limbs

pub fn zero() -> Self

Creates a new foreign element representing the value zero

pub fn from_biguint(big: &BigUint) -> Self

Initializes a new foreign element from a BigUint

Panics

Panics if the BigUint is too large to fit in the N limbs.

pub fn neg(&self, modulus: &BigUint) -> Self

Initializes a new foreign element from an absolute BigUint but the equivalent foreign element obtained corresponds to the negated input. It first converts the input big element to a big integer modulo the foreign field modulus, and then computes the negation of the result.

pub fn from_be(bytes: &[u8]) -> Self

Initializes a new foreign element from a set of bytes in big endian

pub fn to_biguint(&self) -> BigUint

Obtains the big integer representation of the foreign field element

fn big_to_vec(fe: &BigUint) -> Vec<F>

Split a foreign field element into a vector of B (limb bitsize) bits field elements of type F in little-endian. Right now it is written so that it gives N (limb count) limbs, even if it fits in less bits.

impl<F: PrimeField, const B: usize, const N: usize> ForeignElement<F, B, N>

pub fn from_field(field: F) -> Self

Initializes a new foreign element from an element in the native field

Trait Implementations

impl<F: Clone + Field, const B: usize, const N: usize> Clone for ForeignElement<F, B, N>

fn clone(&self) -> ForeignElement<F, B, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Field, const B: usize, const N: usize> Debug for ForeignElement<F, B, N>

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

Formats the value using the given formatter.

impl<F: Field, const B: usize, const N: usize> ForeignFieldHelpers<F, B> for ForeignElement<F, B, N>

fn two_to_limb() -> F

2^{B}

fn two_to_2limb() -> F

2^{2 * B}

fn two_to_3limb() -> F

2^{3 * B}

impl<F: Field, const B: usize, const N: usize> Index<usize> for ForeignElement<F, B, N>

type Output = F

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<F: Field, const B: usize, const N: usize> IndexMut<usize> for ForeignElement<F, B, N>

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<F: PartialEq + Field, const B: usize, const N: usize> PartialEq for ForeignElement<F, B, N>

fn eq(&self, other: &ForeignElement<F, B, N>) -> 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: Eq + Field, const B: usize, const N: usize> Eq for ForeignElement<F, B, N>

impl<F: Field, const B: usize, const N: usize> StructuralPartialEq for ForeignElement<F, B, N>