Shrink integers using midpoint function

Author: x-sheep

Sources/PropertyBased/Shrink+Integer.swift

@@ -13,52 +13,40 @@ extension Shrink {
         public typealias Element = IntegerType
 
         @usableFromInline var current: IntegerType
-        @usableFromInline var leap: IntegerType
-
-        @usableFromInline let isSubtracting: Bool
-
-        /// The first value in the sequence.
-        @usableFromInline let first: IntegerType
         /// Stop the sequence when reaching the end. Do not yield this value.
         @usableFromInline let end: IntegerType
 
         @usableFromInline init(from: IntegerType, bound: IntegerType) {
-            first = bound
             current = bound
             end = from
-            isSubtracting = bound > from
-
-            let newLeap: (partialValue: IntegerType, overflow: Bool)
-            if isSubtracting {
-                newLeap = (bound / 2).subtractingReportingOverflow(from / 2)
-            } else {
-                newLeap = (from / 2).subtractingReportingOverflow(bound / 2)
-            }
-            leap = !newLeap.overflow ? newLeap.partialValue : .max / 2
         }
 
         public mutating func next() -> IntegerType? {
-            let hasReachedEnd = isSubtracting ? current <= end : current >= end
-            guard !hasReachedEnd, leap > 0 else {
+            guard current != end else {
                 return nil
             }
-
             defer {
-                if isSubtracting {
-                    current -= leap
-                } else {
-                    current += leap
-                }
-            }
-            if current != first {
-                leap /= 2
+                let next = current.midpoint(towards: end)
+                current = current != next ? next : end
             }
             return current
         }
     }
 }
 
 extension FixedWidthInteger {
+
+    // Adapted from https://github.com/apple/swift-numerics/pull/293
+    @inlinable func midpoint(towards other: Self) -> Self {
+        // Isolate bits in a + b with weight 2, and those with weight 1
+        let twos = self & other
+        let ones = self ^ other
+        let floor = twos &+ ones >> 1
+        let frac = ones & 1
+
+        return floor &+ (self < other ? frac : 0)
+    }
+
     /// Get a shrinking sequence that shrinks this value to a specific value.
     /// - Parameter bound: The value to shrink towards.
     /// - Returns: A new sequence.

Tests/PropertyBasedTests/ShrinkTests+Array.swift

@@ -59,13 +59,13 @@ import Testing
             [3, 10, 25],
             [4, 0, 25],
             [4, 5, 25],
-            [4, 7, 25],
             [4, 8, 25],
+            [4, 9, 25],
             [4, 10, 0],
-            [4, 10, 12],
-            [4, 10, 18],
-            [4, 10, 21],
+            [4, 10, 13],
+            [4, 10, 19],
             [4, 10, 22],
+            [4, 10, 24],
         ]
 
         #expect(actual == expected)