Округлення подвійного значення до x кількості десяткових знаків у швидкій формі

Хтось може сказати мені, як округлити подвійне значення до x кількості десяткових знаків у Свіфті?

Я маю:

var totalWorkTimeInHours = (totalWorkTime/60/60)

Маючи totalWorkTimeNSTimeInterval (подвійний) за секунду.

totalWorkTimeInHours дасть мені години, але це дає мені кількість часу в такій довгій точній кількості, наприклад, 1.543240952039 ......

Як закрутити це до, скажімо, 1.543, коли я друкую totalWorkTimeInHours?

Для цього можна скористатися roundфункцією Swift .

Щоб округнути a Doubleз 3-х цифрною точністю, спочатку помножте її на 1000, округляйте її і ділить результат округлення на 1000:

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

Окрім будь-якого виду printf(...)або String(format: ...)рішень, результат цієї операції все ще є типовим Double.

EDIT:
Щодо коментарів, які іноді не спрацьовують, будь ласка, прочитайте це:

Що повинен знати кожен програміст про арифметику з плаваючою комою

Розширення для 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
    }
}

Приклад, який повертає подвійний округлення до 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спеціального методу розширення, побудованого за допомогою Дарвіна 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:) ініціалізатора

Якщо ви хочете повернути a 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Тип Свіфта пов'язаний з NSStringкласом Foundation . Тому ви можете використовувати наступний код, щоб повернути a 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

Швидкий 4, Xcode 10

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

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

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

Тут% .3f повідомляє швидкому зробити це число округленим до 3 знаків після коми. І якщо ви хочете подвійне число, ви можете використовувати цей код:

// Рядок удвічі

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

Використовуйте вбудовану бібліотеку фонду Дарвіна

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" (округлий). Хоча це не найекономічніше рішення, я даю це тому, що в ОП згадується друк (в цьому випадку String не є небажаним) і тому, що цей клас дозволяє встановлювати кілька параметрів.

Я б користувався

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 - це перелік, який має наступні можливості

Випадки перерахування:

справа від FZZero Round до найближчого дозволеного значення, величина якого більше або дорівнює величині джерела.

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

справа до НайближчогоОстороньFromZero Round до найближчого дозволеного значення; якщо два значення однаково близькі, вибирається одне з більшою величиною.

справа доNearestOrEven Round до найближчого дозволеного значення; якщо два значення однаково близькі, вибирається рівне.

справа до Зеро до Round до найближчого дозволеного значення, величина якого менша або рівна величині джерела.

випадок " Раунд" до найближчого дозволеного значення, яке більше або рівне джерелу.

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

Щоб уникнути поплавкових недоліків, використовуйте Десяткові

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.

Передбачається, що значення вже перевірено для успішного перетворення з рядка в подвійне.

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