也支持 Decimal 的通用计算函数

Question

简而言之

当高精度很重要时，我正在玩计算来分析不同数字类型的可靠性和错误传播。 将相同的公式应用于不同的数字类型，我尝试使用泛型，但无法涵盖Decimal类型。

有没有办法为简单的数字函数提供一个涵盖Float 、 Double和Decimal的通用实现？

更多细节

计算基于穆勒序列，递归地应用一个非常简单的公式。 三种考虑类型的代码是：

func mullerFormulaDouble(y:Double, z:Double ) -> Double {
    return 108.0 - ( (815.0-1500.0/z)/y)
}
func mullerFormulaFloat(y:Float, z:Float ) -> Float {
    return 108.0 - ( (815.0-1500.0/z)/y)
}
func mullerFormulaDecimal(y:Decimal, z:Decimal ) -> Decimal {
    return Decimal(108) - ( (Decimal(815)-Decimal(1500)/z)/y)
}

通用计算如下所示：

func mullerFormula<T>(y:T, z:T ) -> T {      // a constraint is required for T
    let a = T(1500)/z
    let b = (T(815) - a)/y
    return T(108) - b
}
print (mullerFormula(y:4.0, z:4.24))
print (mullerFormula(y:Float(4.0), z:Float(4.24)))
print (mullerFormula(y:Decimal(4), z:Decimal(sign:.plus, exponent: -2, significand:424)))

由于有关T没有初始化程序的错误消息，上面的代码没有编译，这是有道理的。 需要一些类型约束才能使其工作。 所以我使用了T:Numeric ，但它在除法上失败了，错误是它不能应用于操作数T? 和T

几个错误之后，我最终得到了T:FloatingPoint 。 然后它适用于Double和Float ，但我仍然不能将它与Decimal一起使用，因为Decimal不符合FloatingPoint 。 我没有为我的类型约束找到任何其他合适的通用协议。

考虑到所有这三种数字类型都支持从整数初始化和四种基本操作，我无法想象没有办法编写一个通用函数来涵盖所有这些。 因此我的问题。

Answer 1

方法一：用你需要的函数定义一个BasicNumeric协议

这是一种方法。 创建一个名为BasicNumeric的protocol ，该协议具有您要使用的类型的公共属性。 声明您的类型实现了该协议，并使用该协议作为新函数中的约束：

protocol BasicNumeric: ExpressibleByIntegerLiteral {
    static func +(_: Self, _: Self) -> Self
    static func -(_: Self, _: Self) -> Self
    static func *(_: Self, _: Self) -> Self
    static func /(_: Self, _: Self) -> Self
}

extension Double:  BasicNumeric { }
extension Float:   BasicNumeric { }
extension Decimal: BasicNumeric { }

func mullerFormula<T: BasicNumeric>(y:T, z:T ) -> T {
    let a = 1500/z
    let b = (815 - a)/y
    return 108 - b
}

print (mullerFormula(y:4.0, z:4.24))
print (mullerFormula(y:Float(4.0), z:Float(4.24)))
print (mullerFormula(y:Decimal(4), z:Decimal(sign:.plus, exponent: -2, significand:424)))

输出：

-7.306603773584911
-7.3066025
-7.30660377358490566037735849056603775

---

方法 2：定义Divisible协议并使用Numeric协议

Leo Dabus 在评论中提供了这种替代实现。

protocol Divisible {
    static func /(_: Self, _: Self) -> Self
}

extension Double:  Divisible { }
extension Float:   Divisible { }
extension Decimal: Divisible { }

func mullerFormula<T: Numeric & Divisible>(y: T, z: T) -> T {
    let a = 1500 / z
    let b = (815 - a) / y
    return 108 - b
}