Struct Eq

pub struct Eq { /* private fields */ }

Represents a point in the projective coordinate space.

Implementations

impl Eq

pub const ISOGENY_CONSTANTS: [Fq; 13] = _

Constants used for computing the isogeny from IsoEq to Eq.

pub const Z: Fq = _

Z = -13

pub const THETA: Fq = _

(F::ROOT_OF_UNITY.invert().unwrap() * z).sqrt().unwrap()

Trait Implementations

impl<'a, 'b> Add<&'a Eq> for &'b Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: &'a Eq) -> Eq

Performs the + operation.

impl<'a, 'b> Add<&'a Eq> for &'b EqAffine

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: &'a Eq) -> Eq

Performs the + operation.

impl<'b> Add<&'b Eq> for Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: &'b Eq) -> Eq

Performs the + operation.

impl<'b> Add<&'b Eq> for EqAffine

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: &'b Eq) -> Eq

Performs the + operation.

impl<'a, 'b> Add<&'a EqAffine> for &'b Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: &'a EqAffine) -> Eq

Performs the + operation.

impl<'b> Add<&'b EqAffine> for Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: &'b EqAffine) -> Eq

Performs the + operation.

impl<'a> Add<Eq> for &'a Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: Eq) -> Eq

Performs the + operation.

impl<'a> Add<Eq> for &'a EqAffine

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: Eq) -> Eq

Performs the + operation.

impl Add<Eq> for EqAffine

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: Eq) -> Eq

Performs the + operation.

impl<'a> Add<EqAffine> for &'a Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: EqAffine) -> Eq

Performs the + operation.

impl Add<EqAffine> for Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: EqAffine) -> Eq

Performs the + operation.

impl Add for Eq

type Output = Eq

The resulting type after applying the + operator.

fn add(self, rhs: Eq) -> Eq

Performs the + operation.

impl<'b> AddAssign<&'b Eq> for Eq

fn add_assign(&mut self, rhs: &'b Eq)

Performs the += operation.

impl<'b> AddAssign<&'b EqAffine> for Eq

fn add_assign(&mut self, rhs: &'b EqAffine)

Performs the += operation.

impl AddAssign<EqAffine> for Eq

fn add_assign(&mut self, rhs: EqAffine)

Performs the += operation.

impl AddAssign for Eq

fn add_assign(&mut self, rhs: Eq)

Performs the += operation.

impl Clone for Eq

fn clone(&self) -> Eq

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CofactorCurve for Eq

type Affine = EqAffine

impl CofactorGroup for Eq

type Subgroup = Eq

The large prime-order subgroup in which cryptographic operations are performed. If Self implements PrimeGroup, then Self::Subgroup may be Self.

fn clear_cofactor(&self) -> Eq

Maps self to the prime-order subgroup by multiplying this element by some k-multiple of the cofactor.

fn into_subgroup(self) -> CtOption<<Eq as CofactorGroup>::Subgroup>

Returns self if it is contained in the prime-order subgroup.

fn is_torsion_free(&self) -> Choice

Determines if this element is “torsion free”, i.e., is contained in the prime-order subgroup.

fn is_small_order(&self) -> Choice

Determines if this element is of small order.

impl ConditionallySelectable for Eq

fn conditional_select(a: &Eq, b: &Eq, choice: Choice) -> Eq

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl ConstantTimeEq for Eq

fn ct_eq(&self, other: &Eq) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl Curve for Eq

type AffineRepr = EqAffine

The affine representation for this elliptic curve.

fn batch_normalize(p: &[Eq], q: &mut [<Eq as Curve>::AffineRepr])

Converts a batch of projective elements into affine elements. This function will panic if p.len() != q.len().

fn to_affine(&self) -> <Eq as Curve>::AffineRepr

Converts this element into its affine representation.

impl CurveExt for Eq

fn endo(&self) -> Eq

Apply the curve endomorphism by multiplying the x-coordinate by an element of multiplicative order 3.

const CURVE_ID: &'static str = "vesta"

CURVE_ID used for hash-to-curve.

type ScalarExt = Fp

The scalar field of this elliptic curve.

type Base = Fq

The base field over which this elliptic curve is constructed.

type AffineExt = EqAffine

The affine version of the curve

fn hash_to_curve<'a>(domain_prefix: &'a str) -> Box<dyn Fn(&[u8]) -> Eq + 'a>

Requests a hasher that accepts messages and returns near-uniformly distributed elements in the group, given domain prefix domain_prefix.

fn a() -> <Eq as CurveExt>::Base

Returns the curve constant a.

fn b() -> <Eq as CurveExt>::Base

Returns the curve constant b.

fn new_jacobian( x: <Eq as CurveExt>::Base, y: <Eq as CurveExt>::Base, z: <Eq as CurveExt>::Base, ) -> CtOption<Eq>

Obtains a point given Jacobian coordinates $X : Y : Z$, failing if the coordinates are not on the curve.

fn jacobian_coordinates(&self) -> (Fq, Fq, Fq)

Return the Jacobian coordinates of this point.

fn is_on_curve(&self) -> Choice

Returns whether or not this element is on the curve; should always be true unless an “unchecked” API was used.

impl Debug for Eq

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

Formats the value using the given formatter.

impl Default for Eq

fn default() -> Eq

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Eq

fn deserialize<D>(d: D) -> Result<Eq, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a Eq> for EqAffine

fn from(p: &'a Eq) -> EqAffine

Converts to this type from the input type.

impl<'a> From<&'a EqAffine> for Eq

fn from(p: &'a EqAffine) -> Eq

Converts to this type from the input type.

impl From<Eq> for EqAffine

fn from(p: Eq) -> EqAffine

Converts to this type from the input type.

impl From<EqAffine> for Eq

fn from(p: EqAffine) -> Eq

Converts to this type from the input type.

impl Group for Eq

type Scalar = Fp

Scalars modulo the order of this group’s scalar field.

fn random(rng: impl RngCore) -> Eq

Returns an element chosen uniformly at random from the non-identity elements of this group.

fn generator() -> Eq

Returns a fixed generator of the prime-order subgroup.

fn double(&self) -> Eq

Doubles this element.

fn identity() -> Eq

Returns the additive identity, also known as the “neutral element”.

fn is_identity(&self) -> Choice

Determines if this point is the identity.

impl GroupEncoding for Eq

type Repr = [u8; 32]

The encoding of group elements.

fn from_bytes(bytes: &<Eq as GroupEncoding>::Repr) -> CtOption<Eq>

Attempts to deserialize a group element from its encoding.

fn from_bytes_unchecked(bytes: &<Eq as GroupEncoding>::Repr) -> CtOption<Eq>

Attempts to deserialize a group element, not checking if the element is valid.

fn to_bytes(&self) -> <Eq as GroupEncoding>::Repr

Converts this element into its byte encoding. This may or may not support encoding the identity.

impl<'a, 'b> Mul<&'b Fp> for &'a Eq

type Output = Eq

The resulting type after applying the * operator.

fn mul(self, other: &'b Fp) -> <&'a Eq as Mul<&'b Fp>>::Output

Performs the * operation.

impl<'b> Mul<&'b Fp> for Eq

type Output = Eq

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Fp) -> Eq

Performs the * operation.

impl<'a> Mul<Fp> for &'a Eq

type Output = Eq

The resulting type after applying the * operator.

fn mul(self, rhs: Fp) -> Eq

Performs the * operation.

impl Mul<Fp> for Eq

type Output = Eq

The resulting type after applying the * operator.

fn mul(self, rhs: Fp) -> Eq

Performs the * operation.

impl<'b> MulAssign<&'b Fp> for Eq

fn mul_assign(&mut self, rhs: &'b Fp)

Performs the *= operation.

impl MulAssign<Fp> for Eq

fn mul_assign(&mut self, rhs: Fp)

Performs the *= operation.

impl<'a> Neg for &'a Eq

type Output = Eq

The resulting type after applying the - operator.

fn neg(self) -> Eq

Performs the unary - operation.

impl Neg for Eq

type Output = Eq

The resulting type after applying the - operator.

fn neg(self) -> Eq

Performs the unary - operation.

impl PartialEq for Eq

fn eq(&self, other: &Eq) -> 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 PrimeCurve for Eq

type Affine = EqAffine

impl Serialize for Eq

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, 'b> Sub<&'a Eq> for &'b Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, other: &'a Eq) -> Eq

Performs the - operation.

impl<'a, 'b> Sub<&'a Eq> for &'b EqAffine

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, other: &'a Eq) -> Eq

Performs the - operation.

impl<'b> Sub<&'b Eq> for Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Eq) -> Eq

Performs the - operation.

impl<'b> Sub<&'b Eq> for EqAffine

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Eq) -> Eq

Performs the - operation.

impl<'a, 'b> Sub<&'a EqAffine> for &'b Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, other: &'a EqAffine) -> Eq

Performs the - operation.

impl<'b> Sub<&'b EqAffine> for Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: &'b EqAffine) -> Eq

Performs the - operation.

impl<'a> Sub<Eq> for &'a Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: Eq) -> Eq

Performs the - operation.

impl<'a> Sub<Eq> for &'a EqAffine

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: Eq) -> Eq

Performs the - operation.

impl Sub<Eq> for EqAffine

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: Eq) -> Eq

Performs the - operation.

impl<'a> Sub<EqAffine> for &'a Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: EqAffine) -> Eq

Performs the - operation.

impl Sub<EqAffine> for Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: EqAffine) -> Eq

Performs the - operation.

impl Sub for Eq

type Output = Eq

The resulting type after applying the - operator.

fn sub(self, rhs: Eq) -> Eq

Performs the - operation.

impl<'b> SubAssign<&'b Eq> for Eq

fn sub_assign(&mut self, rhs: &'b Eq)

Performs the -= operation.

impl<'b> SubAssign<&'b EqAffine> for Eq

fn sub_assign(&mut self, rhs: &'b EqAffine)

Performs the -= operation.

impl SubAssign<EqAffine> for Eq

fn sub_assign(&mut self, rhs: EqAffine)

Performs the -= operation.

impl SubAssign for Eq

fn sub_assign(&mut self, rhs: Eq)

Performs the -= operation.

impl<T> Sum<T> for Eq

where T: Borrow<Eq>,

fn sum<I>(iter: I) -> Eq

where I: Iterator<Item = T>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl WnafGroup for Eq

fn recommended_wnaf_for_num_scalars(num_scalars: usize) -> usize

Recommends a wNAF window size given the number of scalars you intend to multiply a base by. Always returns a number between 2 and 22, inclusive.

impl Copy for Eq

impl Eq for Eq

impl PrimeGroup for Eq