어떻게 하면 더블을 가장 가까운 인터로 빠르게 반올림 할 수 있을까요?

어떻게 하면 더블을 가장 가까운 인터로 빠르게 반올림 할 수 있을까요?

Double결과를 가장 가까운 Integer로 반올림하고 거기에서 다시 계산합니다.

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(다음 계산을 하기 위해) 변수가 되어 프로그램 전체에 걸쳐 변화해야 했습니다.그런 일이 일어나지 않았으면 합니다.

게 요.round에서 입수할 수 있다Foundation라이브러리(실제로 에 있지만 대부분의 시간을 직접 사용하지 않고 사용할 수 있습니다).

import Foundation

users = round(users)

놀이터에서 코드를 실행한 다음 전화하기:

print(round(users))

출력:

15.0

round() 가 되면 >= .5시간이 되면 내려가고< .5(일부러)하시면 됩니다.floor()ceil()제로올올 올올올다다

할 에는 '반올림을 해서 '반올림'을 .pow(10.0, number of places),round, 등으로 나누다.pow(10, number of places):

소수점 이하 2자리 반올림:

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항상 완벽하게 정확하지는 않을 수도 있습니다.반올림에 가깝다고 생각하는 것이 가장 좋습니다.표시 목적으로 이 작업을 수행하는 경우 숫자를 반올림하는 데 산술적인 방법보다 문자열 형식을 사용하여 숫자 형식을 지정하는 것이 좋습니다.

배수를 가장 가까운 정수로 반올림하려면 를 사용합니다.

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

원래 값을 변경하지 않을 경우 다음을 사용합니다.

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단, 이 더 않을 에만).Int.max

let myInt = Int(myDouble.rounded())

메모들

• 이 답변은 완전히 수정되었습니다.를 다뤘습니다.round,lround,floor , , , , 입니다.ceil다만, Swift에 이 기능이 내장되어 있기 때문에, 그 기능을 사용하는 것을 추천할 수 없게 되었습니다.@dfri 님의 지적에 감사드립니다.여기서 @dfri의 훌륭한 답변을 확인하십시오.반올림도 비슷한 작업을 했습니다.

Swift 3 & 4 - 를 사용하여rounded(_:)에서 설명되고 있는 방법FloatingPoint프로토콜

프로토콜(예: 프로토콜).Double그리고.Float적합) 메서드의 설계도

func rounded(_ rule: FloatingPointRoundingRule) -> Self

여기서 은 다양한 반올림 규칙을 열거한 것입니다.

case awayFromZero

크기가 소스 크기보다 크거나 같은 가장 가까운 허용 값으로 반올림합니다.

case down

소스와 같거나 작은 허용치에 가장 가까운 값으로 반올림합니다.

case toNearestOrAwayFromZero

가장 가까운 허용 값으로 반올림합니다. 두 값이 동등하게 가까울 경우 크기가 더 큰 값이 선택됩니다.

case toNearestOrEven

가장 가까운 허용값으로 반올림합니다.두 값이 동등하게 가까운 경우 짝수가 선택됩니다.

case towardZero

크기가 소스 크기 이하인 가장 가까운 허용 값으로 반올림합니다.

case up

송신원보다 크거나 같은 가장 가까운 허용치로 반올림합니다.

@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

이 반올림 규칙은 제로 인수 방식을 사용하여 액세스할 수도 있습니다.

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

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

.toNearestOrEven

으로 반올림합니다.두 값이선택됩니다.C 가 가 、 C 가 ent 、 C 가 、 C 가 ent ent 。 와 c c c c c c c c crint)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

를 들어, 「반올림」을 사용)를 사용하는 .Int타타에 FloatPointrounding)은 '반올림 후 초기화'를 할 때 할 수 .Int, 「」의Double (오류)Floatetc.etc)는 소수점 이하입니다.

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 하는 C FloatingPointRoundingRulediscloss.discloses.

swift/stdlib/public/core/Floating Point.swift.gyb에서 디폴트 구현이 확인되었습니다.rounded(_:).round(_:)★★★★

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

swift/stdlib/public/core/Floating PointTypes.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)
    }
}

**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

Swift 3: 5.68434 -> 5.68과 같은 특정 숫자로 반올림하려면 round() 또는 roundf() 함수를 곱셈과 결합하면 됩니다.

let value:Float = 5.678434
let roundedValue = roundf(value * 100) / 100
print(roundedValue) //5.68

다음과 같이 Swift 3에서 Floating Point를 확장할 수도 있습니다.

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

    }
}

324.0.rounded(to: 5)   // 325

스위프트 3

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

매우 간단한 솔루션이 효과가 있었습니다.

  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)))")

언급URL : https://stackoverflow.com/questions/26350977/how-to-round-a-double-to-the-nearest-int-in-swift