Struct Field

pub struct Field<E>
where
    E: Environment,
{ /* private fields */ }

Implementations

impl<E> Field<E>

where E: Environment,

pub fn even_square_root(&self) -> Result<Field<E>, Error>

Returns the square_root of self, where the least significant bit of the square root is zero.

impl<E> Field<E>

where E: Environment,

pub const SIZE_IN_BITS: usize = <E::Field>::SIZE_IN_BITS

The field size in bits.

pub const SIZE_IN_BYTES: usize = _

The field size in bytes.

pub const SIZE_IN_DATA_BITS: usize = <E::Field>::SIZE_IN_DATA_BITS

The field capacity for data bits.

pub const fn new(field: <E as Environment>::Field) -> Field<E>

Initializes a new field.

pub fn new_domain_separator(domain: &str) -> Field<E>

Initializes a new field as a domain separator.

pub fn from_u8(value: u8) -> Field<E>

Initializes a new field from a u8.

pub fn from_u16(value: u16) -> Field<E>

Initializes a new field from a u16.

pub fn from_u32(value: u32) -> Field<E>

Initializes a new field from a u32.

pub fn from_u64(value: u64) -> Field<E>

Initializes a new field from a u64.

pub fn from_u128(value: u128) -> Field<E>

Initializes a new field from a u128.

pub fn half() -> Field<E>

Returns 1 * 2^{-1}.

Trait Implementations

impl<E> Add<&Field<E>> for Field<E>

where E: Environment,

fn add(self, other: &Field<E>) -> <Field<E> as Add<&Field<E>>>::Output

Returns the sum of self and other.

type Output = Field<E>

The resulting type after applying the + operator.

impl<E> Add for Field<E>

where E: Environment,

fn add(self, other: Field<E>) -> <Field<E> as Add>::Output

Returns the sum of self and other.

type Output = Field<E>

The resulting type after applying the + operator.

impl<E> AddAssign<&Field<E>> for Field<E>

where E: Environment,

fn add_assign(&mut self, other: &Field<E>)

Adds other to self.

impl<E> AddAssign for Field<E>

where E: Environment,

fn add_assign(&mut self, other: Field<E>)

Adds other to self.

impl<E: Environment> Cast<Address<E>> for Field<E>

fn cast(&self) -> Result<Address<E>>

Casts a Field to an Address.

This operation attempts to recover the group element from the field element, and then constructs an address from the group element.

To cast arbitrary field elements to addresses, use Field::cast_lossy.

impl<E: Environment> Cast<Boolean<E>> for Field<E>

fn cast(&self) -> Result<Boolean<E>>

Casts a Field to a Boolean, if the field is zero or one.

To cast arbitrary field elements to booleans, use Field::cast_lossy.

impl<E: Environment> Cast<Field<E>> for Boolean<E>

fn cast(&self) -> Result<Field<E>>

Casts a Boolean to a Field.

impl<E: Environment, I: IntegerType> Cast<Field<E>> for Integer<E, I>

fn cast(&self) -> Result<Field<E>>

Casts an Integer to a Field.

impl<E: Environment> Cast<Field<E>> for Scalar<E>

fn cast(&self) -> Result<Field<E>>

Casts a Scalar to a Field.

impl<E: Environment> Cast<Group<E>> for Field<E>

fn cast(&self) -> Result<Group<E>>

Casts a Field to a Group.

This operation attempts to recover the group element from the field element, and returns an error if the field element is not a valid x-coordinate.

To cast arbitrary field elements to groups, use Field::cast_lossy.

impl<E: Environment, I: IntegerType> Cast<Integer<E, I>> for Field<E>

fn cast(&self) -> Result<Integer<E, I>>

Casts a Field to an Integer, if the field element is in the integer’s range.

To cast arbitrary field elements to integers, use Field::cast_lossy.

impl<E: Environment> Cast<Scalar<E>> for Field<E>

fn cast(&self) -> Result<Scalar<E>>

Casts a Field to a Scalar, if the field element is in the scalar’s range.

To cast arbitrary field elements to scalars, use Field::cast_lossy.

impl<E: Environment> Cast for Field<E>

fn cast(&self) -> Result<Field<E>>

Casts a Field to a Field.

impl<E: Environment> CastLossy<Address<E>> for Field<E>

fn cast_lossy(&self) -> Address<E>

Casts a Field to an Address.

This operation attempts to recover the group element from the given field, which is then used to construct the address. See the documentation of Field::cast_lossy on the Group type for more details.

impl<E: Environment> CastLossy<Boolean<E>> for Field<E>

fn cast_lossy(&self) -> Boolean<E>

Casts a Field to a Boolean, with lossy truncation. This operation returns the least significant bit of the field.

impl<E: Environment> CastLossy<Field<E>> for Boolean<E>

fn cast_lossy(&self) -> Field<E>

Casts a Boolean to a Field. This is safe because casting from a boolean to any other type is always lossless.

impl<E: Environment, I: IntegerType> CastLossy<Field<E>> for Integer<E, I>

fn cast_lossy(&self) -> Field<E>

Casts an Integer to a Field. This is safe because casting from an integer to a field is always lossless.

impl<E: Environment> CastLossy<Field<E>> for Scalar<E>

fn cast_lossy(&self) -> Field<E>

Casts a Scalar to a Field. This operation is always lossless.

impl<E: Environment> CastLossy<Group<E>> for Field<E>

fn cast_lossy(&self) -> Group<E>

Casts a Field to a Group.

This operation attempts to recover the group element from the given field.

If the field is a valid x-coordinate, then the group element is returned. If the field is not a valid x-coordinate, then if the field is the one element, the generator of the prime-order subgroup is returned. Otherwise, Elligator-2 is applied to the field element to recover a group element.

impl<E: Environment, I: IntegerType> CastLossy<Integer<E, I>> for Field<E>

fn cast_lossy(&self) -> Integer<E, I>

Casts a Field to an Integer, with lossy truncation. This operation truncates the field to an integer.

impl<E: Environment> CastLossy<Scalar<E>> for Field<E>

fn cast_lossy(&self) -> Scalar<E>

Casts a Field to a Scalar, with lossy truncation. This operation truncates the field to a scalar.

impl<E: Environment> CastLossy for Field<E>

fn cast_lossy(&self) -> Field<E>

Casts a Field to a Field. This is an identity cast, so it is always lossless.

impl<E> Clone for Field<E>

where E: Clone + Environment, <E as Environment>::Field: Clone,

fn clone(&self) -> Field<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E> Compare for Field<E>

where E: Environment,

fn is_less_than(&self, other: &Field<E>) -> <Field<E> as Compare>::Output

Returns true if self is less than other.

fn is_greater_than(&self, other: &Field<E>) -> <Field<E> as Compare>::Output

Returns true if self is greater than other.

fn is_less_than_or_equal( &self, other: &Field<E>, ) -> <Field<E> as Compare>::Output

Returns true if self is less than or equal to other.

fn is_greater_than_or_equal( &self, other: &Field<E>, ) -> <Field<E> as Compare>::Output

Returns true if self is greater than or equal to other.

type Output = Boolean<E>

impl<E> Debug for Field<E>

where E: Environment,

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

Formats the value using the given formatter.

impl<E> Default for Field<E>

where E: Environment,

fn default() -> Field<E>

Returns the default field element.

impl<E> Deref for Field<E>

where E: Environment,

type Target = <E as Environment>::Field

The resulting type after dereferencing.

fn deref(&self) -> &<Field<E> as Deref>::Target

Dereferences the value.

impl<E> DerefMut for Field<E>

where E: Environment,

fn deref_mut(&mut self) -> &mut <Field<E> as Deref>::Target

Mutably dereferences the value.

impl<'de, E> Deserialize<'de> for Field<E>

where E: Environment,

fn deserialize<D>( deserializer: D, ) -> Result<Field<E>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserializes the field from a string or bytes.

impl<E> Display for Field<E>

where E: Environment,

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

Formats the value using the given formatter.

impl<E> Distribution<Field<E>> for Standard

where E: Environment,

fn sample<R>(&self, rng: &mut R) -> Field<E>

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<E> Div<&Field<E>> for Field<E>

where E: Environment,

fn div(self, other: &Field<E>) -> <Field<E> as Div<&Field<E>>>::Output

Returns the quotient of self and other.

type Output = Field<E>

The resulting type after applying the / operator.

impl<E> Div for Field<E>

where E: Environment,

fn div(self, other: Field<E>) -> <Field<E> as Div>::Output

Returns the quotient of self and other.

type Output = Field<E>

The resulting type after applying the / operator.

impl<E> DivAssign<&Field<E>> for Field<E>

where E: Environment,

fn div_assign(&mut self, other: &Field<E>)

Divides self by other.

impl<E> DivAssign for Field<E>

where E: Environment,

fn div_assign(&mut self, other: Field<E>)

Divides self by other.

impl<E> Double for Field<E>

where E: Environment,

fn double(&self) -> <Field<E> as Double>::Output

Returns the double of self.

type Output = Field<E>

impl<E> Equal for Field<E>

where E: Environment,

fn is_equal(&self, other: &Field<E>) -> <Field<E> as Equal>::Output

Returns true if self and other are equal.

fn is_not_equal(&self, other: &Field<E>) -> <Field<E> as Equal>::Output

Returns true if self and other are not equal.

type Output = Boolean<E>

impl<E> FromBits for Field<E>

where E: Environment,

fn from_bits_le(bits_le: &[bool]) -> Result<Field<E>, Error>

Initializes a new field from a list of little-endian bits.

• If bits_le is longer than E::Field::size_in_bits(), the excess bits are enforced to be 0s.
• If bits_le is shorter than E::Field::size_in_bits(), it is padded with 0s up to field size.

fn from_bits_be(bits_be: &[bool]) -> Result<Field<E>, Error>

Initializes a new field from a list of big-endian bits without leading zeros.

impl<E> FromBytes for Field<E>

where E: Environment,

fn read_le<R>(reader: R) -> Result<Field<E>, Error>

where R: Read,

Reads the field from a buffer.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

Returns Self from a byte array in little-endian order.

impl<E> FromStr for Field<E>

where E: Environment,

fn from_str(string: &str) -> Result<Field<E>, Error>

Parses a string into a field.

type Err = Error

The associated error which can be returned from parsing.

impl<E> Hash for Field<E>

where E: Hash + Environment, <E as Environment>::Field: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<E> Inverse for Field<E>

where E: Environment,

fn inverse(&self) -> Result<<Field<E> as Inverse>::Output, Error>

Returns the inverse of self.

type Output = Field<E>

impl<E> Mul<&Field<E>> for Field<E>

where E: Environment,

fn mul(self, other: &Field<E>) -> <Field<E> as Mul<&Field<E>>>::Output

Returns the product of self and other.

type Output = Field<E>

The resulting type after applying the * operator.

impl<E> Mul for Field<E>

where E: Environment,

fn mul(self, other: Field<E>) -> <Field<E> as Mul>::Output

Returns the product of self and other.

type Output = Field<E>

The resulting type after applying the * operator.

impl<E> MulAssign<&Field<E>> for Field<E>

where E: Environment,

fn mul_assign(&mut self, other: &Field<E>)

Multiplies self by other.

impl<E> MulAssign for Field<E>

where E: Environment,

fn mul_assign(&mut self, other: Field<E>)

Multiplies self by other.

impl<E> Neg for Field<E>

where E: Environment,

fn neg(self) -> <Field<E> as Neg>::Output

Returns the negation of self.

type Output = Field<E>

The resulting type after applying the - operator.

impl<E> One for Field<E>

where E: Environment,

fn one() -> Field<E>

Returns the 1 element of the field.

fn is_one(&self) -> bool

Returns true if the element is one.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<E> Ord for Field<E>

where E: Environment,

fn cmp(&self, other: &Field<E>) -> Ordering

Returns the lexicographic ordering of self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<E> Parser for Field<E>

where E: Environment,

fn parse(string: &str) -> Result<(&str, Field<E>), Err<VerboseError<&str>>>

Parses a string into a field circuit.

impl<E> PartialEq for Field<E>

where E: PartialEq + Environment, <E as Environment>::Field: PartialEq,

fn eq(&self, other: &Field<E>) -> 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> PartialOrd for Field<E>

where E: Environment,

fn partial_cmp(&self, other: &Field<E>) -> Option<Ordering>

Returns the lexicographic ordering of self and other.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E> Pow<&Field<E>> for Field<E>

where E: Environment,

fn pow(self, other: &Field<E>) -> <Field<E> as Pow<&Field<E>>>::Output

Returns the power of self to the power of other.

type Output = Field<E>

The result after applying the operator.

impl<E> Pow<Field<E>> for Field<E>

where E: Environment,

fn pow(self, other: Field<E>) -> <Field<E> as Pow<Field<E>>>::Output

Returns the power of self to the power of other.

type Output = Field<E>

The result after applying the operator.

impl<'a, E> Product<&'a Field<E>> for Field<E>

where E: Environment,

fn product<I>(iter: I) -> Field<E>

where I: Iterator<Item = &'a Field<E>>,

Returns the product of self and other.

impl<E> Product for Field<E>

where E: Environment,

fn product<I>(iter: I) -> Field<E>

where I: Iterator<Item = Field<E>>,

Returns the product of self and other.

impl<E> Serialize for Field<E>

where E: Environment,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serializes the field into a string or as bytes.

impl<E> SizeInBits for Field<E>

where E: Environment,

fn size_in_bits() -> usize

Returns the field size in bits.

impl<E> SizeInBytes for Field<E>

where E: Environment,

fn size_in_bytes() -> usize

Returns the field size in bytes.

impl<E> SizeInDataBits for Field<E>

where E: Environment,

fn size_in_data_bits() -> usize

Returns the field capacity for data bits.

impl<E> Square for Field<E>

where E: Environment,

fn square(&self) -> <Field<E> as Square>::Output

Returns the square of self.

type Output = Field<E>

impl<E> SquareRoot for Field<E>

where E: Environment,

fn square_root(&self) -> Result<<Field<E> as SquareRoot>::Output, Error>

Returns the square_root of self. If there are two square roots, the bitwise lesser one is returned.

type Output = Field<E>

impl<E> Sub<&Field<E>> for Field<E>

where E: Environment,

fn sub(self, other: &Field<E>) -> <Field<E> as Sub<&Field<E>>>::Output

Returns the difference of self and other.

type Output = Field<E>

The resulting type after applying the - operator.

impl<E> Sub for Field<E>

where E: Environment,

fn sub(self, other: Field<E>) -> <Field<E> as Sub>::Output

Returns the difference of self and other.

type Output = Field<E>

The resulting type after applying the - operator.

impl<E> SubAssign<&Field<E>> for Field<E>

where E: Environment,

fn sub_assign(&mut self, other: &Field<E>)

Subtracts other from self.

impl<E> SubAssign for Field<E>

where E: Environment,

fn sub_assign(&mut self, other: Field<E>)

Subtracts other from self.

impl<'a, E> Sum<&'a Field<E>> for Field<E>

where E: Environment,

fn sum<I>(iter: I) -> Field<E>

where I: Iterator<Item = &'a Field<E>>,

Returns the sum of self and other.

impl<E> Sum for Field<E>

where E: Environment,

fn sum<I>(iter: I) -> Field<E>

where I: Iterator<Item = Field<E>>,

Returns the sum of self and other.

impl<E> Ternary for Field<E>

where E: Environment,

fn ternary( condition: &<Field<E> as Ternary>::Boolean, first: &Field<E>, second: &Field<E>, ) -> <Field<E> as Ternary>::Output

Returns first if condition is true, otherwise returns second.

type Boolean = Boolean<E>

type Output = Field<E>

impl<E> ToBits for Field<E>

where E: Environment,

fn write_bits_le(&self, vec: &mut Vec<bool>)

Outputs the little-endian bit representation of self without trailing zeros.

fn write_bits_be(&self, vec: &mut Vec<bool>)

Outputs the big-endian bit representation of self without leading zeros.

fn to_bits_le(&self) -> Vec<bool>

Returns self as a boolean array in little-endian order.

fn to_bits_be(&self) -> Vec<bool>

Returns self as a boolean array in big-endian order.

fn num_bits() -> Option<usize>

An optional indication of how many bits an object can be represented with.

impl<E> ToBytes for Field<E>

where E: Environment,

fn write_le<W>(&self, writer: W) -> Result<(), Error>

where W: Write,

Writes the field to a buffer.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>

where Self: Sized,

Returns self as a byte array in little-endian order.

impl<E> TypeName for Field<E>

where E: Environment,

fn type_name() -> &'static str

Returns the type name as a string.

impl<E> Zero for Field<E>

where E: Environment,

fn zero() -> Field<E>

Returns the 0 element of the field.

fn is_zero(&self) -> bool

Returns true if the element is zero.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<E> Zeroize for Field<E>

where E: Environment,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<E> Copy for Field<E>

where E: Copy + Environment, <E as Environment>::Field: Copy,

impl<E> Eq for Field<E>

where E: Eq + Environment, <E as Environment>::Field: Eq,

impl<E> FieldTrait for Field<E>

where E: Environment,

impl<E> StructuralPartialEq for Field<E>

where E: Environment,