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) -> Field<E>

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 fn square_roots_flagged_nondeterministic( &self, ) -> (Field<E>, Field<E>, Boolean<E>)

Returns both square roots of self and a Boolean flag, which is set iff self is not a square.

If self is a non-zero square,

• the first field result is the positive root (i.e. closer to 0)
• the second field result is the negative root (i.e. closer to the prime)
• the flag is 0

If self is 0,

• both field results are 0
• the flag is 0

If self is not a square,

• both field results are 0
• the flag is 1

Note that the constraints do not impose an ordering on the two roots returned by this function; this is what the nondeterministic part of this function name refers to.

Trait Implementations

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E> Add for Field<E>

where E: Environment,

type Output = Field<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where E: Environment,

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

Performs the += operation.

impl<E> AddAssign for Field<E>

where E: Environment,

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

Performs the += operation.

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

where E: Environment,

fn cast(&self) -> 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> Cast<Boolean<E>> for Field<E>

where E: Environment,

fn cast(&self) -> 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> Cast<Field<E>> for Boolean<E>

where E: Environment,

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

Casts a Boolean to a Field.

impl<E, I> Cast<Field<E>> for Integer<E, I>

where E: Environment, I: IntegerType,

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

Casts an Integer to a Field.

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

where E: Environment,

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

Casts a Scalar to a Field.

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

where E: Environment,

fn cast(&self) -> 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, I> Cast<Integer<E, I>> for Field<E>

where E: Environment, I: IntegerType,

fn cast(&self) -> 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> Cast<Scalar<E>> for Field<E>

where E: Environment,

fn cast(&self) -> 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> Cast for Field<E>

where E: Environment,

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

Casts a Field to a Field.

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

where E: Environment,

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> CastLossy<Boolean<E>> for Field<E>

where E: Environment,

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> CastLossy<Field<E>> for Boolean<E>

where E: Environment,

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, I> CastLossy<Field<E>> for Integer<E, I>

where E: Environment, I: IntegerType,

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> CastLossy<Field<E>> for Scalar<E>

where E: Environment,

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

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

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

where E: Environment,

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, I> CastLossy<Integer<E, I>> for Field<E>

where E: Environment, I: IntegerType,

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> CastLossy<Scalar<E>> for Field<E>

where E: Environment,

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> CastLossy for Field<E>

where E: Environment,

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>::BaseField: 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> Display for Field<E>

where E: Environment,

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

Formats the value using the given formatter.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E> Div for Field<E>

where E: Environment,

type Output = Field<E>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where E: Environment,

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

Performs the /= operation.

impl<E> DivAssign for Field<E>

where E: Environment,

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

Performs the /= operation.

impl<E> DivUnchecked for Field<E>

where E: Environment,

type Output = Field<E>

fn div_unchecked(&self, rhs: &Rhs) -> Self::Output

impl<E> Double for Field<E>

where E: Environment,

type Output = Field<E>

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

impl<E> Eject for Field<E>

where E: Environment,

fn eject_mode(&self) -> Mode

Ejects the mode of the field circuit.

fn eject_value(&self) -> <Field<E> as Eject>::Primitive

Ejects the field circuit as a console field.

type Primitive = Field<<E as Environment>::Network>

fn eject(&self) -> (Mode, Self::Primitive)

Ejects the mode and primitive value of the circuit type.

fn is_constant(&self) -> bool

Returns true if the circuit is a constant.

fn is_public(&self) -> bool

Returns true if the circuit is a public.

fn is_private(&self) -> bool

Returns true if the circuit is a private.

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.

This method costs 2 constraints.

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

Returns true if self and other are not equal.

This method constructs a boolean that indicates if self and other are not equal to each other.

This method costs 2 constraints.

type Output = Boolean<E>

impl<E> From<&Address<E>> for Field<E>

where E: Environment,

fn from(value: &Address<E>) -> Field<E>

Returns the x-coordinate of the affine group element in the address.

impl<E> From<&Field<E>> for Address<E>

where E: Environment,

fn from(value: &Field<E>) -> Address<E>

Initializes an address from the x-coordinate of an affine group element.

impl<E> From<&Field<E>> for LinearCombination<<E as Environment>::BaseField>

where E: Environment,

fn from(field: &Field<E>) -> LinearCombination<<E as Environment>::BaseField>

Converts to this type from the input type.

impl<E> From<&LinearCombination<<E as Environment>::BaseField>> for Field<E>

where E: Environment,

fn from( linear_combination: &LinearCombination<<E as Environment>::BaseField>, ) -> Field<E>

Converts to this type from the input type.

impl<E> From<Address<E>> for Field<E>

where E: Environment,

fn from(value: Address<E>) -> Field<E>

Returns the x-coordinate of the affine group element in the address.

impl<E> From<Field<E>> for Address<E>

where E: Environment,

fn from(value: Field<E>) -> Address<E>

Initializes an address from the x-coordinate of an affine group element.

impl<E> From<Field<E>> for LinearCombination<<E as Environment>::BaseField>

where E: Environment,

fn from(field: Field<E>) -> LinearCombination<<E as Environment>::BaseField>

Converts to this type from the input type.

impl<E> From<LinearCombination<<E as Environment>::BaseField>> for Field<E>

where E: Environment,

fn from( linear_combination: LinearCombination<<E as Environment>::BaseField>, ) -> Field<E>

Converts to this type from the input type.

impl<E> FromBits for Field<E>

where E: Environment,

fn from_bits_le(bits_le: &[<Field<E> as FromBits>::Boolean]) -> Field<E>

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

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

fn from_bits_be(bits_be: &[<Field<E> as FromBits>::Boolean]) -> Field<E>

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

type Boolean = Boolean<E>

impl<E> FromBoolean for Field<E>

where E: Environment,

fn from_boolean(boolean: &<Field<E> as FromBoolean>::Boolean) -> Field<E>

Initializes a base field from a boolean.

type Boolean = Boolean<E>

impl<E> FromStr for Field<E>

where E: Environment,

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

Parses a string into a field circuit.

type Err = Error

The associated error which can be returned from parsing.

impl<E> Inject for Field<E>

where E: Environment,

fn new(mode: Mode, field: <Field<E> as Inject>::Primitive) -> Field<E>

Initializes a field circuit from a console field.

type Primitive = Field<<E as Environment>::Network>

fn constant(value: Self::Primitive) -> Self

where Self: Sized,

Initializes a constant of the given primitive value.

impl<E> Inv for &Field<E>

where E: Environment,

type Output = Field<E>

The result after applying the operator.

fn inv(self) -> <&Field<E> as Inv>::Output

Returns the multiplicative inverse of self.

impl<E> Inv for Field<E>

where E: Environment,

type Output = Field<E>

The result after applying the operator.

fn inv(self) -> <Field<E> as Inv>::Output

Returns the multiplicative inverse of self.

impl<E> Inverse for Field<E>

where E: Environment,

type Output = Field<E>

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

impl<E> Metrics<dyn Add<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn count( _case: &<Field<E> as Metrics<dyn Add<Field<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Div<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn count( case: &<Field<E> as Metrics<dyn Div<Field<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn DivUnchecked<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn count( case: &<Field<E> as Metrics<dyn DivUnchecked<Field<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Double<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn count( _parameter: &<Field<E> as Metrics<dyn Double<Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Equal<Field<E>, Output = Boolean<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn count( case: &<Field<E> as Metrics<dyn Equal<Field<E>, Output = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn FromBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Vec<Mode>

fn count( _modes: &<Field<E> as Metrics<dyn FromBits<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn FromBoolean<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = ()

fn count( _case: &<Field<E> as Metrics<dyn FromBoolean<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Inverse<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn count( case: &<Field<E> as Metrics<dyn Inverse<Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Mul<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn count( case: &<Field<E> as Metrics<dyn Mul<Field<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Neg<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn count( _case: &<Field<E> as Metrics<dyn Neg<Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn One<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = ()

fn count( _parameter: &<Field<E> as Metrics<dyn One<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Pow<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn count( case: &<Field<E> as Metrics<dyn Pow<Field<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Square<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn count( case: &<Field<E> as Metrics<dyn Square<Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn SquareRoot<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn count( case: &<Field<E> as Metrics<dyn SquareRoot<Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Sub<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn count( _case: &<Field<E> as Metrics<dyn Sub<Field<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Ternary<Boolean = Boolean<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode, Mode)

fn count( case: &<Field<E> as Metrics<dyn Ternary<Boolean = Boolean<E>, Output = Field<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn ToBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn count( case: &<Field<E> as Metrics<dyn ToBits<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn ToLowerBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = (Mode, u64)

fn count( case: &<Field<E> as Metrics<dyn ToLowerBits<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn ToUpperBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = (Mode, u64)

fn count( case: &<Field<E> as Metrics<dyn ToUpperBits<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

impl<E> Metrics<dyn Zero<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = ()

fn count( _parameter: &<Field<E> as Metrics<dyn Zero<Boolean = Boolean<E>>>>::Case, ) -> Count

Returns the number of constants, public inputs, private inputs, and constraints.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E> Mul for Field<E>

where E: Environment,

type Output = Field<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E: Environment,

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

Performs the *= operation.

impl<E> MulAssign for Field<E>

where E: Environment,

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

Performs the *= operation.

impl<E> Neg for &Field<E>

where E: Environment,

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

Performs the unary - operation.

type Output = Field<E>

The resulting type after applying the - operator.

impl<E> Neg for Field<E>

where E: Environment,

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

Performs the unary - operation.

type Output = Field<E>

The resulting type after applying the - operator.

impl<E> One for Field<E>

where E: Environment,

type Boolean = Boolean<E>

fn one() -> Field<E>

Returns a new one constant.

fn is_one(&self) -> <Field<E> as One>::Boolean

Returns true if self is one.

impl<E> OutputMode<dyn Add<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn output_mode( case: &<Field<E> as OutputMode<dyn Add<Field<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Div<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn output_mode( case: &<Field<E> as OutputMode<dyn Div<Field<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn DivUnchecked<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn output_mode( case: &<Field<E> as OutputMode<dyn DivUnchecked<Field<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Double<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( input: &<Field<E> as OutputMode<dyn Double<Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Equal<Field<E>, Output = Boolean<E>>> for Field<E>

where E: Environment,

type Case = (Mode, Mode)

fn output_mode( case: &<Field<E> as OutputMode<dyn Equal<Field<E>, Output = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn FromBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Vec<Mode>

fn output_mode( case: &<Field<E> as OutputMode<dyn FromBits<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn FromBoolean<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn FromBoolean<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Inverse<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn Inverse<Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Mul<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn output_mode( case: &<Field<E> as OutputMode<dyn Mul<Field<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Neg<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn Neg<Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn One<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = ()

fn output_mode( _input: &<Field<E> as OutputMode<dyn One<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Pow<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn output_mode( case: &<Field<E> as OutputMode<dyn Pow<Field<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Square<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( input: &<Field<E> as OutputMode<dyn Square<Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn SquareRoot<Output = Field<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn SquareRoot<Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Sub<Field<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Field<E>>, CircuitType<Field<E>>)

fn output_mode( case: &<Field<E> as OutputMode<dyn Sub<Field<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Ternary<Boolean = Boolean<E>, Output = Field<E>>> for Field<E>

where E: Environment,

type Case = (CircuitType<Boolean<E>>, Mode, Mode)

fn output_mode( parameter: &<Field<E> as OutputMode<dyn Ternary<Boolean = Boolean<E>, Output = Field<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn ToBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn ToBits<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn ToLowerBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn ToLowerBits<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn ToUpperBits<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = Mode

fn output_mode( case: &<Field<E> as OutputMode<dyn ToUpperBits<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

impl<E> OutputMode<dyn Zero<Boolean = Boolean<E>>> for Field<E>

where E: Environment,

type Case = ()

fn output_mode( _input: &<Field<E> as OutputMode<dyn Zero<Boolean = Boolean<E>>>>::Case, ) -> Mode

Returns the mode of the output.

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> Pow<&Field<E>> for &Field<E>

where E: Environment,

type Output = Field<E>

The result after applying the operator.

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

Returns self to the power rhs.

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

where E: Environment,

type Output = Field<E>

The result after applying the operator.

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

Returns self to the power rhs.

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

where E: Environment,

type Output = Field<E>

The result after applying the operator.

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

Returns self to the power rhs.

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

where E: Environment,

type Output = Field<E>

The result after applying the operator.

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

Returns self to the power rhs.

impl<E> Square for Field<E>

where E: Environment,

type Output = Field<E>

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

impl<E> SquareRoot for Field<E>

where E: Environment,

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

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

type Output = Field<E>

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where E: Environment,

type Output = Field<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E> Sub for Field<E>

where E: Environment,

type Output = Field<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where E: Environment,

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

Performs the -= operation.

impl<E> SubAssign for Field<E>

where E: Environment,

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

Performs the -= operation.

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<<&Field<E> as ToBits>::Boolean>)

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

fn write_bits_be(&self, vec: &mut Vec<<&Field<E> as ToBits>::Boolean>)

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

type Boolean = Boolean<E>

fn to_bits_le(&self) -> Vec<Self::Boolean>

Returns the little-endian bits of the circuit.

fn to_bits_be(&self) -> Vec<Self::Boolean>

Returns the big-endian bits of the circuit.

impl<E> ToBits for Field<E>

where E: Environment,

fn write_bits_le(&self, vec: &mut Vec<<Field<E> as ToBits>::Boolean>)

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

fn write_bits_be(&self, vec: &mut Vec<<Field<E> as ToBits>::Boolean>)

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

type Boolean = Boolean<E>

fn to_bits_le(&self) -> Vec<Self::Boolean>

Returns the little-endian bits of the circuit.

fn to_bits_be(&self) -> Vec<Self::Boolean>

Returns the big-endian bits of the circuit.

impl<E> ToLowerBits for Field<E>

where E: Environment,

fn to_lower_bits_le(&self, k: usize) -> Vec<<Field<E> as ToLowerBits>::Boolean>

Outputs the lower k bits of an n-bit field element in little-endian representation. Enforces that the upper n - k bits are zero.

fn to_lower_bits_be(&self, k: usize) -> Vec<<Field<E> as ToLowerBits>::Boolean>

Outputs the lower k bits of an n-bit field element in big-endian representation. Enforces that the upper n - k bits are zero.

type Boolean = Boolean<E>

impl<E> ToUpperBits for Field<E>

where E: Environment,

fn to_upper_bits_le(&self, k: usize) -> Vec<<Field<E> as ToUpperBits>::Boolean>

Outputs the upper k bits of an n-bit field element in little-endian representation. Enforces that the lower n - k bits are zero.

fn to_upper_bits_be(&self, k: usize) -> Vec<<Field<E> as ToUpperBits>::Boolean>

Outputs the upper k bits of an n-bit field element in big-endian representation. Enforces that the lower n - k bits are zero.

type Boolean = Boolean<E>

impl<E> TypeName for Field<E>

where E: Environment,

fn type_name() -> &'static str

Returns the type name of the circuit as a string.

impl<E> Zero for Field<E>

where E: Environment,

type Boolean = Boolean<E>

fn zero() -> Field<E>

Returns a new zero constant.

fn is_zero(&self) -> <Field<E> as Zero>::Boolean

Returns true if self is zero.

impl<E> FieldTrait for Field<E>

where E: Environment,