Округление двойного значения до x количества знаков после запятой в быстром

Может кто-нибудь сказать мне, как округлить двойное значение до х числа десятичных знаков в Swift?

Я имею:

var totalWorkTimeInHours = (totalWorkTime/60/60)

С totalWorkTimeNSTimeInterval (двойной) в секунду.

totalWorkTimeInHours даст мне часы, но это даст мне количество времени в таком длинном точном числе, например 1.543240952039 ......

Как мне округлить до, скажем, 1.543 при печати totalWorkTimeInHours?

Вы можете использовать roundфункцию Swift для достижения этой цели.

Для округления Doubleс точностью до 3 цифр сначала умножьте его на 1000, округлите и разделите округленный результат на 1000:

let x = 1.23556789
let y = Double(round(1000*x)/1000)
print(y)  // 1.236

Помимо любого вида printf(...)или String(format: ...)решения, результат этой операции все еще имеет тип Double.

РЕДАКТИРОВАТЬ:
Что касается комментариев, которые иногда не работают, пожалуйста, прочитайте это:

Что каждый программист должен знать об арифметике с плавающей точкой

Удлинитель для Swift 2

Более общим решением является следующее расширение, которое работает с Swift 2 и iOS 9:

extension Double {
    /// Rounds the double to decimal places value
    func roundToPlaces(places:Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return round(self * divisor) / divisor
    }
}

Удлинитель для Swift 3

В Swift 3 roundзаменяется rounded:

extension Double {
    /// Rounds the double to decimal places value
    func rounded(toPlaces places:Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return (self * divisor).rounded() / divisor
    }
}

Пример, который возвращает Double, округленный до 4 десятичных знаков:

let x = Double(0.123456789).roundToPlaces(4)  // x becomes 0.1235 under Swift 2
let x = Double(0.123456789).rounded(toPlaces: 4)  // Swift 3 version

Как мне округлить до, скажем, 1.543 при печати totalWorkTimeInHours ?

Чтобы округлить totalWorkTimeInHoursдо 3 цифр для печати, используйте Stringконструктор, который принимает formatстроку:

print(String(format: "%.3f", totalWorkTimeInHours))

В Swift 5, в соответствии с вашими потребностями, вы можете выбрать один из 9 следующих стилей , чтобы получить округленный результат от a Double.

# 1. Используя FloatingPoint rounded()метод

В простейшем случае вы можете использовать Double rounded()метод.

let roundedValue1 = (0.6844 * 1000).rounded() / 1000
let roundedValue2 = (0.6849 * 1000).rounded() / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

# 2. Используя FloatingPoint rounded(_:)метод

let roundedValue1 = (0.6844 * 1000).rounded(.toNearestOrEven) / 1000
let roundedValue2 = (0.6849 * 1000).rounded(.toNearestOrEven) / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

# 3. Использование roundфункции Дарвина

Фонд предлагает roundфункцию через Дарвина.

import Foundation

let roundedValue1 = round(0.6844 * 1000) / 1000
let roundedValue2 = round(0.6849 * 1000) / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

# 4. Использование Doubleсобственного метода расширения, созданного с помощью Darwin roundи powфункций

Если вы хотите повторить предыдущую операцию много раз, рефакторинг вашего кода может быть хорошей идеей.

import Foundation

extension Double {
    func roundToDecimal(_ fractionDigits: Int) -> Double {
        let multiplier = pow(10, Double(fractionDigits))
        return Darwin.round(self * multiplier) / multiplier
    }
}

let roundedValue1 = 0.6844.roundToDecimal(3)
let roundedValue2 = 0.6849.roundToDecimal(3)
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

# 5. Используя NSDecimalNumber rounding(accordingToBehavior:)метод

При необходимости NSDecimalNumberпредлагает подробное, но мощное решение для округления десятичных чисел.

import Foundation

let scale: Int16 = 3

let behavior = NSDecimalNumberHandler(roundingMode: .plain, scale: scale, raiseOnExactness: false, raiseOnOverflow: false, raiseOnUnderflow: false, raiseOnDivideByZero: true)

let roundedValue1 = NSDecimalNumber(value: 0.6844).rounding(accordingToBehavior: behavior)
let roundedValue2 = NSDecimalNumber(value: 0.6849).rounding(accordingToBehavior: behavior)

print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

# 6. Используя NSDecimalRound(_:_:_:_:)функцию

import Foundation

let scale = 3

var value1 = Decimal(0.6844)
var value2 = Decimal(0.6849)

var roundedValue1 = Decimal()
var roundedValue2 = Decimal()

NSDecimalRound(&roundedValue1, &value1, scale, NSDecimalNumber.RoundingMode.plain)
NSDecimalRound(&roundedValue2, &value2, scale, NSDecimalNumber.RoundingMode.plain)

print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

# 7. Использование NSString init(format:arguments:)инициализатора

Если вы хотите получить возврат NSStringиз операции округления, использование NSStringинициализатора является простым, но эффективным решением.

import Foundation

let roundedValue1 = NSString(format: "%.3f", 0.6844)
let roundedValue2 = NSString(format: "%.3f", 0.6849)
print(roundedValue1) // prints 0.684
print(roundedValue2) // prints 0.685

# 8. Использование String init(format:_:)инициализатора

StringТип Swift соединен с NSStringклассом Foundation . Следовательно, вы можете использовать следующий код для возврата Stringиз операции округления:

import Foundation

let roundedValue1 = String(format: "%.3f", 0.6844)
let roundedValue2 = String(format: "%.3f", 0.6849)
print(roundedValue1) // prints 0.684
print(roundedValue2) // prints 0.685

# 9. С помощьюNumberFormatter

Если вы ожидаете получить String?от вашей операции округления, NumberFormatterпредлагает очень настраиваемое решение.

import Foundation

let formatter = NumberFormatter()
formatter.numberStyle = NumberFormatter.Style.decimal
formatter.roundingMode = NumberFormatter.RoundingMode.halfUp
formatter.maximumFractionDigits = 3

let roundedValue1 = formatter.string(from: 0.6844)
let roundedValue2 = formatter.string(from: 0.6849)
print(String(describing: roundedValue1)) // prints Optional("0.684")
print(String(describing: roundedValue2)) // prints Optional("0.685")

В Swift 2.0 и Xcode 7.2:

let pi: Double = 3.14159265358979
String(format:"%.2f", pi)

Пример:

Это полностью проработанный код

Swift 3.0 / 4.0 / 5.0, Xcode 9.0 GM / 9.2 и выше

let doubleValue : Double = 123.32565254455
self.lblValue.text = String(format:"%.f", doubleValue)
print(self.lblValue.text)

выход - 123

let doubleValue : Double = 123.32565254455
self.lblValue_1.text = String(format:"%.1f", doubleValue)
print(self.lblValue_1.text)

выход - 123,3

let doubleValue : Double = 123.32565254455
self.lblValue_2.text = String(format:"%.2f", doubleValue)
print(self.lblValue_2.text)

выход - 123,33

let doubleValue : Double = 123.32565254455
self.lblValue_3.text = String(format:"%.3f", doubleValue)
print(self.lblValue_3.text)

выход - 123,326

Основываясь на ответе Йога, вот функция Swift, которая делает эту работу:

func roundToPlaces(value:Double, places:Int) -> Double {
    let divisor = pow(10.0, Double(places))
    return round(value * divisor) / divisor
}

В Swift 3.0 и Xcode 8.0:

extension Double {
    func roundTo(places: Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return (self * divisor).rounded() / divisor
    }
}

Используйте это расширение так:

let doubleValue = 3.567
let roundedValue = doubleValue.roundTo(places: 2)
print(roundedValue) // prints 3.56

Swift 4, Xcode 10

yourLabel.text =  String(format:"%.2f", yourDecimalValue)

Код для конкретных цифр после десятичных знаков:

var a = 1.543240952039
var roundedString = String(format: "%.3f", a)

Здесь% .3f сообщает swift, чтобы это число было округлено до 3 десятичных знаков. И если вы хотите получить двойное число, вы можете использовать этот код:

// String to Double

var roundedString = Double(String(format: "%.3f", b))

Используйте встроенную библиотеку Foundation Darwin

SWIFT 3

extension Double {
    func round(to places: Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return Darwin.round(self * divisor) / divisor
    }
}

Применение:

let number:Double = 12.987654321
print(number.round(to: 3)) 

Выходы: 12,988

Удобным способом может быть использование расширения типа Double

extension Double {
    var roundTo2f: Double {return Double(round(100 *self)/100)  }
    var roundTo3f: Double {return Double(round(1000*self)/1000) }
}

Применение:

let regularPie:  Double = 3.14159
var smallerPie:  Double = regularPie.roundTo3f  // results 3.142
var smallestPie: Double = regularPie.roundTo2f  // results 3.14

Если вы хотите округлить Doubleзначения, вы можете использовать Swift, Decimalчтобы не допустить ошибок, которые могут возникнуть при попытке вычислить эти округленные значения. Если вы используете Decimal, он может точно представлять десятичные значения этого округленного значения с плавающей запятой.

Так что вы можете сделать:

extension Double {
    /// Convert `Double` to `Decimal`, rounding it to `scale` decimal places.
    ///
    /// - Parameters:
    ///   - scale: How many decimal places to round to. Defaults to `0`.
    ///   - mode:  The preferred rounding mode. Defaults to `.plain`.
    /// - Returns: The rounded `Decimal` value.

    func roundedDecimal(to scale: Int = 0, mode: NSDecimalNumber.RoundingMode = .plain) -> Decimal {
        var decimalValue = Decimal(self)
        var result = Decimal()
        NSDecimalRound(&result, &decimalValue, scale, mode)
        return result
    }
}

Затем вы можете получить округленное Decimalзначение следующим образом:

let foo = 427.3000000002
let value = foo.roundedDecimal(to: 2) // results in 427.30

И если вы хотите отобразить его с указанным количеством десятичных знаков (а также локализовать строку для текущей локали пользователя), вы можете использовать NumberFormatter:

let formatter = NumberFormatter()
formatter.maximumFractionDigits = 2
formatter.minimumFractionDigits = 2

if let string = formatter.string(for: value) {
    print(string)
}

Это своего рода долгий обходной путь, который может пригодиться, если ваши потребности немного сложнее. Вы можете использовать средство форматирования чисел в Swift.

let numberFormatter: NSNumberFormatter = {
    let nf = NSNumberFormatter()
    nf.numberStyle = .DecimalStyle
    nf.minimumFractionDigits = 0
    nf.maximumFractionDigits = 1
    return nf
}()

Предположим, что ваша переменная, которую вы хотите напечатать

var printVar = 3.567

Это гарантирует, что он будет возвращен в желаемом формате:

numberFormatter.StringFromNumber(printVar)

Таким образом, результатом здесь будет «3,6» (округлено). Хотя это не самое экономичное решение, я даю его, потому что OP упоминает печать (в этом случае строка не является нежелательной), и потому что этот класс позволяет устанавливать несколько параметров.

я хотел бы использовать

print(String(format: "%.3f", totalWorkTimeInHours))

и измените .3f на любое количество десятичных чисел, которое вам нужно

Или:

1. Использование String(format:):

   • Приведение Doubleк Stringс %.3fспецификатор формата , а затем обратноDouble

     Double(String(format: "%.3f", 10.123546789))!

   • Или расширить Doubleдля обработки N-десятичных разрядов:

     extension Double {
         func rounded(toDecimalPlaces n: Int) -> Double {
             return Double(String(format: "%.\(n)f", self))!
         }
     }

2. По расчету

   • умножьте на 10 ^ 3, округлите его и затем разделите на 10 ^ 3 ...

     (1000 * 10.123546789).rounded()/1000

   • Или расширить Doubleдля обработки N-десятичных разрядов:

     extension Double {    
         func rounded(toDecimalPlaces n: Int) -> Double {
             let multiplier = pow(10, Double(n))
             return (multiplier * self).rounded()/multiplier
         }
     }

Это более гибкий алгоритм округления до N значащих цифр

Swift 3 решение

extension Double {
// Rounds the double to 'places' significant digits
  func roundTo(places:Int) -> Double {
    guard self != 0.0 else {
        return 0
    }
    let divisor = pow(10.0, Double(places) - ceil(log10(fabs(self))))
    return (self * divisor).rounded() / divisor
  }
}


// Double(0.123456789).roundTo(places: 2) = 0.12
// Double(1.23456789).roundTo(places: 2) = 1.2
// Double(1234.56789).roundTo(places: 2) = 1200

Лучший способ отформатировать двойное свойство - это использовать предопределенные методы Apple.

mutating func round(_ rule: FloatingPointRoundingRule)

FloatingPointRoundingRule - это перечисление, которое имеет следующие возможности

Случаи перечисления:

case awayFromZero Округлить до ближайшего допустимого значения, величина которого больше или равна величине источника.

case down Округление до ближайшего допустимого значения, которое меньше или равно источнику.

case toNearestOrAwayFromZero Округлить до ближайшего допустимого значения; если два значения одинаково близки, выбирается значение с большей величиной.

case toNearestOrEven Округлить до ближайшего допустимого значения; если два значения одинаково близки, выбирается четное.

случай в направлении нуля. Округление до ближайшего допустимого значения, величина которого меньше или равна величине источника.

case up Округлить до ближайшего допустимого значения, которое больше или равно источнику.

var aNumber : Double = 5.2
aNumber.rounded(.up) // 6.0

округлите двойное значение до x числа десятичного числа
NO. цифр после десятичной

var x = 1.5657676754
var y = (x*10000).rounded()/10000
print(y)  // 1.5658 

var x = 1.5657676754 
var y = (x*100).rounded()/100
print(y)  // 1.57 

var x = 1.5657676754
var y = (x*10).rounded()/10
print(y)  // 1.6

Не Свифт, но я уверен, что вы поняли идею.

pow10np = pow(10,num_places);
val = round(val*pow10np) / pow10np;

Это похоже на работу в Swift 5.

Весьма удивлен, что для этого уже нет стандартной функции.

// Усечение двойных до n-десятичных разрядов с округлением

extension Double {

    func truncate(to places: Int) -> Double {
    return Double(Int((pow(10, Double(places)) * self).rounded())) / pow(10, Double(places))
    }

}

Вы можете добавить это расширение:

extension Double {
    var clean: String {
        return self.truncatingRemainder(dividingBy: 1) == 0 ? String(format: "%.0f", self) : String(format: "%.2f", self)
    }
}

и назовите это так:

let ex: Double = 10.123546789
print(ex.clean) // 10.12

Чтобы избежать недостатков Float, используйте Decimal

extension Float {
    func rounded(rule: NSDecimalNumber.RoundingMode, scale: Int) -> Float {
        var result: Decimal = 0
        var decimalSelf = NSNumber(value: self).decimalValue
        NSDecimalRound(&result, &decimalSelf, scale, rule)
        return (result as NSNumber).floatValue
    }
}

ех.
1075,58 раундов до 1075,57 при использовании Float со шкалой: 2 и .down
1075,58 раундов до 1075,58 при использовании десятичного со шкалой: 2 и .down

Я обнаружил, что это интересно, если можно исправить ввод пользователя. Это если они вводят три знака после запятой вместо двух для суммы в долларах. Скажем, 1.111 вместо 1.11, вы можете исправить это путем округления? Ответ по многим причинам - нет! Если деньги превышают 0,001, это может вызвать проблемы в реальной чековой книжке.

Вот функция для проверки ввода пользователем слишком большого количества значений после периода. Но что позволит 1., 1.1 и 1.11.

Предполагается, что значение уже проверено на успешное преобразование из String в Double.

//func need to be where transactionAmount.text is in scope

func checkDoublesForOnlyTwoDecimalsOrLess()->Bool{


    var theTransactionCharacterMinusThree: Character = "A"
    var theTransactionCharacterMinusTwo: Character = "A"
    var theTransactionCharacterMinusOne: Character = "A"

    var result = false

    var periodCharacter:Character = "."


    var myCopyString = transactionAmount.text!

    if myCopyString.containsString(".") {

         if( myCopyString.characters.count >= 3){
                        theTransactionCharacterMinusThree = myCopyString[myCopyString.endIndex.advancedBy(-3)]
         }

        if( myCopyString.characters.count >= 2){
            theTransactionCharacterMinusTwo = myCopyString[myCopyString.endIndex.advancedBy(-2)]
        }

        if( myCopyString.characters.count > 1){
            theTransactionCharacterMinusOne = myCopyString[myCopyString.endIndex.advancedBy(-1)]
        }


          if  theTransactionCharacterMinusThree  == periodCharacter {

                            result = true
          }


        if theTransactionCharacterMinusTwo == periodCharacter {

            result = true
        }



        if theTransactionCharacterMinusOne == periodCharacter {

            result = true
        }

    }else {

        //if there is no period and it is a valid double it is good          
        result = true

    }

    return result


}

//find the distance between two points
let coordinateSource = CLLocation(latitude: 30.7717625, longitude:76.5741449 )
let coordinateDestination = CLLocation(latitude: 29.9810859, longitude: 76.5663599)
let distanceInMeters = coordinateSource.distance(from: coordinateDestination)
let valueInKms = distanceInMeters/1000
let preciseValueUptoThreeDigit = Double(round(1000*valueInKms)/1000)
self.lblTotalDistance.text = "Distance is : \(preciseValueUptoThreeDigit) kms"

extension String{
  var roundedValue:String {
     return String(format: "%.3f", self)
}}

Применение :

totalWorkTimeInHours.roundedValue

Вот один из них для SwiftUI, если вам нужен элемент Text с числовым значением.

struct RoundedDigitText : View {
    let digits : Int
    let number : Double

    var body : some View {
        Text(String(format: "%.\(digits)f", number))
    }
}