Initial data commit

Task/Pathological-floating-point-problems/Swift/pathological-floating-point-problems.swift

@@ -0,0 +1,97 @@
+extension Numeric where Self: Strideable {
+  @inlinable
+  public func power(_ n: Self) -> Self {
+    return stride(from: 0, to: n, by: 1).lazy.map({_ in self }).reduce(1, *)
+  }
+}
+
+protocol PathologicalFloat: SignedNumeric, Strideable, ExpressibleByFloatLiteral {
+  static var e: Self { get }
+
+  static func /(_ lhs: Self, _ rhs: Self) -> Self
+}
+
+extension Double: PathologicalFloat {
+  static var e: Double { Double("2.71828182845904523536028747135266249")! }
+}
+
+extension Float: PathologicalFloat {
+  static var e: Float { Float("2.7182818284590")! }
+}
+
+extension Decimal: PathologicalFloat {
+  static var e: Decimal { Decimal(string: "2.71828182845904523536028747135266249")! }
+}
+
+extension BDouble: PathologicalFloat {
+  static var e: BDouble { BDouble("2.71828182845904523536028747135266249")! }
+
+  public func advanced(by n: BDouble) -> BDouble { self + n }
+  public func distance(to other: BDouble) -> BDouble { abs(self - other) }
+}
+
+func badSequence<T: PathologicalFloat>(n: Int) -> T {
+  guard n != 1 else { return 2 }
+  guard n != 2 else { return -4 }
+
+  var a: T = 2, b: T = -4
+
+  for _ in stride(from: 2, to: n, by: 1) {
+    (a, b) = (b, 111 - 1130  / b + 3000 / (a * b))
+  }
+
+  return b
+}
+
+func chaoticBank<T: PathologicalFloat>(years: T) -> T {
+  var balance = T.e - 1
+
+  for year: T in stride(from: 1, through: 25, by: 1) {
+    balance = (balance * year) - 1
+  }
+
+  return balance
+}
+
+func rumpFunction<T: PathologicalFloat>(_ a: T, _ b: T) -> T {
+  let aSquared = a.power(2)
+  let bSix = b.power(6)
+
+  let f1 = 333.75 * bSix
+  let f2 = aSquared * (11 * aSquared * b.power(2) - bSix - 121 * b.power(4) - 2)
+  let f3 = 5.5 * b.power(8) + a / (2 * b)
+
+  return f1 + f2 + f3
+}
+
+func fmt<T: CVarArg>(_ n: T) -> String { String(format: "%16.16f", n) }
+
+print("Bad sequence")
+for i in [3, 4, 5, 6, 7, 8, 20, 30, 50, 100] {
+  let vFloat: Float = badSequence(n: i)
+  let vDouble: Double = badSequence(n: i)
+  let vDecimal: Decimal = badSequence(n: i)
+  let vBigDouble: BDouble = badSequence(n: i)
+
+  print("v(\(i)) as Float \(fmt(vFloat)); as Double = \(fmt(vDouble)); as Decimal = \(vDecimal); as BDouble = \(vBigDouble.decimalExpansion(precisionAfterDecimalPoint: 16, rounded: false))")
+}
+
+
+let bankFloat: Float = chaoticBank(years: 25)
+let bankDouble: Double = chaoticBank(years: 25)
+let bankDecimal: Decimal = chaoticBank(years: 25)
+let bankBigDouble: BDouble = chaoticBank(years: 25)
+
+print("\nChaotic bank")
+print("After 25 years your bank will be \(bankFloat) if stored as a Float")
+print("After 25 years your bank will be \(bankDouble) if stored as a Double")
+print("After 25 years your bank will be \(bankDecimal) if stored as a Decimal")
+print("After 25 years your bank will be \(bankBigDouble.decimalExpansion(precisionAfterDecimalPoint: 16, rounded: false)) if stored as a BigDouble")
+
+let rumpFloat: Float = rumpFunction(77617.0, 33096.0)
+let rumpDouble: Double = rumpFunction(77617.0, 33096.0)
+let rumpDecimal: Decimal = rumpFunction(77617.0, 33096.0)
+let rumpBigDouble: BDouble = rumpFunction(77617.0, 33096.0)
+
+print("\nRump's function")
+print("rump(77617.0, 33096.0) as Float \(rumpFloat); as Double = \(rumpDouble); as Decimal = \(rumpDecimal); as BDouble = \(rumpBigDouble.decimalExpansion(precisionAfterDecimalPoint: 16, rounded: false))")