Rename MontgomeryPoint fields from x|y to U|V

Author: daxpedda

ed448-goldilocks/src/montgomery/ops.rs

@@ -59,7 +59,7 @@ impl Add<&MontgomeryPoint> for &ProjectiveMontgomeryPoint {
     // With "Trade-Off Technique".
     fn add(self, rhs: &MontgomeryPoint) -> ProjectiveMontgomeryPoint {
         let (x1, y1, z1) = (self.U, self.V, self.W);
-        let (x2, y2) = (rhs.x, rhs.y);
+        let (x2, y2) = (rhs.U, rhs.V);
 
         let t0 = x1 * x2;
         let t1 = y1 * y2;
@@ -160,7 +160,7 @@ impl Mul<&MontgomeryScalar> for &MontgomeryPoint {
     fn mul(self, rhs: &MontgomeryScalar) -> ProjectiveMontgomeryPoint {
         pub const A2: FieldElement = FieldElement(ConstMontyType::new(&U448::from_u64(312652)));
 
-        let MontgomeryPoint { x: xP, y: yP } = self;
+        let MontgomeryPoint { U: xP, V: yP } = self;
         let (
             ProjectiveMontgomeryXpoint { U: xQ, W: zQ },
             ProjectiveMontgomeryXpoint { U: xD, W: zD },

ed448-goldilocks/src/montgomery/point.rs

@@ -20,19 +20,19 @@ use crate::{AffinePoint, Curve448, Curve448FieldBytes, ORDER};
 /// A point in Montgomery form including the y-coordinate.
 #[derive(Copy, Clone, Debug, Default, Eq)]
 pub struct MontgomeryPoint {
-    pub(super) x: FieldElement,
-    pub(super) y: FieldElement,
+    pub(super) U: FieldElement,
+    pub(super) V: FieldElement,
 }
 
 impl MontgomeryPoint {
     /// The identity element of the group: the point at infinity.
     pub const IDENTITY: Self = Self {
-        x: FieldElement::ZERO,
-        y: FieldElement::ONE,
+        U: FieldElement::ZERO,
+        V: FieldElement::ONE,
     };
 
-    pub(crate) fn new(x: FieldElement, y: FieldElement) -> Self {
-        Self { x, y }
+    pub(crate) fn new(U: FieldElement, V: FieldElement) -> Self {
+        Self { U, V }
     }
 
     /// Generate a random [`MontgomeryPoint`].
@@ -56,15 +56,15 @@ impl MontgomeryPoint {
 impl ConditionallySelectable for MontgomeryPoint {
     fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self {
         Self {
-            x: FieldElement::conditional_select(&a.x, &b.x, choice),
-            y: FieldElement::conditional_select(&a.y, &b.y, choice),
+            U: FieldElement::conditional_select(&a.U, &b.U, choice),
+            V: FieldElement::conditional_select(&a.V, &b.V, choice),
         }
     }
 }
 
 impl ConstantTimeEq for MontgomeryPoint {
     fn ct_eq(&self, other: &Self) -> Choice {
-        self.x.ct_eq(&other.x) & self.y.ct_eq(&other.y)
+        self.U.ct_eq(&other.U) & self.V.ct_eq(&other.V)
     }
 }
 
@@ -77,8 +77,8 @@ impl PartialEq for MontgomeryPoint {
 impl From<&MontgomeryPoint> for ProjectiveMontgomeryPoint {
     fn from(value: &MontgomeryPoint) -> Self {
         ProjectiveMontgomeryPoint {
-            U: value.x,
-            V: value.y,
+            U: value.U,
+            V: value.V,
             W: FieldElement::ONE,
         }
     }
@@ -92,7 +92,7 @@ impl From<MontgomeryPoint> for ProjectiveMontgomeryPoint {
 
 impl From<&MontgomeryPoint> for MontgomeryXpoint {
     fn from(value: &MontgomeryPoint) -> Self {
-        MontgomeryXpoint(value.x.to_bytes())
+        MontgomeryXpoint(value.U.to_bytes())
     }
 }
 
@@ -105,8 +105,8 @@ impl From<MontgomeryPoint> for MontgomeryXpoint {
 impl From<&MontgomeryPoint> for AffinePoint {
     // https://www.rfc-editor.org/rfc/rfc7748#section-4.2
     fn from(value: &MontgomeryPoint) -> AffinePoint {
-        let x = value.x;
-        let y = value.y;
+        let x = value.U;
+        let y = value.V;
         let mut t0 = x.square(); // x^2
         let t1 = t0 + FieldElement::ONE; // x^2+1
         t0 -= FieldElement::ONE; // x^2-1
@@ -161,23 +161,23 @@ impl AffineCoordinates for MontgomeryPoint {
         let right = x.square() * x + FieldElement::J * xx + x;
         let is_on_curve = left.ct_eq(&right);
 
-        CtOption::new(Self { x, y }, is_on_curve)
+        CtOption::new(Self { U: x, V: y }, is_on_curve)
     }
 
     fn x(&self) -> Self::FieldRepr {
-        self.x.to_bytes().into()
+        self.U.to_bytes().into()
     }
 
     fn y(&self) -> Self::FieldRepr {
-        self.y.to_bytes().into()
+        self.V.to_bytes().into()
     }
 
     fn x_is_odd(&self) -> Choice {
-        self.x.is_negative()
+        self.U.is_negative()
     }
 
     fn y_is_odd(&self) -> Choice {
-        self.y.is_negative()
+        self.V.is_negative()
     }
 }
 
@@ -269,10 +269,10 @@ impl PartialEq for ProjectiveMontgomeryPoint {
 impl From<&ProjectiveMontgomeryPoint> for MontgomeryPoint {
     fn from(value: &ProjectiveMontgomeryPoint) -> Self {
         let W_inv = value.W.invert();
-        let x = value.U * W_inv;
-        let y = value.V * W_inv;
+        let U = value.U * W_inv;
+        let V = value.V * W_inv;
 
-        MontgomeryPoint { x, y }
+        MontgomeryPoint { U, V }
     }
 }
 
@@ -417,10 +417,10 @@ impl CurveGroup for ProjectiveMontgomeryPoint {
 
     fn to_affine(&self) -> Self::AffineRepr {
         let W_inv = self.W.invert();
-        let x = self.U * W_inv;
-        let y = self.V * W_inv;
+        let U = self.U * W_inv;
+        let V = self.V * W_inv;
 
-        MontgomeryPoint { x, y }
+        MontgomeryPoint { U, V }
     }
 }
 
@@ -432,9 +432,9 @@ impl GroupEncoding for ProjectiveMontgomeryPoint {
         let sign = bytes[0] & 1;
         bytes[0] &= 0xfe;
 
-        FieldElement::from_repr(&bytes).map(|x| {
+        FieldElement::from_repr(&bytes).map(|U| {
             ProjectiveMontgomeryXpoint {
-                U: x,
+                U,
                 W: FieldElement::ONE,
             }
             .to_extended(Choice::from(sign))
@@ -448,9 +448,9 @@ impl GroupEncoding for ProjectiveMontgomeryPoint {
 
     fn to_bytes(&self) -> Self::Repr {
         let affine = self.to_affine();
-        let mut bytes = affine.x.to_bytes();
+        let mut bytes = affine.U.to_bytes();
 
-        if affine.y.is_negative().unwrap_u8() == 1 {
+        if affine.V.is_negative().unwrap_u8() == 1 {
             bytes[0] |= 0x01;
         }