extend tests

Author: mkrd

Tests/BigNumberTests/Test_BDouble_Extended.swift

@@ -152,4 +152,27 @@ class Test_BDouble_Extended: XCTestCase {
 		let str = z.decimalExpansion(precisionAfterDecimalPoint: 4, rounded: false)
 		XCTAssertEqual(str, "0.0000")
 	}
+
+	func test_decimal_expansion_repeating_pattern() {
+		// 1/7 = 0.142857142857... (period 6)
+		let val = BDouble(1, over: 7)
+		let expansion = val.decimalExpansion(precisionAfterDecimalPoint: 6000, rounded: false)
+		let digits = String(expansion.dropFirst(2)) // drop "0."
+		XCTAssertEqual(digits.count, 6000)
+
+		let period = "142857"
+		for i in stride(from: 0, to: digits.count - 5, by: 6) {
+			let start = digits.index(digits.startIndex, offsetBy: i)
+			let end = digits.index(start, offsetBy: 6)
+			XCTAssertEqual(String(digits[start..<end]), period,
+				"1/7 period mismatch at position \(i)")
+		}
+	}
+
+	func test_decimal_expansion_1_over_3() {
+		let val = BDouble(1, over: 3)
+		let expansion = val.decimalExpansion(precisionAfterDecimalPoint: 5000, rounded: false)
+		let digits = String(expansion.dropFirst(2))
+		XCTAssert(digits.allSatisfy({ $0 == "3" }), "1/3 should be all 3s")
+	}
 }

Tests/BigNumberTests/Test_BIntMath_Extended.swift

@@ -170,6 +170,49 @@ class Test_BIntMath_Extended: XCTestCase {
 		}
 	}
 
+	func test_fib_large_recurrence() {
+		// F(n) = F(n-1) + F(n-2) for larger values
+		for n in [100, 500, 1000, 5000] {
+			XCTAssertEqual(
+				BIntMath.fib(n),
+				BIntMath.fib(n - 1) + BIntMath.fib(n - 2),
+				"fib(\(n)) != fib(\(n-1)) + fib(\(n-2))"
+			)
+		}
+	}
+
+	func test_fib_larger_known_values() {
+		XCTAssertEqual(BIntMath.fib(100), BInt("354224848179261915075")!)
+		XCTAssertEqual(BIntMath.fib(300), BInt("222232244629420445529739893461909967206666939096499764990979600")!)
+
+		// fib(1000): verify via recurrence and digit count
+		let f1000 = BIntMath.fib(1000)
+		XCTAssertEqual(f1000.description.count, 209)
+		XCTAssert(f1000.description.hasPrefix("4346655768693745643568852767"))
+		XCTAssertEqual(f1000, BIntMath.fib(999) + BIntMath.fib(998))
+	}
+
+	func test_fib_lucas_identity() {
+		// F(2k) = F(k) * [2*F(k+1) - F(k)]
+		for k in [50, 200, 500, 1000] {
+			let f2k = BIntMath.fib(2 * k)
+			let fk = BIntMath.fib(k)
+			let fk1 = BIntMath.fib(k + 1)
+			XCTAssertEqual(f2k, fk * (BInt(2) * fk1 - fk),
+				"Lucas identity failed for k=\(k)")
+		}
+	}
+
+	func test_fib_100000_spot_check() {
+		let f = BIntMath.fib(100_000)
+		// Known digit count
+		XCTAssertEqual(f.description.count, 20899)
+		// Known prefix
+		XCTAssert(f.description.hasPrefix("2597406934722"))
+		// Recurrence: F(100000) = F(99999) + F(99998)
+		XCTAssertEqual(f, BIntMath.fib(99_999) + BIntMath.fib(99_998))
+	}
+
 	// MARK: - Mersenne
 
 	func test_isMersenne() {

Tests/BigNumberTests/Test_Basic_Math.swift

@@ -242,6 +242,60 @@ class Test_Basic_Math: XCTestCase {
 		}
 	}
 
+	func test_Multiplication_large_roundtrip() {
+		// (a*b)/a == b for large operands
+		let a = BIntMath.randomBInt(bits: 10_000)
+		let b = BIntMath.randomBInt(bits: 10_000)
+		let product = a * b
+		XCTAssertEqual(product / a, b)
+		XCTAssertEqual(product / b, a)
+	}
+
+	func test_Multiplication_commutative_large() {
+		let a = BIntMath.randomBInt(bits: 50_000)
+		let b = BIntMath.randomBInt(bits: 50_000)
+		XCTAssertEqual(a * b, b * a)
+	}
+
+	func test_Multiplication_distributive() {
+		let a = BIntMath.randomBInt(bits: 5_000)
+		let b = BIntMath.randomBInt(bits: 5_000)
+		let c = BIntMath.randomBInt(bits: 5_000)
+		XCTAssertEqual(a * (b + c), a * b + a * c)
+	}
+
+	func test_Multiplication_known_square() {
+		let base = BInt(10) ** 1000
+		XCTAssertEqual(base * base, BInt(10) ** 2000)
+	}
+
+	func test_Factorial_consistency() {
+		// n! == n * (n-1)!
+		XCTAssertEqual(BInt(1000).factorial(), BInt(1000) * BInt(999).factorial())
+		XCTAssertEqual(BInt(10000).factorial(), BInt(10000) * BInt(9999).factorial())
+	}
+
+	func test_Factorial_trailing_zeros() {
+		// Trailing zeros in n! = sum of floor(n/5^k)
+		func expectedTrailingZeros(_ n: Int) -> Int {
+			var count = 0; var p = 5
+			while p <= n { count += n / p; p *= 5 }
+			return count
+		}
+		for n in [100, 1000, 5000, 10000] {
+			let str = BInt(n).factorial().description
+			let zeros = str.reversed().prefix(while: { $0 == "0" }).count
+			XCTAssertEqual(zeros, expectedTrailingZeros(n), "\(n)! trailing zeros")
+		}
+	}
+
+	func test_Exponentiation_10_pow_large() {
+		let str = (BInt(10) ** 10_000).description
+		XCTAssertEqual(str.count, 10_001)
+		XCTAssertEqual(str.first, "1")
+		XCTAssert(str.dropFirst().allSatisfy({ $0 == "0" }))
+	}
+
     func test_Power() {
         // Reference issue #41
         let TWO : BInt = 2

Tests/BigNumberTests/Test_String_Conversions_Extended.swift

@@ -74,6 +74,41 @@ class Test_String_Conversions_Extended: XCTestCase {
 		}
 	}
 
+	// MARK: - Hex string for large numbers
+
+	func test_hex_known_power_of_two() {
+		XCTAssertEqual((BInt(1) << 64).asString(radix: 16), "10000000000000000")
+		XCTAssertEqual(((BInt(1) << 128) - 1).asString(radix: 16),
+			"ffffffffffffffffffffffffffffffff")
+		XCTAssertEqual((BInt(1) << 256).asString(radix: 16),
+			"1" + String(repeating: "0", count: 64))
+	}
+
+	func test_hex_roundtrip_factorial() {
+		// Roundtrip 1500! through hex — matches the benchmark
+		let fac = BInt(1500).factorial()
+		let hex = fac.asString(radix: 16)
+		let back = BInt(hex, radix: 16)!
+		XCTAssertEqual(back, fac, "1500! hex roundtrip failed")
+	}
+
+	func test_hex_vs_decimal_consistency() {
+		// Verify hex and decimal representations refer to the same number
+		let big = BInt(1000).factorial()
+		let fromDec = BInt(big.description)!
+		let fromHex = BInt(big.asString(radix: 16), radix: 16)!
+		XCTAssertEqual(fromDec, fromHex)
+	}
+
+	func test_large_radix_roundtrips() {
+		let big = BInt(500).factorial()
+		for radix in [2, 8, 16, 32, 36] {
+			let str = big.asString(radix: radix)
+			let back = BInt(str, radix: radix)!
+			XCTAssertEqual(back, big, "500! roundtrip failed for base \(radix)")
+		}
+	}
+
 	// MARK: - Bytes roundtrip extended
 
 	func test_bytes_roundtrip_extended() {