Fixed: limited integer bounds & precision to the largest valid sequence of 9s.

Author: oscbyspro

Sources/DiffableTextKitXNumber/Graphs/Graph+Floats.swift

@@ -39,8 +39,8 @@ where Value: _Input & BinaryFloatingPoint & SignedNumeric {
     /// - Limited by `Double.max` due to `FloatingPointFormatStyle`.
     fileprivate init() where Value: LosslessStringConvertible {
         let size = Swift.min(Value.significandBitCount, Double.significandBitCount)
-        self.precision = Int.init(log10(pow(2.0, Double.init(size))))
-        self.max = Value(String(repeating:  "9", count: precision ))!
+        self.precision = Int(log10(pow(2, Double.init(size))))/*-*/
+        self.max = Value(String(repeating: "9", count: precision))!
         self.min = -(max)
     }
 

Sources/DiffableTextKitXNumber/Graphs/Graph+Integers.swift

@@ -35,12 +35,20 @@ where Value: _Input & FixedWidthInteger {
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    /// - Limited by `Int.max` due to `IntegerFormatStyle`.
-    fileprivate init() {
-        let large = Value.bitWidth >= Int.bitWidth
-        self.max = large  ? Value(Int.max) : Value.max
-        self.min = large && Value.isSigned ? Value(Int.min) : Value.min
-        self.precision = Int(ceil(log10(Double(max))))
+    /// - Limited by Int.max due to IntegerFormatStyle.
+    /// - Limited by longest sequence of 9s due to IntegerFormatStyle.
+    fileprivate init() where Value: LosslessStringConvertible {
+        let limit = Value(clamping: Int.max)
+        //=--------------------------------------=
+        // Precision
+        //=--------------------------------------=
+        self.precision = Int(floor(log10(Double(limit))))
+        let nines = String(repeating: "9", count: precision)
+        //=--------------------------------------=
+        // Bounds
+        //=--------------------------------------=
+        self.max = Value(nines)! // max <= precision, 9s <= Int.max
+        self.min = Value.isSigned ? Value("-" + nines)! : Value.min
     }
 
     //=------------------------------------------------------------------------=

Tests/DiffableTextKitXNumberTests/Graphs/Graph.swift

@@ -24,15 +24,15 @@ final class GraphTests: XCTestCase {
     //=------------------------------------------------------------------------=
 
     func testBounds_Decimal_Double_Int64() {
-        XCTAssertEqual(Decimal.max, Decimal(string: String(repeating: "9", count: 38))!)
-        XCTAssertEqual(Double .max, Double(         String(repeating: "9", count: 15))!)
-        XCTAssertEqual(Int64  .max, Int64.max)
+        XCTAssertEqual(Decimal._NumberTextGraph.max, Decimal(string: String(repeating: "9", count: 38))!)
+        XCTAssertEqual(Double ._NumberTextGraph.max, Double    .init(String(repeating: "9", count: 15))!)
+        XCTAssertEqual(Int64  ._NumberTextGraph.max, Int64     .init(String(repeating: "9", count: 18))!)
     }
 
     func testPrecision_Decimal_Double_Int64() {
-        XCTAssertEqual(Decimal.precision, 38)
-        XCTAssertEqual(Double .precision, 15)
-        XCTAssertEqual(Int64  .precision, 19)
+        XCTAssertEqual(Decimal._NumberTextGraph.precision, 38)
+        XCTAssertEqual(Double ._NumberTextGraph.precision, 15)
+        XCTAssertEqual(Int64  ._NumberTextGraph.precision, 18)
     }
 }
 

Tests/DiffableTextKitXNumberTests/Models/Precision.swift

@@ -86,14 +86,14 @@ final class PrecisionTests: XCTestCase {
     }
 
     func testInt() {
-        let digits   = 1...19
-        let integer  = 1...19
+        let digits   = 1...18 // 9s
+        let integer  = 1...18 // 9s
         let fraction = 0...00
 
         var precision = _Precision<Int>()
         XCTAssert(precision, digits: digits, integer: integer, fraction: fraction)
 
-        precision = _Precision<Int>(7...7)
+        precision = _Precision<Int>( 7...7)
         XCTAssert(precision, digits: 7...7, integer: integer, fraction: fraction)
 
         precision = _Precision<Int>(integer: 7...7, fraction: 7...7)
@@ -102,6 +102,24 @@ final class PrecisionTests: XCTestCase {
         precision = _Precision<Int>(integer: (-99)...99, fraction: (-99)...99)
         XCTAssert(precision, digits: digits, integer: integer, fraction: fraction)
     }
+    
+    func testUInt() {
+        let digits   = 1...18 // 9s
+        let integer  = 1...18 // 9s
+        let fraction = 0...00
+        
+        var precision = _Precision<UInt>()
+        XCTAssert(precision, digits: digits, integer: integer, fraction: fraction)
+        
+        precision = _Precision<UInt>(7...7)
+        XCTAssert(precision, digits: 7...7, integer: integer, fraction: fraction)
+        
+        precision = _Precision<UInt>(integer: 7...7, fraction: 7...7)
+        XCTAssert(precision, digits: digits, integer: 7...7, fraction: fraction)
+        
+        precision = _Precision<UInt>(integer: (-99)...99, fraction: (-99)...99)
+        XCTAssert(precision, digits: digits, integer: integer, fraction: fraction)
+    }
 }
 
 #endif

Tests/DiffableTextKitXNumberTests/Styles/Style+Currency.swift

@@ -137,7 +137,7 @@ extension StyleTestsOnCurrency {
     }
 
     func testUInt8() {
-        XCTAssertCurrencies(123 as UInt8)
+        XCTAssertCurrencies(012 as UInt8) // 9s
     }
 
     func testUInt16() {

Tests/DiffableTextKitXNumberTests/Styles/Style+Number.swift

@@ -75,7 +75,7 @@ extension StyleTestsOnNumber {
     }
 
     func testInt8() {
-        XCTAssertLocales(-123 as Int8)
+        XCTAssertLocales(-012 as Int8) // 9s
     }
 
     func testInt16() {
@@ -106,7 +106,7 @@ extension StyleTestsOnNumber {
     }
 
     func testUInt8() {
-        XCTAssertLocales(123 as UInt8)
+        XCTAssertLocales(012 as UInt8) // 9s
     }
 
     func testUInt16() {