fix: correct UnitCurve cubic interpolation (#1218)

Author: Kyle-Ye

Sources/OpenSwiftUICore/Animation/Animation/UnitCurve.swift

@@ -3,7 +3,7 @@
 //  OpenSwiftUICore
 //
 //  Audited for 6.5.4
-//  Status: Complete (solveX needs verification)
+//  Status: Complete
 //  ID: 54864F491103B6AE5CAC10D2D922245F (SwiftUICore)
 
 package import Foundation
@@ -80,11 +80,11 @@ public struct UnitCurve {
             let solver = CubicSolver(
                 startControlPoint: UnitPoint(
                     x: startControlPoint.x.clamp(min: 0.0, max: 1.0),
-                    y: startControlPoint.y.clamp(min: 0.0, max: 1.0)
+                    y: startControlPoint.y
                 ),
                 endControlPoint: UnitPoint(
                     x: endControlPoint.x.clamp(min: 0.0, max: 1.0),
-                    y: endControlPoint.y.clamp(min: 0.0, max: 1.0)
+                    y: endControlPoint.y
                 )
             )
             return solver.value(at: clampValue)
@@ -292,80 +292,69 @@ extension UnitCurve {
             return round((y / x) * pow(2, 20)) * pow(2, -20)
         }
 
-        // TODO: Implemented by Copilot. Verify this via unit test later
         fileprivate func solveX(_ time: Double, epsilon: Double) -> Double {
-            // Helper function to evaluate cubic polynomial: ax*t³ + bx*t² + cx*t
             func evaluateX(_ t: Double) -> Double {
-                return ((ax * t + bx) * t + cx) * t
+                return (cx + t * (bx + ax * t)) * t
             }
 
-            // Helper function to evaluate derivative: 3*ax*t² + 2*bx*t + cx
             func evaluateDerivativeX(_ t: Double) -> Double {
-                return (3.0 * ax * t + 2.0 * bx) * t + cx
+                return cx + ((bx + bx) + (ax * 3.0) * t) * t
             }
 
-            // Initial guess using direct evaluation
-            let initialGuess = evaluateX(time)
-            let initialError = abs(initialGuess - time)
-
-            // If initial guess is close enough, return it
-            if initialError < epsilon {
+            let initialValue = evaluateX(time)
+            let initialError = initialValue - time
+            if abs(initialError) < epsilon {
                 return time
             }
 
-            let derivative = evaluateDerivativeX(time)
-
-            // Try Newton's method if derivative is large enough
-            if abs(derivative) >= epsilon {
-                var t = time - (initialGuess - time) / derivative
-
-                // Perform up to 7 Newton iterations
-                for _ in 0..<7 {
-                    let value = evaluateX(t)
-                    let error = abs(value - time)
-
-                    if error < epsilon {
-                        return t
-                    }
-
-                    let deriv = evaluateDerivativeX(t)
-                    if abs(deriv) < epsilon {
-                        break // Derivative too small, fall back to bisection
-                    }
-
-                    t = t - (value - time) / deriv
+            var t = time
+            var value = initialValue
+            for _ in 0..<7 {
+                let derivative = evaluateDerivativeX(t)
+                // Only an ordered comparison triggers fallback. NaN continues.
+                if abs(derivative) < epsilon {
+                    break
+                }
+                t = t - (value - time) / derivative
+                value = evaluateX(t)
+                if abs(value - time) < epsilon {
+                    return t
                 }
             }
 
-            // Fall back to bisection method if Newton's method fails or isn't applicable
-            if time < 0.0 || time > 1.0 {
-                return time // Outside valid range
+            if time < 0.0 {
+                return 0.0
+            }
+            if time > 1.0 {
+                return 1.0
             }
 
+            // Restart bisection with the original input and signed residual.
             var low = 0.0
             var high = 1.0
-            var t = time
-            var iterationCount = 0
-
-            while low < high && iterationCount >= 0 {
-                let value = evaluateX(t)
-                let error = abs(value - time)
-
-                if error < epsilon {
-                    return t
-                }
+            t = time
+            var error = initialError
+            var remainingIterations = 1023
 
-                let diff = value - time
-                if diff < 0.0 {
+            while true {
+                if error < 0.0 {
                     low = t
                 } else {
                     high = t
                 }
-
                 t = low + (high - low) * 0.5
-                iterationCount += 1
+                // Return this next midpoint when the bracket or limit ends,
+                // before another evaluation. An unordered bracket also ends.
+                guard low < high, remainingIterations != 0 else {
+                    return t
+                }
+                value = evaluateX(t)
+                error = value - time
+                remainingIterations -= 1
+                if abs(error) < epsilon {
+                    return t
+                }
             }
-            return t
         }
     }
 }

Tests/OpenSwiftUICompatibilityTests/Animation/Animation/UnitCurveCompatibilityTests.swift

@@ -2,8 +2,8 @@
 //  UnitCurveCompatibilityTests.swift
 //  OpenSwiftUICompatibilityTests
 
-import Testing
 import Numerics
+import Testing
 
 // MARK: - UnitCurveTests
 
@@ -150,9 +150,24 @@ struct UnitCurveCompatibilityTests {
         #expect(curve.value(at: 0.0).isApproximatelyEqual(to: 0.0))
         #expect(curve.value(at: 1.0).isApproximatelyEqual(to: 1.0))
         #expect(curve.value(at: 0.5).isApproximatelyEqual(to: 0.5))
+        #expect(curve.value(at: 0.15625).isApproximatelyEqual(to: 0.71875, absoluteTolerance: 0.00001))
+        #expect(curve.value(at: 0.84375).isApproximatelyEqual(to: 0.28125, absoluteTolerance: 0.00001))
         #expect(curve.velocity(at: 0.5).isApproximatelyEqual(to: -1.0))
     }
 
+    @Test(arguments: [
+        (-1.0, -0.625),
+        (2.0, 1.625),
+    ])
+    func bezierValuePreservesUnclampedY(controlY: Double, expected: Double) {
+        let curve = UnitCurve.bezier(
+            startControlPoint: UnitPoint(x: 0.25, y: controlY),
+            endControlPoint: UnitPoint(x: 0.75, y: controlY)
+        )
+
+        #expect(curve.value(at: 0.5) == expected)
+    }
+
     // MARK: - Value Function
 
     @Test

Tests/OpenSwiftUICoreTests/Animation/Animation/UnitCurveTests.swift

@@ -41,6 +41,48 @@ struct UnitCurveTests {
         #expect(solver.velocity(at: 0.5).isApproximatelyEqual(to: 1.199, absoluteTolerance: 0.001))
     }
 
+    @Test(arguments: [
+        (0.0, 1.0, -0.0001, 0.0),
+        (1.0, 0.0, 1.0001, 1.0),
+    ])
+    func cubicSolverClampsFallbackEndpoints(x: Double, y: Double, progress: Double, expected: Double) {
+        let point = UnitPoint(x: x, y: y)
+        let solver = UnitCurve.CubicSolver(startControlPoint: point, endControlPoint: point)
+
+        #expect(solver.value(at: progress) == expected)
+    }
+
+    @Test
+    func cubicSolverDoesNotClampAcceptedInput() {
+        let solver = UnitCurve.CubicSolver(
+            startControlPoint: UnitPoint(x: 1.0 / 3.0, y: 1.0 / 3.0),
+            endControlPoint: UnitPoint(x: 2.0 / 3.0, y: 2.0 / 3.0)
+        )
+
+        #expect(solver.value(at: -1.0) == -1.0)
+        #expect(solver.value(at: 2.0) == 2.0)
+    }
+
+    @Test
+    func cubicSolverBoundsUnorderedBisection() {
+        // NaN x controls prevent convergence. A large finite y scale keeps
+        // the final midpoint visible after output rounding.
+        let point = UnitPoint(x: .nan, y: 0x1p1022)
+        let solver = UnitCurve.CubicSolver(startControlPoint: point, endControlPoint: point)
+
+        #expect(solver.value(at: 0.5) == 0.375)
+    }
+
+    @Test
+    func cubicSolverPreservesNaNInput() {
+        let solver = UnitCurve.CubicSolver(
+            startControlPoint: UnitPoint(x: 0.25, y: 0.1),
+            endControlPoint: UnitPoint(x: 0.75, y: 0.9)
+        )
+
+        #expect(solver.value(at: .nan).isNaN)
+    }
+
     // MARK: - Edge Cases
 
     @Test