如何舍入一个双到最近的Int在迅速?

我试图使增长率(Double)的计算器，将结果舍入到最近的整数，并从那里重新计算，如下所示:

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
}

但到目前为止我还不能。

< em >编辑 我是这样做的:

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必须成为一个变量，并在整个程序中改变(为了进行下一次计算)，这是我不希望发生的。

200671 次浏览
小开
最佳答案

在Foundation库(它实际上在Darwin中，但__ABC1导入Darwin，大多数时候你会想使用__ABC1而不是直接使用Darwin)中有一个round可用。

import Foundation


users = round(users)

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

print(round(users))

输出:

15.0

当小数点为>= .5时，round()总是向上舍入，当它为< .5时则向下舍入(标准舍入)。可以使用floor()强制向下舍入，使用ceil()强制向上舍入。

如果你需要四舍五入到一个特定的位置，那么你乘以pow(10.0, number of places)， round，然后除以pow(10, number of places):

四舍五入到小数点后两位:

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

输出:

10.12

由于浮点数学的工作方式，rounded可能并不总是完全准确。最好把它看作是四舍五入的近似。如果这样做是为了显示，最好使用字符串格式来格式化数字，而不是使用数学来四舍五入。

小开

要四舍五入到最接近的整数，只需使用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

如果你需要一个实际的Int，那么只需将其转换为1(但只有当你确定Double不会大于Int.max时):

let myInt = Int(myDouble.rounded())

笔记

  • 这个答案完全改写了。我的旧答案涉及C数学函数，如round， lround， floor和ceil。然而，现在Swift已经内置了这个功能，我不能再推荐使用这些功能了。感谢@dfri为我指出这一点。看看@dfri的回答非常棒。我也为舍入CGFloat做了类似的事情。
小开

斯威夫特3

var myNum = 8.09
myNum.rounded() // result = 8 and leaves myNum unmodified
小开

Swift 3 &4 -在FloatingPoint协议中使用蓝图中的rounded(_:)方法

FloatingPoint协议(例如，Double和Float符合)是rounded(_:)方法的蓝图

func rounded(_ rule: FloatingPointRoundingRule) -> Self

其中FloatingPointRoundingRule是枚举许多不同舍入规则的枚举:

case awayFromZero

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

case down

舍入到最接近的允许值，该值小于或等于 源。< / p >

case toNearestOrAwayFromZero

舍入到最接近的允许值;如果两个值相等接近，

.

.

.

case toNearestOrEven

舍入到最接近的允许值;如果两个值相等接近，

.

.

.

case towardZero

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

case up

四舍五入到最接近的允许值，大于或等于 源。< / p >

我们使用与@Suragch的回答非常棒中类似的例子来展示这些不同的舍入选项。

.awayFromZero

四舍五入到最接近的允许值，其大小大于或等于源的大小;C函数之间没有直接等价，因为这里分别使用self、ceil或floor作为self的正数和负数。

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

.down

等价于C floor函数。

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

.toNearestOrAwayFromZero

等价于C round函数。

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

这个舍入规则也可以使用0参数rounded()方法来访问。

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


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

.toNearestOrEven

四舍五入到最接近的允许值;如果两个值相等接近，则选择偶数;等价于C rint(/非常类似于nearbyint)函数。

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)

.towardZero

等价于C trunc函数。

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

如果舍入的目的是准备处理一个整数(例如，在舍入后通过FloatPoint初始化使用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

.up

等价于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的源代码，以验证C函数与不同的FloatingPointRoundingRule规则的等价性

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

从斯威夫特/ stdlib /公共/ / FloatingPoint.swift.gyb核心中，我们看到rounded(_:)方法的默认实现使我们使用了变化的round(_:)方法:

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

在斯威夫特/ stdlib /公共/ / FloatingPointTypes.swift.gyb核心中，我们发现了round(_:)的默认实现，其中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)
}
}
小开

你也可以扩展FloatingPoint在Swift 3如下:

extension FloatingPoint {
func rounded(to n: Int) -> Self {
let n = Self(n)
return (self / n).rounded() * n


}
}


324.0.rounded(to: 5)   // 325
小开
< p >迅速3: 如果您想四舍五入到某个数字，例如5.678434 -> 5.68，您可以将round()或roundf()函数与乘法组合:

let value:Float = 5.678434
let roundedValue = roundf(value * 100) / 100
print(roundedValue) //5.68
小开 
**In Swift**


var a = 14.123456789
var b = 14.123456789
var c = 14.123456789
var d = 14.123456789
var e = 14.123456789
var f = 14.123456789


a.rounded(.up)                      //15
b.rounded(.down)                    //14
c.rounded(.awayFromZero)            //15
d.rounded(.towardZero)              //14
e.rounded(.toNearestOrAwayFromZero) //14
f.rounded(.toNearestOrEven)         //14
小开

一个非常简单的解决方案对我很有效:

  if (62 % 50 != 0) {
var number = 62 / 50 + 1 // adding 1 is doing the actual "round up"
}

数量包含值2

小开

这是我想到的最简单的方法

let weightValue = 143.69
print("Rounded off weight value = \(Int(weightValue))")

替代方法:

print("Rounded off weight value = \((String(format: "%.0f", sender.value)))")

提交答案