将 Measurements 和 Units 应用到物理学

头像
SwiftGG翻译组
    阅读 6 分钟

    作者：Ole Begemann，原文链接，原文日期：2016-07-29
    译者：钟颖；校对：小铁匠Linus；定稿：CMB

    更新：
    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

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

    1. 目前，类型检查器还不能推断出返回值的类型，所以我们必须明确的指定其为 Measurement<UnitLength> 类型，我不能非常确定这是为什么。我尝试了 * 运算符泛型参数的各种约束，但还是不能让它正常工作。

    2. 计算结果的单位是米，这虽然没什么大问题，但如果改成千米的话会更好，因为我们传进去的单位分别是千米每小时和小时，我们会在下篇文章中解决这个问题。

    3. 计算结果会有一点舍入误差，主要是由千米每小时到米每秒的转换引起的。

    让乘法可交换

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

    
/// 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 Ω

    结语

    我觉得这非常酷，而且向我们展示了强大的类型系统是如何帮助我们写出正确代码的。一旦定义好了关系，编译器就不允许我们进行无意义的计算了（比如将分子和分母搞混）。在类型推断的过程中，编译器甚至能告诉我们运算结果的类型（请注意上面最后一个例子中，我们并没有指定电阻的类型）。

    我同样喜欢声明式来描述关系的方式。本质上我们只需要告诉编译器：“嘿，这就是这三个量之间的关系，剩下的事情你搞定”，然后所有的运算和类型检查都很完美地完成了。

    展望

    在第三部分中，我会提出一个可能的解决方案，它能够在计算过程中保留单位（千米除以小时得到千米每小时，而不是米每秒），并讨论当前解决方案的另一个局限性。敬请关注！

    本文由 SwiftGG 翻译组翻译，已经获得作者翻译授权，最新文章请访问 http://swift.gg。

    1. 他们有一个共同的父类，但在这个时候并不重要。 ↩
    swift
    SwiftGG翻译组
    1.6k 声望957 粉丝

    走心的 Swift 翻译组

    « 上一篇
    这样的 StackView 动画，你想到了吗？
    下一篇 »
    在 GitHub 上进行协同写作

    引用和评论

    推荐阅读
    头像
    如何用 UIKit Dynamics 进行碰撞检测

    SwiftGG翻译组赞 6阅读 5.6k

    头像
    苹果已提供新的设计资源 | Swift 周报 issue 32

    Swift社区赞 5阅读 748评论 2

    头像
    在 SwiftUI 中实战应用 ContentUnavailableView

    Swift社区赞 4阅读 709

    头像
    在 SwiftUI 中实战使用 MapKit API

    Swift社区赞 4阅读 694

    头像
    SwiftUI Release 引入的辅助焦点管理

    Swift社区赞 4阅读 563

    头像
    Swift 定制 Core Data 迁移

    Swift社区赞 3阅读 941

    头像
    如何使用 SwiftUI 构建 visionOS 应用

    Swift社区赞 3阅读 767评论 2

    0 条评论
    得票最新