Rename MontgomeryPoint to AffineMontgomeryPoint

Author: daxpedda

ed448-goldilocks/src/edwards/extended.rs

@@ -541,9 +541,9 @@ impl EdwardsPoint {
         MontgomeryXpoint(u.to_bytes())
     }
 
-    /// Convert this point to [`MontgomeryPoint`]
+    /// Convert this point to [`AffineMontgomeryPoint`]
     // See https://www.rfc-editor.org/rfc/rfc7748#section-4.2 4-isogeny maps
-    pub fn to_montgomery(&self) -> MontgomeryPoint {
+    pub fn to_montgomery(&self) -> AffineMontgomeryPoint {
         // u = y^2/x^2
         // v = (2 - x^2 - y^2)*y/x^3
 
@@ -556,9 +556,9 @@ impl EdwardsPoint {
         let u = yy * xx.invert();
         let v = (FieldElement::TWO - xx - yy) * affine.y * (xx * affine.x).invert();
 
-        MontgomeryPoint::conditional_select(
-            &MontgomeryPoint::new(u, v),
-            &MontgomeryPoint::IDENTITY,
+        AffineMontgomeryPoint::conditional_select(
+            &AffineMontgomeryPoint::new(u, v),
+            &AffineMontgomeryPoint::IDENTITY,
             self.ct_eq(&Self::IDENTITY),
         )
     }

ed448-goldilocks/src/field/element.rs

@@ -3,7 +3,7 @@ use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 use super::{ConstMontyType, MODULUS};
 use crate::{
-    AffinePoint, Curve448, Decaf448, DecafPoint, Ed448, EdwardsPoint, MontgomeryPoint,
+    AffineMontgomeryPoint, AffinePoint, Curve448, Decaf448, DecafPoint, Ed448, EdwardsPoint,
     ProjectiveMontgomeryPoint, curve::twedwards::extended::ExtendedPoint as TwistedExtendedPoint,
 };
 use elliptic_curve::{
@@ -403,7 +403,7 @@ impl FieldElement {
         (inv_sqrt_x * u, zero_u | is_res)
     }
 
-    pub(crate) fn map_to_curve_elligator2_curve448(&self) -> MontgomeryPoint {
+    pub(crate) fn map_to_curve_elligator2_curve448(&self) -> AffineMontgomeryPoint {
         let mut t1 = self.square(); // 1.   t1 = u^2
         t1 *= Self::Z; // 2.   t1 = Z * t1              // Z * u^2
         let e1 = t1.ct_eq(&Self::MINUS_ONE); // 3.   e1 = t1 == -1            // exceptional case: Z * u^2 == -1
@@ -423,7 +423,7 @@ impl FieldElement {
         let mut y = y2.sqrt(); // 17.   y = sqrt(y2)
         let e3 = y.is_negative(); // 18.  e3 = sgn0(y) == 1
         y.conditional_negate(e2 ^ e3); //       y = CMOV(-y, y, e2 xor e3)
-        MontgomeryPoint::new(x, y)
+        AffineMontgomeryPoint::new(x, y)
     }
 
     // See https://www.rfc-editor.org/rfc/rfc9380.html#name-curve448-q-3-mod-4-k-1.

ed448-goldilocks/src/lib.rs

@@ -61,7 +61,7 @@ pub use edwards::{
 };
 pub use field::{MODULUS_LIMBS, ORDER, Scalar, WIDE_ORDER};
 pub use montgomery::{
-    MontgomeryPoint, MontgomeryScalar, MontgomeryScalarBytes, MontgomeryXpoint,
+    AffineMontgomeryPoint, MontgomeryScalar, MontgomeryScalarBytes, MontgomeryXpoint,
     ProjectiveMontgomeryPoint, ProjectiveMontgomeryXpoint, WideMontgomeryScalarBytes,
 };
 #[cfg(feature = "signing")]
@@ -213,7 +213,7 @@ impl FieldBytesEncoding<Curve448> for U448 {
 }
 
 impl CurveArithmetic for Curve448 {
-    type AffinePoint = MontgomeryPoint;
+    type AffinePoint = AffineMontgomeryPoint;
     type ProjectivePoint = ProjectiveMontgomeryPoint;
     type Scalar = MontgomeryScalar;
 }

ed448-goldilocks/src/montgomery.rs

@@ -15,7 +15,7 @@ mod point;
 mod scalar;
 mod x;
 
-pub use point::{MontgomeryPoint, ProjectiveMontgomeryPoint};
+pub use point::{AffineMontgomeryPoint, ProjectiveMontgomeryPoint};
 pub use scalar::{MontgomeryScalar, MontgomeryScalarBytes, WideMontgomeryScalarBytes};
 pub use x::{MontgomeryXpoint, ProjectiveMontgomeryXpoint};
 

ed448-goldilocks/src/montgomery/ops.rs

@@ -6,7 +6,7 @@ use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 use elliptic_curve::CurveGroup;
 use elliptic_curve::bigint::U448;
 
-use super::{MontgomeryPoint, MontgomeryScalar, MontgomeryXpoint, ProjectiveMontgomeryPoint};
+use super::{AffineMontgomeryPoint, MontgomeryScalar, MontgomeryXpoint, ProjectiveMontgomeryPoint};
 
 impl Add<&ProjectiveMontgomeryPoint> for &ProjectiveMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
@@ -52,12 +52,12 @@ define_add_variants!(
     Output = ProjectiveMontgomeryPoint
 );
 
-impl Add<&MontgomeryPoint> for &ProjectiveMontgomeryPoint {
+impl Add<&AffineMontgomeryPoint> for &ProjectiveMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
 
     // See Complete Addition Law for Montgomery Curves - Algorithm 2.
     // With "Trade-Off Technique".
-    fn add(self, rhs: &MontgomeryPoint) -> ProjectiveMontgomeryPoint {
+    fn add(self, rhs: &AffineMontgomeryPoint) -> ProjectiveMontgomeryPoint {
         let (x1, y1, z1) = (self.U, self.V, self.W);
         let (x2, y2) = (rhs.U, rhs.V);
 
@@ -92,11 +92,11 @@ impl Add<&MontgomeryPoint> for &ProjectiveMontgomeryPoint {
 
 define_add_variants!(
     LHS = ProjectiveMontgomeryPoint,
-    RHS = MontgomeryPoint,
+    RHS = AffineMontgomeryPoint,
     Output = ProjectiveMontgomeryPoint
 );
 
-impl Add<&ProjectiveMontgomeryPoint> for &MontgomeryPoint {
+impl Add<&ProjectiveMontgomeryPoint> for &AffineMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
 
     fn add(self, other: &ProjectiveMontgomeryPoint) -> ProjectiveMontgomeryPoint {
@@ -105,7 +105,7 @@ impl Add<&ProjectiveMontgomeryPoint> for &MontgomeryPoint {
 }
 
 define_add_variants!(
-    LHS = MontgomeryPoint,
+    LHS = AffineMontgomeryPoint,
     RHS = ProjectiveMontgomeryPoint,
     Output = ProjectiveMontgomeryPoint
 );
@@ -121,21 +121,21 @@ define_add_assign_variants!(
     RHS = ProjectiveMontgomeryPoint
 );
 
-impl AddAssign<&MontgomeryPoint> for ProjectiveMontgomeryPoint {
-    fn add_assign(&mut self, rhs: &MontgomeryPoint) {
+impl AddAssign<&AffineMontgomeryPoint> for ProjectiveMontgomeryPoint {
+    fn add_assign(&mut self, rhs: &AffineMontgomeryPoint) {
         *self += Self::from(*rhs);
     }
 }
 
-define_add_assign_variants!(LHS = ProjectiveMontgomeryPoint, RHS = MontgomeryPoint);
+define_add_assign_variants!(LHS = ProjectiveMontgomeryPoint, RHS = AffineMontgomeryPoint);
 
-impl AddAssign<&ProjectiveMontgomeryPoint> for MontgomeryPoint {
+impl AddAssign<&ProjectiveMontgomeryPoint> for AffineMontgomeryPoint {
     fn add_assign(&mut self, rhs: &ProjectiveMontgomeryPoint) {
         *self = (ProjectiveMontgomeryPoint::from(*self) + rhs).into();
     }
 }
 
-define_add_assign_variants!(LHS = MontgomeryPoint, RHS = ProjectiveMontgomeryPoint);
+define_add_assign_variants!(LHS = AffineMontgomeryPoint, RHS = ProjectiveMontgomeryPoint);
 
 impl Mul<&MontgomeryScalar> for &ProjectiveMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
@@ -152,15 +152,15 @@ define_mul_variants!(
     Output = ProjectiveMontgomeryPoint
 );
 
-impl Mul<&MontgomeryScalar> for &MontgomeryPoint {
+impl Mul<&MontgomeryScalar> for &AffineMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
 
     // Montgomery curves and their arithmetic - Algorithm 6
     // https://eprint.iacr.org/2017/212.pdf
     fn mul(self, rhs: &MontgomeryScalar) -> ProjectiveMontgomeryPoint {
         pub const A2: FieldElement = FieldElement(ConstMontyType::new(&U448::from_u64(312652)));
 
-        let MontgomeryPoint { U: xP, V: yP } = self;
+        let AffineMontgomeryPoint { U: xP, V: yP } = self;
         let (
             ProjectiveMontgomeryXpoint { U: xQ, W: zQ },
             ProjectiveMontgomeryXpoint { U: xD, W: zD },
@@ -191,7 +191,7 @@ impl Mul<&MontgomeryScalar> for &MontgomeryPoint {
 }
 
 define_mul_variants!(
-    LHS = MontgomeryPoint,
+    LHS = AffineMontgomeryPoint,
     RHS = MontgomeryScalar,
     Output = ProjectiveMontgomeryPoint
 );
@@ -239,21 +239,21 @@ define_sub_variants!(
     Output = ProjectiveMontgomeryPoint
 );
 
-impl Sub<&MontgomeryPoint> for &ProjectiveMontgomeryPoint {
+impl Sub<&AffineMontgomeryPoint> for &ProjectiveMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
 
-    fn sub(self, other: &MontgomeryPoint) -> ProjectiveMontgomeryPoint {
+    fn sub(self, other: &AffineMontgomeryPoint) -> ProjectiveMontgomeryPoint {
         *self - ProjectiveMontgomeryPoint::from(*other)
     }
 }
 
 define_sub_variants!(
     LHS = ProjectiveMontgomeryPoint,
-    RHS = MontgomeryPoint,
+    RHS = AffineMontgomeryPoint,
     Output = ProjectiveMontgomeryPoint
 );
 
-impl Sub<&ProjectiveMontgomeryPoint> for &MontgomeryPoint {
+impl Sub<&ProjectiveMontgomeryPoint> for &AffineMontgomeryPoint {
     type Output = ProjectiveMontgomeryPoint;
 
     fn sub(self, other: &ProjectiveMontgomeryPoint) -> ProjectiveMontgomeryPoint {
@@ -262,7 +262,7 @@ impl Sub<&ProjectiveMontgomeryPoint> for &MontgomeryPoint {
 }
 
 define_sub_variants!(
-    LHS = MontgomeryPoint,
+    LHS = AffineMontgomeryPoint,
     RHS = ProjectiveMontgomeryPoint,
     Output = ProjectiveMontgomeryPoint
 );
@@ -278,21 +278,21 @@ define_sub_assign_variants!(
     RHS = ProjectiveMontgomeryPoint
 );
 
-impl SubAssign<&MontgomeryPoint> for ProjectiveMontgomeryPoint {
-    fn sub_assign(&mut self, rhs: &MontgomeryPoint) {
+impl SubAssign<&AffineMontgomeryPoint> for ProjectiveMontgomeryPoint {
+    fn sub_assign(&mut self, rhs: &AffineMontgomeryPoint) {
         *self -= ProjectiveMontgomeryPoint::from(*rhs);
     }
 }
 
-define_sub_assign_variants!(LHS = ProjectiveMontgomeryPoint, RHS = MontgomeryPoint);
+define_sub_assign_variants!(LHS = ProjectiveMontgomeryPoint, RHS = AffineMontgomeryPoint);
 
-impl SubAssign<&ProjectiveMontgomeryPoint> for MontgomeryPoint {
+impl SubAssign<&ProjectiveMontgomeryPoint> for AffineMontgomeryPoint {
     fn sub_assign(&mut self, rhs: &ProjectiveMontgomeryPoint) {
         *self = (ProjectiveMontgomeryPoint::from(*self) - rhs).into();
     }
 }
 
-define_sub_assign_variants!(LHS = MontgomeryPoint, RHS = ProjectiveMontgomeryPoint);
+define_sub_assign_variants!(LHS = AffineMontgomeryPoint, RHS = ProjectiveMontgomeryPoint);
 
 impl<T> Sum<T> for ProjectiveMontgomeryPoint
 where