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

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

У меня есть:

var totalWorkTimeInHours = (totalWorkTime/60/60)

С totalWorkTime является NSTimeInterval (double) во втором.

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

Как мне обходить это до, скажем, 1.543, когда я печатаю totalWorkTimeInHours?

ОТВЕТЫ

Ответ 1

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

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

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

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

EDIT:
Что касается комментариев, которые он иногда не работает, прочитайте следующее:

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

Ответ 2

Расширение для 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

Ответ 3

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

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

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

Ответ 4

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

# 1. Использование метода FloatingPoint rounded()

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

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 extension, созданного с использованием функций Дарвина 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. Использование rounding(accordingToBehavior:) NSDecimalNumber rounding(accordingToBehavior:) методу 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:_:) инициализатор

Тип Swifts String соединяется с классом Foundations NSString. Поэтому вы можете использовать следующий код для возврата 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, 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")

Ответ 5

В Swift 2.0 и Xcode 7.2:

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

Пример:

введите описание изображения здесь

Ответ 6

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

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

Ответ 7

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

Swift 3.0/4.0, Xcode 9.0 GM/9.2

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

выход - 123

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

выход - 123,3

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

выход - 123,33

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

выход - 123.326

Ответ 8

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

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

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

//String to Double

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

Ответ 9

В 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

Ответ 10

Swift 4, Xcode 10

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

Ответ 11

Используйте встроенную библиотеку 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

Ответ 12

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

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

Ответ 13

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

Ответ 14

Я бы использовал

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

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

Ответ 15

Или:

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

    • Typecast Double to String с %.3f формата %.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
    }
}

Ответ 16

Это более гибкий алгоритм округления до 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

Ответ 17

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

mutating func round(_ rule: FloatingPointRoundingRule)

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

Перечисления:

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

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

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

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

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

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

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

Ответ 18

Если вы хотите округлить значения 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)
}

Ответ 19

Не быстро, но я уверен, что вы поняли.

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

Ответ 20

округлить двойное значение до 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

Ответ 21

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

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

Ответ 22

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

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

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

extension Double {

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

}

Ответ 23

Мне было интересно узнать, можно ли исправить пользовательский ввод. То есть, если они вводят три десятичных знака вместо двух для суммы в долларах. Скажем, 1.111 вместо 1.11 вы можете исправить его округлением? Ответ по многим причинам нет! С деньгами все, что угодно, например, 0.001, в конечном итоге вызовет проблемы в реальной чековой книжке.

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

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


}

Ответ 24

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

Ответ 25

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

Использование:

totalWorkTimeInHours.roundedValue

Ответ 26

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

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

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

Ответ 27

Чтобы избежать недостатков 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

Ответ 28

Задача:

double d=3.0;

d/100= 0.0299999999

Мне нужно 0.03

Решение:

NSNumber *doubleNSNumber=[[NSNumber alloc] initWithDouble:d/100.0];
double roundedNumber=[doubleNSNumber doubleValue];

roundedNumber=0.03