Edge refactored

Author: mcallisto

src/ring_seq/methods.py

@@ -39,11 +39,40 @@ class Vertex(AxisLocation):
     i: Index
 
 
-@dataclass(frozen=True)
 class Edge(AxisLocation):
-    """A symmetry axis location passing between two adjacent elements."""
-    i: Index
-    j: Index
+    """A symmetry axis location passing between two consecutive elements of a circular sequence.
+
+    The invariant `j == (i + 1) % n` is enforced at construction — direct
+    construction of an edge with arbitrary `(i, j)` is not supported.
+    Pattern matching with `match e: case Edge(i, j): ...` still works.
+    """
+
+    __match_args__ = ("i", "j")
+
+    def __init__(self, i: Index, n: int):
+        """Constructs the edge between consecutive elements of a circular sequence of size `n`,
+        starting at circular index `i`. The endpoint `j = ((i mod n) + 1) mod n` is computed.
+
+        Args:
+          i: circular index of the first endpoint (any integer, normalized to `[0, n)`)
+          n: the ring size; must be positive
+
+        Raises:
+          ValueError: if `n <= 0`
+        """
+        if n <= 0:
+            raise ValueError("ring size must be positive")
+        self.i = i % n
+        self.j = (self.i + 1) % n
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Edge) and self.i == other.i and self.j == other.j
+
+    def __hash__(self) -> int:
+        return hash((Edge, self.i, self.j))
+
+    def __repr__(self) -> str:
+        return f"Edge(i={self.i}, j={self.j})"
 
 
 def index_from(ring: Seq, i: IndexO) -> Index:
@@ -711,7 +740,7 @@ def reflectional_symmetry_axes(ring: Seq) -> list[tuple[AxisLocation, AxisLocati
     n: int = len(ring)
 
     def edge_indices(i: Index) -> Edge:
-        return Edge(i, (i + 1) % n)
+        return Edge(i, n)
 
     def opposite_edge_index(i: Index) -> Index:
         return (i + n // 2) % n

tests/SymmetryTest.py

@@ -54,9 +54,9 @@ def test_reflectional_symmetry_axes_triangle(self):
         self.assertEqual(
             reflectional_symmetry_axes((1, 1, 1)),
             [
-                (Vertex(1), Edge(2, 0)),
-                (Vertex(2), Edge(0, 1)),
-                (Vertex(0), Edge(1, 2)),
+                (Vertex(1), Edge(2, 3)),
+                (Vertex(2), Edge(0, 3)),
+                (Vertex(0), Edge(1, 3)),
             ],
         )
 
@@ -74,9 +74,9 @@ def test_reflectional_symmetry_axes_square(self):
         self.assertEqual(
             reflectional_symmetry_axes((1, 1, 1, 1)),
             [
-                (Edge(1, 2), Edge(3, 0)),
+                (Edge(1, 4), Edge(3, 4)),
                 (Vertex(1), Vertex(3)),
-                (Edge(0, 1), Edge(2, 3)),
+                (Edge(0, 4), Edge(2, 4)),
                 (Vertex(0), Vertex(2)),
             ],
         )
@@ -95,9 +95,32 @@ def test_reflectional_symmetry_axes_doubled_square(self):
     def test_reflectional_symmetry_axes_specular_pentagon(self):
         self.assertEqual(
             reflectional_symmetry_axes((1, 1, 2, 3, 2)),
-            [(Vertex(3), Edge(0, 1))],
+            [(Vertex(3), Edge(0, 5))],
         )
 
+    def test_edge_computes_second_endpoint(self):
+        e = Edge(2, 4)
+        self.assertEqual(e.i, 2)
+        self.assertEqual(e.j, 3)
+        # wraps around the ring
+        self.assertEqual(Edge(3, 4).j, 0)
+
+    def test_edge_normalizes_out_of_range_i(self):
+        self.assertEqual(Edge(-1, 5), Edge(4, 5))
+        self.assertEqual(Edge(7, 5), Edge(2, 5))
+
+    def test_edge_rejects_non_positive_ring_size(self):
+        with self.assertRaises(ValueError):
+            Edge(0, 0)
+        with self.assertRaises(ValueError):
+            Edge(0, -1)
+
+    def test_edge_supports_pattern_matching(self):
+        match Edge(2, 4):
+            case Edge(i, j):
+                self.assertEqual(i, 2)
+                self.assertEqual(j, 3)
+
 
 if __name__ == '__main__':
     unittest.main()