Aby zaokrąglić dublet do najbliższej liczby całkowitej, wystarczy użyć round().

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

Jeśli nie chcesz modyfikować oryginalnej wartości, użyj rounded():

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

Jak można się spodziewać ( lub nie ), liczba taka jak 3.5 jest zaokrąglana w górę, a liczba taka jak -3.5 jest zaokrąglana w dół. Jeśli potrzebujesz innego zachowania zaokrąglania niż to, możesz użyć jednej z reguł zaokrąglania . Na przykład:

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

Jeśli potrzebujesz prawdziwego {[8] } to po prostu rzuć go do jednego:

let myInt = Int(myDouble.rounded())

Uwagi

• ta odpowiedź jest całkowicie przepisana. Moja stara odpowiedź dotyczyła funkcji matematycznych C takich jak round, lround, floor, i ceil. Jednak teraz, gdy Swift ma wbudowaną tę funkcjonalność, nie mogę już zalecać korzystania z tych funkcji. Dzięki @dfri za wskazanie mi tego. Sprawdź @dfri doskonałą odpowiedź tutaj . Zrobiłem też coś podobnego dla zaokrąglenia a CGFloat.

Swift 3 & 4 - wykorzystanie metody rounded(_:) jako wzorca protokołu FloatingPoint

The FloatingPoint protokół (do którego np. Double i Float odpowiada) rounded(_:) metoda

func rounded(_ rule: FloatingPointRoundingRule) -> Self

Gdzie FloatingPointRoundingRule jest enumem wyliczającym szereg różnych reguł zaokrąglania:

case awayFromZero

Zaokrąglenie do najbliższej dozwolonej wartości, której wielkość jest większa niż lub równym źródło.

case down

Zaokrąglenie do najbliższej dozwolonej wartości, która jest mniejsza lub równa źródło.

case toNearestOrAwayFromZero

Zaokrąglić do najbliższej dozwolonej wartości; jeśli dwie wartości są jednakowo bliskie, wybierany jest ten o większej wielkości.

case toNearestOrEven

Zaokrąglić do najbliższej dozwolonej wartości; jeśli dwie wartości są jednakowo bliskie, wybierany jest parzysty.

case towardZero

Zaokrąglenie do najbliższej dozwolonej wartości, której wielkość jest mniejsza lub równym źródłu.

case up

Zaokrąglenie do najbliższej dozwolonej wartości, która jest większa lub równa źródło.

Używamy podobnych przykładów do tych z @suragch ' s excellent answer aby pokazać te różne opcje zaokrąglania w praktyce.

.awayFromZero

Zaokrąglenie do najbliższej dozwolonej wartości, której wielkość jest większe lub równe źródłu; nie ma bezpośredniego odpowiednika między funkcjami C, jak to ma zastosowanie, warunkowo na znak self, ceil lub floor, odpowiednio dla wartości dodatnich i ujemnych 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

Odpowiednik funkcji 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

Odpowiednik funkcji 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

Ta reguła zaokrąglania może być również dostępna za pomocą argumentu zerowego rounded() metoda .

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

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

.toNearestOrEven

Zaokrąglić do najbliższej dozwolonej wartości; jeśli dwie wartości są jednakowo bliskie, wybierana jest parzysta; odpowiednik funkcji C rint (/bardzo podobny do funkcji 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) // 4.0

.towardZero

Odpowiednik funkcji 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

Jeśli celem zaokrąglenia jest przygotowanie do pracy z liczbą całkowitą( np. użycie Int przez FloatPoint inicjalizacji po zaokrągleniu), możemy po prostu skorzystać z faktu, że podczas inicjalizacji an Int używając Double (lub Float itd), część dziesiętna zostanie skrócona.

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

Odpowiednik funkcji 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

Dodatek: przeglądanie kodu źródłowego dla FloatingPoint w celu sprawdzenia równoważności funkcji C z różnymi regułami FloatingPointRoundingRule

Jeśli chcemy, możemy spojrzeć na kod źródłowy protokołu FloatingPoint, aby bezpośrednio zobaczyć odpowiedniki funkcji C do publicznych reguł FloatingPointRoundingRule.

Od swift/stdlib/public/core / FloatingPoint.swift.gyb widzimy, że domyślna implementacja metody rounded(_:) czyni nas metodą mutacji round(_:):

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

From swift/stdlib/public/core/FloatingPointTypes.swift.gyb znajdujemy domyślną implementację round(_:), w której równoważność między regułamiFloatingPointRoundingRule a funkcjami zaokrąglania C jest pozorna:

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

Swift 3: 5.678434 - > 5.68 można po prostu połączyć funkcję round() lub roundf () z mnożeniem:

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

Swift 3

Var myNum = 8.09

MyNum.rounded () / / wynik = 8, który jest przechowywany w myNum

Możesz również rozszerzyć FloatingPoint w Swift 3 w następujący sposób:

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

    }
}

324.0.rounded(to: 5)   // 325

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