Struct zerocaf::edwards::AffinePoint

pub struct AffinePoint {
    pub X: FieldElement,
    pub Y: FieldElement,
}

An AffinePoint represents a point on the Sonny Curve expressed over the Twisted Edwards Affine Coordinates also known as cartesian coordinates: (X, Y).

This Twisted Edwards coordinates are ONLY implemented for equalty testing, since all of the Point operations defined over them are much slower than the same ones defined over Extended or Projective coordinates.

Fields

X: FieldElement

Y: FieldElement

Trait Implementations

impl ConstantTimeEq for AffinePoint

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

Determine if two items are equal.

impl Debug for AffinePoint

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

Formats the value using the given formatter.

impl Default for AffinePoint

fn default() -> AffinePoint

Returns the default Twisted Edwards AffinePoint Coordinates: (0, 1).

impl Eq for AffinePoint

impl From<AffinePoint> for EdwardsPoint

fn from(point: AffinePoint) -> EdwardsPoint

In affine form, each elliptic curve point has 2 coordinates, like (x,y). In the new projective form, each point will have 3 coordinates, like (X,Y,Z), with the restriction that Z is never zero.

The forward mapping is given by (X,Y)→(XZ,YZ,Z), for any non-zero z (usually chosen to be 1 for convenience).

After this is done, we move from Projective to Extended by setting the new coordinate T = X * Y.

impl From<AffinePoint> for ProjectivePoint

fn from(point: AffinePoint) -> ProjectivePoint

The key idea of projective coordinates is that instead of performing every division immediately, we defer the divisions by multiplying them into a denominator.

In affine form, each elliptic curve point has 2 coordinates, like (x,y). In the new projective form, each point will have 3 coordinates, like (X,Y,Z), with the restriction that Z is never zero.

The forward mapping is given by (x,y)→(xz,yz,z), for any non-zero z (usually chosen to be 1 for convenience).

impl From<EdwardsPoint> for AffinePoint

fn from(point: EdwardsPoint) -> AffinePoint

Given (X:Y:Z:T) in εε, passing to affine can be performed in 3M+ 1I by computing:

First, move to Projective Coordinates by removing T.

Then, reduce the point from Projective to Affine coordinates computing: (XZinv, YZinv, Z*Zinv).

And once Z coord = 1 we can simply remove it.

Twisted Edwards Curves Revisited - Huseyin Hisil, Kenneth Koon-Ho Wong, Gary Carter, and Ed Dawson.

impl From<ProjectivePoint> for AffinePoint

fn from(point: ProjectivePoint) -> AffinePoint

Reduce the point from Projective to Affine coordinates computing: (XZinv, YZinv, Z*Zinv).

And once the Z coord = 1 we can simply remove it.

Twisted Edwards Curves Revisited - Huseyin Hisil, Kenneth Koon-Ho Wong, Gary Carter, and Ed Dawson.

impl Identity for AffinePoint

fn identity() -> AffinePoint

Returns the Edwards Point identity value = (0, 1).

impl<'a> Neg for &'a AffinePoint

type Output = AffinePoint

The resulting type after applying the - operator.

fn neg(self) -> AffinePoint

Negates an AffinePoint giving it as a result. Since the negative of a point is (-X:Y), it gives as a result: (-X, Y).

impl Neg for AffinePoint

type Output = AffinePoint

The resulting type after applying the - operator.

fn neg(self) -> AffinePoint

Negates an AffinePoint giving it as a result. Since the negative of a point is (-X:Y), it gives as a result: (-X, Y).

impl PartialEq<AffinePoint> for AffinePoint

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl ValidityCheck for AffinePoint

fn is_valid(&self) -> Choice

Verifies if the curve equation holds given the (X, Y) coordinates of a point in Affine Coordinates.