如何用swift将双倍积分四舍五入到最近的整数？

Question

我正在尝试制作一个增长率计算器（双），它将结果四舍五入到最近的整数并从那里重新计算，如下所示：

let firstUsers = 10.0
let growth = 0.1
var users = firstUsers
var week = 0


while users < 14 {
    println("week \(week) has \(users) users")
    users += users * growth
    week += 1
}

但到目前为止我还不能。

编辑我有点这样做：

var firstUsers = 10.0
let growth = 0.1
var users:Int = Int(firstUsers)
var week = 0


while users <= 14 {
    println("week \(week) has \(users) users")
    firstUsers += firstUsers * growth
    users = Int(firstUsers)
    week += 1
}

虽然我不介意它总是向下取整，但我不喜欢它，因为firstUsers必须成为一个变量并在整个程序中进行更改（为了进行下一次计算），我不希望发生这种情况。

Answer 1

浮点协议（例如 Double 和 Float 符合该协议）绘制了舍入 （_：） 方法的蓝图

func rounded(_ rule: FloatingPointRoundingRule) -> Self

其中FloatingPointRounding规则是一个枚举许多不同舍入规则的枚举：

从零开始区分大小写

四舍五入到最接近的允许值，其大小大于或等于源的值。

区分大小写

四舍五入到小于或等于源的最接近的允许值。

大小写为NearestOrAwayFromZero

舍入到最接近的允许值；如果两个值同样接近，则选择幅度较大的值。

案例到最近或偶数

四舍五入到最接近的允许值；如果两个值相等接近，则选择偶数。

案例toardZero

舍入到幅度小于或等于源幅度的最接近的允许值。

大小写

四舍五入到最接近的允许值，该值大于或等于源。

我们使用了类似于@Suragch的优秀答案的例子来展示这些不同的取整选项。

四舍五入到最接近的允许值，其大小大于或等于源的值；C函数之间没有直接等价，因为这使用了，有条件地基于自己、CEIL或地板的符号，分别为自己的正值和负值。

3.000.rounded(.awayFromZero) // 3.0
3.001.rounded(.awayFromZero) // 4.0
3.999.rounded(.awayFromZero) // 4.0

(-3.000).rounded(.awayFromZero) // -3.0
(-3.001).rounded(.awayFromZero) // -4.0
(-3.999).rounded(.awayFromZero) // -4.0

相当于C地板函数。

3.000.rounded(.down) // 3.0
3.001.rounded(.down) // 3.0
3.999.rounded(.down) // 3.0

(-3.000).rounded(.down) // -3.0
(-3.001).rounded(.down) // -4.0
(-3.999).rounded(.down) // -4.0

相当于C轮函数。

3.000.rounded(.toNearestOrAwayFromZero) // 3.0
3.001.rounded(.toNearestOrAwayFromZero) // 3.0
3.499.rounded(.toNearestOrAwayFromZero) // 3.0
3.500.rounded(.toNearestOrAwayFromZero) // 4.0
3.999.rounded(.toNearestOrAwayFromZero) // 4.0

(-3.000).rounded(.toNearestOrAwayFromZero) // -3.0
(-3.001).rounded(.toNearestOrAwayFromZero) // -3.0
(-3.499).rounded(.toNearestOrAwayFromZero) // -3.0
(-3.500).rounded(.toNearestOrAwayFromZero) // -4.0
(-3.999).rounded(.toNearestOrAwayFromZero) // -4.0

也可以使用零参数四舍五入（）方法访问此四舍五入规则。

3.000.rounded() // 3.0
// ...

(-3.000).rounded() // -3.0
// ...

四舍五入到最接近的允许值；如果两个值同样接近，则选择偶数；相当于Crint（/非常类似于附近的）函数。

3.499.rounded(.toNearestOrEven) // 3.0
3.500.rounded(.toNearestOrEven) // 4.0 (up to even)
3.501.rounded(.toNearestOrEven) // 4.0

4.499.rounded(.toNearestOrEven) // 4.0
4.500.rounded(.toNearestOrEven) // 4.0 (down to even)
4.501.rounded(.toNearestOrEven) // 5.0 (up to nearest)

等效于 C 截断函数。

3.000.rounded(.towardZero) // 3.0
3.001.rounded(.towardZero) // 3.0
3.999.rounded(.towardZero) // 3.0

(-3.000).rounded(.towardZero) // 3.0
(-3.001).rounded(.towardZero) // 3.0
(-3.999).rounded(.towardZero) // 3.0

如果舍入的目的是准备使用整数（例如，在舍入后通过浮点初始化使用 Int），我们可以简单地利用这样一个事实，即当使用 Double（或 Float 等）初始化 Int 时，小数部分将被截断。

Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3

Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3

相当于C ceil函数。

3.000.rounded(.up) // 3.0
3.001.rounded(.up) // 4.0
3.999.rounded(.up) // 4.0

(-3.000).rounded(.up) // 3.0
(-3.001).rounded(.up) // 3.0
(-3.999).rounded(.up) // 3.0

如果我们愿意，我们可以查看FloatingPoint协议的源代码，直接查看与公共FloatingPointRounding规则规则等效的C函数。

来自swift/stdlib/public/core/FloatingPoint.swift。gyb我们看到round（_：）方法的默认实现使我们想到了变化的round（_:）方法：

public func rounded(_ rule: FloatingPointRoundingRule) -> Self {
    var lhs = self
    lhs.round(rule)
    return lhs
}

从swift/stdlib/public/core/floatingpointtypes . swift . gyb中，我们找到了< code>round(_:)的默认实现，其中< code > FloatingPointRoundingRule 规则和C舍入函数之间的等价性是显而易见的:

public mutating func round(_ rule: FloatingPointRoundingRule) {
    switch rule {
    case .toNearestOrAwayFromZero:
        _value = Builtin.int_round_FPIEEE${bits}(_value)
    case .toNearestOrEven:
        _value = Builtin.int_rint_FPIEEE${bits}(_value)
    case .towardZero:
        _value = Builtin.int_trunc_FPIEEE${bits}(_value)
    case .awayFromZero:
        if sign == .minus {
            _value = Builtin.int_floor_FPIEEE${bits}(_value)
        }
        else {
            _value = Builtin.int_ceil_FPIEEE${bits}(_value)
        }
    case .up:
        _value = Builtin.int_ceil_FPIEEE${bits}(_value)
    case .down:
        _value = Builtin.int_floor_FPIEEE${bits}(_value)
    }
}

Answer 2

匿名用户

要将双精度舍入到最接近的整数，只需使用round（）。

var x = 3.7
x.round() // x = 4.0

如果不想修改原始值，请使用rounded（）：

let x = 3.7
let y = x.rounded() // y = 4.0. x = 3.7

正如人们可能期望的（也可能不期望的），像3.5这样的数字被四舍五入，像-3.5这样的数字被四舍五入。如果您需要不同的四舍五入行为，您可以使用其中一个四舍五入规则。例如：

var x = 3.7
x.round(.towardZero) // 3.0

如果您需要一个实际的< code>Int，那么只需将其转换为一个(但前提是您确定Double不会大于< code>Int.max):

let myInt = Int(myDouble.rounded())

• 这个答案被完全改写了。我的旧答案涉及C数学函数，如round、lround、floor和ceil。然而，现在Swift已经内置了此功能，我不能再建议使用这些功能。感谢@dfri向我指出这一点。在这里查看@dfri的精彩答案。我也做了类似的事情来舍入CGFloat

Answer 3

基金会库中有一个回合（它实际上是在达尔文中，但基金会导入达尔文，大多数时候你会想要使用基金会而不是直接使用达尔文）。

import Foundation

users = round(users)

在操场上运行您的代码，然后调用:

print(round(users))

输出：

15.0

round（） 总是在小数位为

如果你需要四舍五入到一个特定的地方，那么你乘以pow（10.0，地方数），四舍五入，然后除以pow（10，地方数）：

四舍五入到两位小数：

let numberOfPlaces = 2.0
let multiplier = pow(10.0, numberOfPlaces)
let num = 10.12345
let rounded = round(num * multiplier) / multiplier
print(rounded)

输出：

10.12

注意：由于浮点数学的工作方式，舍入可能并不总是完全准确的。最好将其视为四舍五入的近似值。如果出于显示目的而执行此操作，最好使用字符串格式来设置数字格式，而不是使用数学运算来舍入数字。