Adding AngleSweep.isEquivalent(to:)

Sources/Geometria/Angles/Angle.swift

@@ -14,6 +14,15 @@ public struct Angle<Scalar: FloatingPoint & ElementaryFunctions>: Hashable {
         self.radians = radians
     }
 
+    /// Returns `true` if `self` and `other` refer to the same angle, after
+    /// normalization.
+    public func isEquivalent(to other: Self) -> Bool {
+        let normalizedSelf = self.normalized(from: .zero)
+        let normalizedOther = other.normalized(from: .zero)
+
+        return normalizedSelf == normalizedOther
+    }
+
     /// Returns this angle's normalized representation, starting from a given
     /// offset, such that the angle is confined to `[lowerBound, lowerBound + π)`
     public func normalized(from lowerBound: Scalar) -> Scalar {

Sources/Geometria/Angles/AngleSweep.swift

@@ -21,17 +21,28 @@ public struct AngleSweep<Scalar: FloatingPoint & ElementaryFunctions>: Hashable
         self.sweep = sweep
     }
 
+    /// Returns `true` if `self` and `other` cover to the same angle sweep, after
+    /// normalization.
+    ///
+    /// This method ignores the signs of the sweeps, and only compares the covered
+    /// circular arc of both angle sweeps.
+    public func isEquivalent(to other: Self) -> Bool {
+        let (selfStart, selfStop) = self.normalizedStartStop(from: .zero)
+        let (otherStart, otherStop) = other.normalizedStartStop(from: .zero)
+
+        if selfStart == otherStart && selfStop == otherStop {
+            return true
+        }
+
+        return false
+    }
+
     /// Returns `true` if this circular arc contains a given angle value within
     /// its start + sweep region.
     public func contains(_ angle: Angle<Scalar>) -> Bool {
-        let normalAngle = angle.normalized(from: .zero)
-        var normalStart = start.normalized(from: .zero)
-        var normalStop = (start + sweep).normalized(from: .zero)
-
-        if sweep.radians < .zero {
-            swap(&normalStart, &normalStop)
-        }
+        let (normalStart, normalStop) = normalizedStartStop(from: .zero)
 
+        let normalAngle = angle.normalized(from: .zero)
         if normalStart > normalStop {
             return normalAngle >= normalStart || normalAngle <= normalStop
         }
@@ -42,12 +53,7 @@ public struct AngleSweep<Scalar: FloatingPoint & ElementaryFunctions>: Hashable
     /// Returns the result of clamping a given angle so it is contained within
     /// this angle sweep.
     public func clamped(_ angle: Angle<Scalar>) -> Angle<Scalar> {
-        var normalStart = start.normalized(from: .zero)
-        var normalStop = (start + sweep).normalized(from: .zero)
-
-        if sweep.radians < .zero {
-            swap(&normalStart, &normalStop)
-        }
+        let (normalStart, normalStop) = normalizedStartStop(from: .zero)
 
         let nMin = (Angle(radians: normalStart) - angle).normalized(from: -.pi)
         let nMax = (Angle(radians: normalStop) - angle).normalized(from: -.pi)
@@ -61,4 +67,15 @@ public struct AngleSweep<Scalar: FloatingPoint & ElementaryFunctions>: Hashable
 
         return .init(radians: normalStop)
     }
+
+    func normalizedStartStop(from lowerBound: Scalar) -> (normalStart: Scalar, normalStop: Scalar) {
+        var normalStart = start.normalized(from: lowerBound)
+        var normalStop = (start + sweep).normalized(from: lowerBound)
+
+        if sweep.radians < .zero {
+            swap(&normalStart, &normalStop)
+        }
+
+        return (normalStart, normalStop)
+    }
 }

Sources/GeometriaPeriodics/2D/CircleArc2Simplex.swift

@@ -0,0 +1,21 @@
+import Geometria
+
+/// A 2-dimensional simplex composed of a circular arc segment.
+public struct CircleArc2Simplex<Vector: Vector2Real>: Periodic2Simplex {
+    /// The circular arc segment associated with this simplex.
+    public var circleArc: CircleArc2<Vector>
+
+    /// Initializes a new circular arc segment simplex value with a given circular
+    /// arc segment.
+    public init(circleArc: CircleArc2<Vector>) {
+        self.circleArc = circleArc
+    }
+}
+
+extension CircleArc2Simplex {
+    @inlinable
+    public var start: Vector { circleArc.startPoint }
+
+    @inlinable
+    public var end: Vector { circleArc.endPoint }
+}

Sources/GeometriaPeriodics/2D/LineSegment2Simplex.swift

@@ -0,0 +1,20 @@
+import Geometria
+
+/// A 2-dimensional simplex composed of a line segment.
+public struct LineSegment2Simplex<Vector: Vector2Type>: Periodic2Simplex {
+    /// The line segment associated with this simplex.
+    public var lineSegment: LineSegment2<Vector>
+
+    /// Initializes a new line segment simplex value with a given line segment.
+    public init(lineSegment: LineSegment2<Vector>) {
+        self.lineSegment = lineSegment
+    }
+}
+
+extension LineSegment2Simplex {
+    @inlinable
+    public var start: Vector { lineSegment.start }
+
+    @inlinable
+    public var end: Vector { lineSegment.end }
+}

Sources/GeometriaPeriodics/2D/Protocols/Periodic2Geometry.swift

@@ -0,0 +1,17 @@
+import Geometria
+
+/// A 2-dimensional periodic geometry that produces lines and circular arcs as
+/// periodic simplexes.
+public protocol Periodic2Geometry: PeriodicGeometry {
+    /// The type of period that this periodic geometry uses to refer to its
+    /// ordered simplexes.
+    associatedtype Period: PeriodType
+
+    /// The inclusive lower bound period within this geometry.
+    var startPeriod: Period { get }
+
+    /// The exclusive upper bound period within this geometry.
+    ///
+    /// This value is not part of the addressable period range.
+    var endPeriod: Period { get }
+}

Sources/GeometriaPeriodics/2D/Protocols/Periodic2Simplex.swift

@@ -0,0 +1,11 @@
+import Geometria
+
+/// Protocol for types that describe 2-dimensional simplexes produced by 2-dimensional
+/// periodic geometry.
+public protocol Periodic2Simplex: PeriodicSimplex where Vector: Vector2Type {
+    /// Gets the starting point of this simplex.
+    var start: Vector { get }
+
+    /// Gets the ending point of this simplex.
+    var end: Vector { get }
+}

Sources/GeometriaPeriodics/Generalized/Protocols/PeriodType.swift

@@ -0,0 +1,4 @@
+/// Type for periods that can be used to refer to sections of simplexes of periodic
+/// geometry.
+public protocol PeriodType: Comparable {
+}

Sources/GeometriaPeriodics/Generalized/Protocols/PeriodicSimplex.swift

@@ -0,0 +1,6 @@
+import Geometria
+
+/// Protocol for types that describe simplexes produced by periodic geometry.
+public protocol PeriodicSimplex: GeometricType {
+    associatedtype Vector: VectorType
+}

Tests/GeometriaTests/Angles/AngleSweepTests.swift

@@ -0,0 +1,61 @@
+import XCTest
+
+@testable import Geometria
+
+class AngleSweepTests: XCTestCase {
+    typealias Sut = AngleSweep<Double>
+
+    func testIsEquivalent_equal() {
+        assertIsEquivalent(
+            .init(start: .pi, sweep: .pi / 2),
+            .init(start: .pi, sweep: .pi / 2)
+        )
+        assertIsEquivalent(
+            .init(start: 0.0, sweep: .pi / 2),
+            .init(start: 0.0, sweep: .pi / 2)
+        )
+        assertNotIsEquivalent(
+            .init(start: .pi, sweep: .pi / 2),
+            .init(start: .pi / 2, sweep: .pi / 2)
+        )
+    }
+
+    func testIsEquivalent_equivalentSweep() {
+        assertIsEquivalent(
+            .init(start: .pi / 2, sweep: .pi / 2),
+            .init(start: .pi, sweep: -.pi / 2)
+        )
+        assertIsEquivalent(
+            .init(start: -.pi / 2, sweep: .pi),
+            .init(start: .pi / 2, sweep: -.pi)
+        )
+    }
+}
+
+// MARK: - Test internals
+
+private func assertIsEquivalent(
+    _ lhs: AngleSweep<Double>,
+    _ rhs: AngleSweep<Double>,
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    guard !lhs.isEquivalent(to: rhs) else {
+        return
+    }
+
+    XCTFail("\(lhs) is not equivalent to \(rhs)", file: file, line: line)
+}
+
+private func assertNotIsEquivalent(
+    _ lhs: AngleSweep<Double>,
+    _ rhs: AngleSweep<Double>,
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    guard lhs.isEquivalent(to: rhs) else {
+        return
+    }
+
+    XCTFail("\(lhs) is equivalent to \(rhs)", file: file, line: line)
+}