Some init(clamping:) infinity fixes (#21).

Sources/CoreKit/BinaryInteger+Validation.swift

@@ -129,7 +129,7 @@ extension BinaryInteger {
     }
 
     /// Creates a new instance by clamping the given `source`.
-    @_disfavoredOverload // req. because of EdgyInteger.init(clamping: some FiniteInteger)
+    @_disfavoredOverload // BinaryInteger.init(clamping: some FiniteInteger)
     @inlinable public init(clamping source: some BinaryInteger) where Self: EdgyInteger {
         self.init(clamping: source)!
     }
@@ -149,25 +149,31 @@ extension BinaryInteger {
     ///
     /// - Note: This is the most generic version of `init(clamping:)`.
     ///
+    @_disfavoredOverload // BinaryInteger.init(clamping: some FiniteInteger)
     @inlinable public init?(clamping source: some BinaryInteger) {
-        if  Self.isSigned, source.isInfinite {
+        let size: Magnitude = Self.size
+        if !size.isInfinite {
+
+            if  let  instance = Self.exactly(source).optional() {
+                self = instance
+
+            }   else if Self.isSigned {
+                let distance = (size).decremented().unchecked()
+                let msb = (1 as Magnitude).up(Shift(unchecked: distance))
+                self.init(raw: source.isNegative ? msb : msb.toggled())
+
+            }   else {
+                self.init(repeating: Bit(!source.isNegative))
+            }
+
+        }   else if Self.isSigned, source.isInfinite {
             return nil
 
         }   else if !Self.isSigned, source.isNegative {
             self.init()
 
-        }   else if Self.size.isInfinite {
+        }   else {
             self.init(load: source)
-
-        }   else if let instance = Self.exactly(source).optional() {
-            self = instance
-
-        }   else if Self.isSigned {
-            let msb = (1 as Magnitude).up(Shift(Self.size - 1))
-            self.init(raw: source.isNegative ? msb : msb.toggled())
-
-        }   else/* if !Self.isSigned */ {
-            self.init(repeating: Bit.one)
         }
     }
 }

Sources/TestKit/Globals.swift

@@ -26,10 +26,6 @@ public let coreSystemsIntegersWhereIsUnsigned: [any (SystemsInteger & UnsignedIn
     UX.self, U8.self, U16.self, U32.self, U64.self,
 ]
 
-//=----------------------------------------------------------------------------=
-// MARK: + Values
-//=----------------------------------------------------------------------------=
-
 /// A collection of all primes that fit in one byte.
 ///
 /// - Note: It contains `54` elements.

Sources/TestKit/Test+Validation.swift

@@ -43,7 +43,9 @@ extension Test {
                 yay(clamped.incremented().error, "T.init(clamping:) - max")
             }
         }   else {
-            yay(Output.isSigned && input.isInfinite, "arbitrary signed integers cannot clamp infinite values")
+            yay(Output.isSigned,        "init(clamping:) [nil][0]")
+            yay(Output.size.isInfinite, "init(clamping:) [nil][1]")
+            yay((((input))).isInfinite, "init(clamping:) [nil][2]")
         }
         //=--------------------------------------=
         // path: sign and magnitude

Tests/UltimathnumTests/BinaryInteger+Validation.swift

@@ -0,0 +1,42 @@
+//=----------------------------------------------------------------------------=
+// This source file is part of the Ultimathnum open source project.
+//
+// Copyright (c)  2023 Oscar Byström Ericsson
+// Licensed under Apache License, Version 2.0
+//
+// See http://www.apache.org/licenses/LICENSE-2.0 for license information.
+//=----------------------------------------------------------------------------=
+
+import CoreKit
+import DoubleIntKit
+import InfiniIntKit
+import TestKit
+
+//*============================================================================*
+// MARK: * Binary Integer x Validation
+//*============================================================================*
+//=----------------------------------------------------------------------------=
+// MARK: + Edge Cases
+//=----------------------------------------------------------------------------=
+
+extension BinaryIntegerTests {
+
+    //=------------------------------------------------------------------------=
+    // MARK: Tests
+    //=------------------------------------------------------------------------=
+
+    /// 2024-06-20: Signed systems integers should successfully clamp `∞`.
+    func testSystemsIntegersCanClampInfiniteValues() {
+        func whereIs<A, B>(_ source: A.Type, _ destinaiton: B.Type) where A: UnsignedInteger, B: SystemsInteger {
+            precondition(A.size.isInfinite)
+            Test().same(B(clamping: A.max    ), B.max)
+            Test().same(B(clamping: A.max - 1), B.max)
+        }
+
+        for source in Self.arbitraryIntegersWhereIsUnsigned {
+            for destinaiton in Self.systemsIntegers {
+                whereIs(source, destinaiton)
+            }
+        }
+    }
+}

Tests/UltimathnumTests/BinaryInteger.swift

@@ -0,0 +1,66 @@
+//=----------------------------------------------------------------------------=
+// This source file is part of the Ultimathnum open source project.
+//
+// Copyright (c)  2023 Oscar Byström Ericsson
+// Licensed under Apache License, Version 2.0
+//
+// See http://www.apache.org/licenses/LICENSE-2.0 for license information.
+//=----------------------------------------------------------------------------=
+
+import CoreKit
+import DoubleIntKit
+import InfiniIntKit
+import TestKit
+
+//*============================================================================*
+// MARK: * Binary Integer
+//*============================================================================*
+
+final class BinaryIntegerTests: XCTestCase {
+
+    //=------------------------------------------------------------------------=
+    // MARK: Metadata
+    //=------------------------------------------------------------------------=
+
+    static let types: [any BinaryInteger.Type] = {
+        typesWhereIsSigned +
+        typesWhereIsUnsigned
+    }()
+
+    static let typesWhereIsSigned: [any SignedInteger.Type] = {
+        systemsIntegersWhereIsSigned +
+        arbitraryIntegersWhereIsSigned
+    }()
+
+    static let typesWhereIsUnsigned: [any UnsignedInteger.Type] = {
+        systemsIntegersWhereIsUnsigned +
+        arbitraryIntegersWhereIsUnsigned
+    }()
+
+    static let arbitraryIntegersWhereIsSigned: [any SignedInteger.Type] = [
+        InfiniInt<I8>.self,
+        InfiniInt<IX>.self,
+    ]
+
+    static let arbitraryIntegersWhereIsUnsigned: [any UnsignedInteger.Type] = [
+        InfiniInt<U8>.self,
+        InfiniInt<UX>.self,
+    ]
+
+    static var systemsIntegers: [any SystemsInteger.Type] = {
+        systemsIntegersWhereIsSigned +
+        systemsIntegersWhereIsUnsigned
+    }()
+
+    static var systemsIntegersWhereIsSigned: [any (SystemsInteger & SignedInteger).Type] = [
+        IX.self,  I8 .self, I16.self, I32.self, I64 .self,
+        DoubleInt<I8>.self, DoubleInt<DoubleInt<I8>>.self,
+        DoubleInt<IX>.self, DoubleInt<DoubleInt<IX>>.self,
+    ]
+
+    static var systemsIntegersWhereIsUnsigned: [any (SystemsInteger & UnsignedInteger).Type] = [
+        UX.self,  U8 .self, U16.self, U32.self, U64 .self,
+        DoubleInt<U8>.self, DoubleInt<DoubleInt<U8>>.self,
+        DoubleInt<UX>.self, DoubleInt<DoubleInt<UX>>.self,
+    ]
+}