转载

将 Measurements 和 Units 应用到物理学

更新：

2016-08-02

为 Xcode 8 beta 4 更新代码

本系列其他文章：

(1) Measurements 和 Units 概览

(2) 乘法和除法（本文）

(3) 内容提炼

感谢 Chris Eidhof 和 Florian Kugler 帮助我想出这个解决方案。

在上篇文章结束时，我就计划实现一个通用的、声明式的方案来描述物理量间依赖关系的解决方案，例如 速度 = 长度 / 时间 。现在，让我们来具体实现这个想法吧。

方程的通用形式

目前，不同的 Unit 类本身对其他类并没有什么关联。对类型系统而言，他们是独立存在的实体^1。然而，在现实生活中，这些物理量之间是有联系的，并且我们可以通过一些方程来描述他们之间的关系。上面已经提到了一个例子，这里还有很多：

物理量之间的关系
速度 = 长度 / 时间
加速度 = 速度 / 时间
面积 = 长度 × 长度
体积 = 长度 × 长度 × 长度 = 面积 × 长度
电阻 = 电压 / 电流
功 = 功率 × 时间
密度 = 质量 / 体积
力 = 质量 × 加速度
压强 = 力 / 面积
力矩 = 历 × 长度

首先要注意的是，我们可以把所有的方程都归纳成 a = b × c 的形式，而除法可以被重写成乘法的形式： 速度 = 长度 / 时间 ⇔ 长度 = 速度 × 时间 。

其次，虽然有些方程超过了两个因子，我们总是可以通过一个中间量将其归纳成只有两个因子的形式（见上述例子中的体积方程式）。

UnitProduct 协议

因此，我们需要找到一个方式，可以在类型系统中通过三个 unit 类来描述 a = b × c 的关系，并且我们希望这个实现方式可以被任意类型所接受。所以我们定义一个叫做 UnitProduct 的协议，他有 Factor1 和 Factor2 两个关联类型。我们将其类型设定成 Dimension ，这是所有维度单位的父类：

/// Describes the relation Self = Factor1 * Factor2.
protocol UnitProduct {
    associatedtype Factor1: Dimension
    associatedtype Factor2: Dimension
}

我们还需要什么呢？为了进行计算，我们需要在计算时指定这些值需要转换的实际单位。换句话说，我们必须告诉类型系统，米除以秒将会产生一个结果，他的单位是 米每秒 ，而不是 千米每小时 。我们在协议里添加一个叫做 defaultUnitMapping() 的静态方法来实现这个目的。他会返回一个三元组，分别表示上述的 a，b 和 c。

在理想的情况下，我希望这个方法的返回值是 (Factor1, Factor2, Self) ，但是当我们通过一个具体的类，例如 UnitLength 来实现这个协议的时候，使用 Self 会引起一些问题。Unit 类不是一个 final 类，意味着他可以被子类化。如果我们通过 UnitLength 来实现协议，并且使用 UnitLength 作为 Self 的返回值，这个实现会被其子类继承，但这并不符合我们的协议，因为 Self 指向了子类的类型。出于此，编译器不允许我们这样做。如果 UnitLength 是值类型或者 final 类的话，那结果是不同的。

作为一种可行的方案，我们可以引进第三个关联类型来表示乘法的结果。我不喜欢这个方案，因为它强制协议的实现者来指定关联类型。虽然这非常不直观，却是可行的，完整的协议将变成：

protocol UnitProduct {
    associatedtype Factor1: Dimension
    associatedtype Factor2: Dimension
    associatedtype Product: Dimension // is always == Self

    static func defaultUnitMapping() -> (Factor1, Factor2, Product)
}

这足够在类型系统中表示他们之间的数学关系，并且为计算提供了关于单位关系的足够信息。

接下来，我们来写一个具体的实现。请记住，我们想实现的关系是 UnitLength = UnitSpeed × UnitDuration ，所以我们让 UnitLength 实现了协议：

/// UnitLength = UnitSpeed * UnitDuration
/// ⇔ UnitSpeed = UnitLength / UnitDuration
extension UnitLength: UnitProduct {
    typealias Factor1 = UnitSpeed
    typealias Factor2 = UnitDuration
    typealias Product = UnitLength

    static func defaultUnitMapping() -> (UnitSpeed, UnitDuration, UnitLength) {
        return (.metersPerSecond, .seconds, .meters)
    }
}

我们通过 typealias 明确的指定了关联类型，但其实我们可以不用这么做。编译器可以通过 defaultUnitMapping() 方法推断其类型，我们返回的三元组 (.metersPerSecond, .seconds, .meters) 指出这些单位是有相关性 )的（将两个相乘或者相除可以得到第三个）。这些单位也恰好是它们各自类型中的基本单位，但并非一定要这么做。我们可以选择其他的值，类似 (.kilometersPerHour, .hours, .kilometers) ，只要他们之间有相关性即可。

重载乘法操作符

在我们进行计算之前，还有一个步骤要做。我们需要实现协议的乘法操作符。这个方法是这样描述的，“这是一个 UnitProduct 的 * 运算符实现，他的左操作符是一个 Measurement<Factor1> ，右操作符是一个 Measurement<Factor2> ，返回值是 Measurement<Product> ”：

/// UnitProduct.Product = Factor1 * Factor2
func * <UnitType: UnitProduct> (lhs: Measurement<UnitType.Factor1>, rhs: Measurement<UnitType.Factor2>)
    -> Measurement<UnitType> where UnitType: Dimension, UnitType == UnitType.Product {    
    let (leftUnit, rightUnit, resultUnit) = UnitType.defaultUnitMapping()
    let quantity = lhs.converted(to: leftUnit).value
        * rhs.converted(to: rightUnit).value
    return Measurement(value: quantity, unit: resultUnit)
}

方法的实现有三个步骤。首先我们从协议中获得单位的映射。然后我们将操作数转换到各自的目标单位并且把他们相乘。最后，我们将结果包装成一个 Measurement 值并返回。让我们来试一下：

let speed = Measurement(value: 20, unit: UnitSpeed.kilometersPerHour)
// → 20.0 km/h
let time = Measurement(value: 2, unit: UnitDuration.hours)
// → 2.0 hr
let distance: Measurement<UnitLength> = speed * time
// → 40000.032 m

成功了，真棒！有三个值得注意的地方：

目前，类型检查器还不能推断出返回值的类型，所以我们必须明确的指定其为 Measurement<UnitLength> 类型，我不能非常确定这是为什么。我尝试了 * 运算符泛型参数的各种约束，但还是不能让它正常工作。
计算结果的单位是米，这虽然没什么大问题，但如果改成千米的话会更好，因为我们传进去的单位分别是千米每小时和小时，我们会在下篇文章中解决这个问题。
计算结果会有一点舍入误差，主要是由千米每小时到米每秒的转换引起的。

让乘法可交换

我们需要添加三个新的方法来达到这个目的，两个除法重载和一个乘法重载。因为乘法是可交换的，所以 时间 × 速度 与 速度 × 时间 应该完全一致。我们目前的方法不能满足这一点，但这也很好实现。只要再给 * 添加另一个重载方法，交换两个参数即可。直接返回之前重载过乘法的结果：

/// UnitProduct.Product = Factor2 * Factor1
func * <UnitType: UnitProduct>(lhs: Measurement<UnitType.Factor2>, rhs: Measurement<UnitType.Factor1>)
    -> Measurement<UnitType> where UnitType: Dimension, UnitType == UnitType.Product {
    return rhs * lhs
}

let distance2: Measurement<UnitLength> = time * speed
// → 40000.032 m

除法

同样，对于除法而言我们需要重载 Product / Factor1 和 Product / Factor2 两种情况：

/// UnitProduct / Factor1 = Factor2
func / <UnitType: UnitProduct>(lhs: Measurement<UnitType>, rhs: Measurement<UnitType.Factor1>)
    -> Measurement<UnitType.Factor2> where UnitType: Dimension, UnitType == UnitType.Product {
    let (rightUnit, resultUnit, leftUnit) = UnitType.defaultUnitMapping()
    let quantity = lhs.converted(to: leftUnit).value / rhs.converted(to: rightUnit).value
    return Measurement(value: quantity, unit: resultUnit)
}

/// UnitProduct / Factor2 = Factor1
func / <UnitType: UnitProduct>(lhs: Measurement<UnitType>, rhs: Measurement<UnitType.Factor2>)
    -> Measurement<UnitType.Factor1> where UnitType: Dimension, UnitType == UnitType.Product {
    let (resultUnit, rightUnit, leftUnit) = UnitType.defaultUnitMapping()
    let quantity = lhs.converted(to: leftUnit).value / rhs.converted(to: rightUnit).value
    return Measurement(value: quantity, unit: resultUnit)
}

let timeReversed = distance / speed
// → 7200.0 s
timeReversed.converted(to: .hours)
// → 2.0 hr
let speedReversed = distance / time
// → 5.55556 m/s
speedReversed.converted(to: .kilometersPerHour)
// → 20.0 km/h

有趣的是，类型检查对除法运算是管用的。我猜测，除法运算时其中的参数能直接追溯到其泛型参数的 UnitType ，而在乘法运算时其中的参数只是泛型参数的关联类型。我尝试在乘法运算中将参数 Factor1 和 Factor2 定义成完整的泛型参数，但这并不管用。如果你知道这是为什么的话请告诉我。

通过 5 行代码实现协议

现在，描述三个物理量之间的关系，我们需要做的仅仅是实现这个协议，并且实现一个只有一行代码的方法。这里拿电阻（ UnitElectricResistance ），电压（ UnitElectricPotentialDifference ）和电流（ UnitElectricCurrent ）来举例：

/// UnitElectricPotentialDifference = UnitElectricResistance * UnitElectricCurrent
extension UnitElectricPotentialDifference: UnitProduct {
    static func defaultUnitMapping() -> (UnitElectricResistance, UnitElectricCurrent, UnitElectricPotentialDifference) {
        return (.ohms, .amperes, .volts)
    }
}

这样使用：

let voltage = Measurement(value: 5, unit: UnitElectricPotentialDifference.volts)
// → 5.0 V
let current = Measurement(value: 500, unit: UnitElectricCurrent.milliamperes)
// → 500.0 mA
let resistance = voltage / current
// → 10.0 Ω