Как округлить двойной до ближайшего Int в swift?

Я пытаюсь сделать калькулятор темпов роста (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

}


но я был не в состоянии до сих пор.



EDIT
Я вроде как сделал это так:



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 должен был стать переменной и изменяться на протяжении всей программы (для того, чтобы сделать следующий расчет), который я не хочу, чтобы это произошло.

705   7  

7 ответов:

есть round доступны Foundation библиотека (это на самом деле в Darwin, а Foundation импорт Darwin и большую часть времени вы хотите использовать Foundation вместо Darwin напрямую).

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 не всегда быть совершенно точным. Лучше всего думать об этом больше как о приближении округления. Если вы делаете это для отображения, лучше использовать форматирование строк для форматирования числа, а не использовать математику для его округления.

181  
2018-09-24 09:11:02

чтобы округлить двойник до ближайшего целого числа, просто используйте 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 тогда просто бросьте его в один:

let myInt = Int(myDouble.rounded())

Примечания

  • этот ответ полностью переписан. Мой старый ответ касался математических функций C, таких как round,lround,floor и ceil. Однако теперь, когда Swift имеет эту встроенную функциональность, я больше не могу рекомендовать использовать эти функции. Спасибо @dfri за то, что указал мне на это. Проверьте @ dfri отличный ответ здесь. Я также сделал что-то подобное для округление a CGFloat.
112  
2017-05-23 13:31:15

Swift 3 & 4-Использование rounded(_:) метод как blueprinted в FloatingPoint протокол

The FloatingPoint протокол (к которым, например,Double и Float соответствует) чертежи rounded(_:) метод

func rounded(_ rule: FloatingPointRoundingRule) -> Self

здесь FloatingPointRoundingRule - это перечисление, перечисляющее ряд различных правил округления:

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 .

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 для публики FloatingPointRoundingRule правила.

от swift/stdlib/public/core / FloatingPoint.быстрый.гыбь мы видим, что реализация по умолчанию rounded(_:) метод делает нас мутирующими round(_:) способ:

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

с swift/stdlib/public/core / FloatingPointTypes.быстрый.гыбь мы находим реализацию по умолчанию 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)
    }
}
54  
2018-08-16 14:53:13

Swift 3: Если вы хотите округлить до определенного числа цифр, например, 5.678434 - > 5.68, вы можете просто объединить функцию round() или roundf () с умножением:

    let value:Float = 5.678434
    let roundedValue = roundf(value * 100) / 100
    print(roundedValue) //5.68
4  
2017-09-21 03:43:29

Swift 3

var myNum = 8.09

myNum.округленный () //результат = 8, который хранится в myNum

1  
2016-12-29 17:43:43

вы также можете расширить FloatingPoint в Swift 3 следующим образом:

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

    }
}

324.0.rounded(to: 5)   // 325
1  
2017-01-14 04:34:31 
**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
1  
2018-09-26 08:15:20

Comments

    Ничего не найдено.
Click here to cancel reply.