Arredondando um valor duplo para um número x de casas decimais rapidamente

Alguém pode me dizer como arredondar um valor duplo para um número x de casas decimais no Swift?

Eu tenho:

var totalWorkTimeInHours = (totalWorkTime/60/60)

Com totalWorkTimesendo um NSTimeInterval (duas vezes) na segunda.

totalWorkTimeInHours vai me dar as horas, mas me dá a quantidade de tempo em um número tão longo e preciso, por exemplo, 1,543240952039 ......

Como arredondar isso para, digamos, 1,543 quando imprimo totalWorkTimeInHours?

Você pode usar a roundfunção do Swift para fazer isso.

Para arredondar a Doublecom precisão de 3 dígitos, multiplique-o primeiro por 1000, arredonde-o e divida o resultado arredondado por 1000:

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

Além de qualquer tipo printf(...)ou String(format: ...)solução, o resultado dessa operação ainda é do tipo Double.

EDIT:
Quanto aos comentários que às vezes não funcionam, leia o seguinte:

O que todo programador deve saber sobre aritmética de ponto flutuante

Extensão para Swift 2

Uma solução mais geral é a seguinte extensão, que funciona com o Swift 2 e 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
    }
}

Extensão para Swift 3

No Swift 3 roundé substituído por 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
    }
}

Exemplo que retorna Double arredondado para 4 casas decimais:

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

Como arredondar isso para, digamos, 1,543 quando imprimo totalWorkTimeInHours ?

Para arredondar totalWorkTimeInHourspara 3 dígitos para impressão, use o Stringconstrutor que usa uma formatstring:

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

Com o Swift 5, de acordo com suas necessidades, você pode escolher um dos 9 estilos a seguir para obter um resultado arredondado de a Double.

# 1 Usando o FloatingPoint rounded()método

No caso mais simples, você pode usar o Double rounded()método

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 Usando o FloatingPoint rounded(_:)método

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 Usando a roundfunção Darwin

A Fundação oferece uma roundfunção via Darwin.

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 Usando um Doublemétodo personalizado de extensão criado com Darwin rounde powfunções

Se você deseja repetir a operação anterior várias vezes, refatorar seu código pode ser uma boa idéia.

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 Usando o NSDecimalNumber rounding(accordingToBehavior:)método

Se necessário, NSDecimalNumberoferece uma solução detalhada, porém poderosa, para arredondar números decimais.

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 Usando a NSDecimalRound(_:_:_:_:)função

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 Usando NSString init(format:arguments:)inicializador

Se você deseja retornar um NSStringde sua operação de arredondamento, usar o NSStringinicializador é uma solução simples, mas eficiente.

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 Usando String init(format:_:)inicializador

O Stringtipo de Swift está em ponte com a NSStringclasse da Foundation . Portanto, você pode usar o seguinte código para retornar a Stringda sua operação de arredondamento:

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 UsandoNumberFormatter

Se você espera obter uma String?da sua operação de arredondamento, NumberFormatteroferece uma solução altamente personalizável.

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

No Swift 2.0 e no Xcode 7.2:

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

Exemplo:

Este é um código totalmente trabalhado

Swift 3.0 / 4.0 / 5.0, Xcode 9.0 GM / 9.2 e superior

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

saída - 123

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

saída - 123,3

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

saída - 123.33

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

saída - 123.326

Com base na resposta de Yogi, aqui está uma função Swift que faz o trabalho:

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

No Swift 3.0 e no Xcode 8.0:

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

Use esta extensão da seguinte forma:

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)

O código para dígitos específicos após decimais é:

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

Aqui o% .3f informa rapidamente que o número é arredondado para três casas decimais. Se você quiser um número duplo, use este código:

// String para Double

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

Use a biblioteca Foundation Darwin incorporada

SWIFT 3

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

Uso:

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

Saídas: 12.988

Uma maneira prática pode ser o uso da extensão do tipo Double

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

Uso:

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

Se você deseja arredondar Doublevalores, use o Swift Decimalpara não introduzir erros que possam surgir ao tentar fazer a matemática com esses valores arredondados. Se você usar Decimal, ele pode representar com precisão os valores decimais desse valor arredondado de ponto flutuante.

Então você pode fazer:

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

Em seguida, você pode obter o Decimalvalor arredondado da seguinte maneira:

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

E se você deseja exibi-lo com um número especificado de casas decimais (além de localizar a sequência do código de idioma atual do usuário), você pode usar um NumberFormatter:

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

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

Essa é uma espécie de solução alternativa longa, que pode ser útil se suas necessidades forem um pouco mais complexas. Você pode usar um formatador de números no Swift.

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

Suponha que sua variável que você deseja imprimir seja

var printVar = 3.567

Isso garantirá que ele seja retornado no formato desejado:

numberFormatter.StringFromNumber(printVar)

O resultado aqui será, portanto, "3,6" (arredondado). Embora essa não seja a solução mais econômica, eu a dou porque o OP mencionou a impressão (nesse caso, uma String não é indesejável) e porque essa classe permite que vários parâmetros sejam definidos.

eu usaria

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

e altere 0,3f para qualquer número decimal que você precisar

Ou:

1. Usando String(format:):

   • Escreva Doublecomo Stringcom %.3fespecificador de formato e, em seguida, volte paraDouble

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

   • Ou estenda Doublepara lidar com locais N-Decimais:

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

2. Por cálculo

   • multiplique por 10 ^ 3, arredonde-o e divida-o por 10 ^ 3 ...

     (1000 * 10.123546789).rounded()/1000

   • Ou estenda Doublepara lidar com locais N-Decimais:

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

Este é um algoritmo mais flexível de arredondamento para N dígitos significativos

Solução 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

A melhor maneira de formatar uma propriedade dupla é usar os métodos predefinidos da Apple.

mutating func round(_ rule: FloatingPointRoundingRule)

FloatingPointRoundingRule é uma enumeração que possui as seguintes possibilidades

Casos de enumeração:

case awayFromZero Arredonde para o valor permitido mais próximo, cuja magnitude é maior ou igual à da fonte.

case down Arredonde para o valor permitido mais próximo que seja menor ou igual à origem.

case toNearestOrAwayFromZero Arredonde para o valor permitido mais próximo; se dois valores são igualmente próximos, aquele com maior magnitude é escolhido.

case toNearestOrEven Round para o valor permitido mais próximo; se dois valores são igualmente próximos, o mesmo é escolhido.

caso Zero Round até o valor permitido mais próximo, cuja magnitude é menor ou igual à da fonte.

case up Arredonde para o valor permitido mais próximo que seja maior ou igual à fonte.

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

arredondar um valor duplo para o número x de
NO decimal . de dígitos após decimal

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

Não é Swift, mas tenho certeza de que você entendeu.

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

Isso parece funcionar no Swift 5.

Bastante surpreso, já não existe uma função padrão para isso.

// Truncamento de casas duplas em n-decimais com arredondamento

extension Double {

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

}

Você pode adicionar esta extensão:

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

e chame assim:

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

Para evitar imperfeições de flutuação, use 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
    }
}

ex.
1075,58 arredonda para 1075,57 ao usar o flutuador com escala: 2 e .down
1075,58 arredonda para 1075,58 ao usar o decimal com escala: 2 e .down

Eu achei isso perguntando se é possível corrigir a entrada de um usuário. Ou seja, se eles digitarem três casas decimais em vez de duas para um valor em dólar. Diga 1.111 em vez de 1.11, você pode corrigi-lo arredondando? A resposta por muitas razões é não! Com dinheiro acima de 0,001 acabaria por causar problemas em um talão de cheques real.

Aqui está uma função para verificar a entrada do usuário para muitos valores após o período. Mas o que permitirá 1., 1.1 e 1.11.

Supõe-se que o valor já tenha sido verificado para uma conversão bem-sucedida de uma String para uma 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)
}}

Uso:

totalWorkTimeInHours.roundedValue

Aqui está um para SwiftUI se você precisar de um elemento Text com o valor numérico.

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

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