Redondeando un valor doble a x número de decimales en swift

¿Alguien puede decirme cómo redondear un valor doble a x número de decimales en Swift?

Yo tengo:

var totalWorkTimeInHours = (totalWorkTime/60/60)

Con totalWorkTimeser un NSTimeInterval (doble) en segundo.

totalWorkTimeInHours me dará las horas, pero me da la cantidad de tiempo en un número tan largo y preciso, por ejemplo, 1.543240952039 ......

¿Cómo redondeo esto a, digamos, 1.543 cuando imprimo totalWorkTimeInHours?

Puede usar la roundfunción de Swift para lograr esto.

Para redondear una Doubleprecisión de 3 dígitos, primero multiplíquela por 1000, redondee y divida el resultado redondeado por 1000:

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

Aparte de cualquier tipo de printf(...)o String(format: ...)soluciones, el resultado de esta operación sigue siendo de tipo Double.

EDITAR: con
respecto a los comentarios que a veces no funciona, lea esto:

Lo que todo programador debe saber sobre la aritmética de coma flotante

Extensión para Swift 2

Una solución más general es la siguiente extensión, que funciona con Swift 2 y 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
    }
}

Extensión para Swift 3

En Swift 3 roundse reemplaza 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
    }
}

Ejemplo que devuelve Doble redondeado a 4 decimales:

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

¿Cómo redondeo esto a, digamos, 1.543 cuando imprimo totalWorkTimeInHours?

Para redondear totalWorkTimeInHoursa 3 dígitos para imprimir, use el Stringconstructor que toma una formatcadena:

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

Con Swift 5, según sus necesidades, puede elegir uno de los 9 estilos siguientes para obtener un resultado redondeado de a Double.

# 1 UtilizandoFloatingPoint rounded() método

En el caso más simple, puede usar el 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 Utilizando el 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 Darwinround función

Foundation ofrece una roundfunción a través de 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 un Doublemétodo personalizado de extensión construido con Darwin roundy powfunciones

Si desea repetir la operación anterior muchas veces, refactorizar su código puede ser una buena idea.

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. Utilizando el NSDecimalNumber rounding(accordingToBehavior:)método

Si es necesario, NSDecimalNumberofrece una solución detallada pero poderosa para redondear números decimales.

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 la NSDecimalRound(_:_:_:_:)función

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

Si desea devolver un a NSStringpartir de su operación de redondeo, el uso de NSStringinitializer es una solución simple pero 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

El Stringtipo de Swift se une con la NSStringclase de Foundation . Por lo tanto, puede usar el siguiente código para devolver un Stringde su operación de redondeo:

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. UtilizandoNumberFormatter

Si espera obtener un resultado String?de su operación de redondeo, NumberFormatterofrece una solución altamente personalizable.

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

En Swift 2.0 y Xcode 7.2:

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

Ejemplo:

Este es un código completamente trabajado

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

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

salida - 123

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

salida - 123.3

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

salida - 123.33

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

salida - 123.326

Basándose en la respuesta de Yogi, aquí hay una función Swift que hace el trabajo:

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

En Swift 3.0 y Xcode 8.0:

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

Use esta extensión así:

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)

El código para dígitos específicos después de decimales es:

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

Aquí el% .3f le dice a swift que redondee este número a 3 decimales. Y si desea un número doble, puede usar este código:

// String to Double

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

Utilice la biblioteca integrada de 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
    }
}

Uso:

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

Salidas: 12.988

Una manera práctica puede ser el uso de la extensión de tipo Doble

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

Si desea redondear los Doublevalores, es posible que desee utilizar Swift Decimalpara no introducir ningún error que pueda surgir al intentar hacer cálculos matemáticos con estos valores redondeados. Si lo usa Decimal, puede representar con precisión los valores decimales de ese valor de punto flotante redondeado.

Entonces puedes hacer:

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

Luego, puede obtener el Decimalvalor redondeado de esta manera:

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

Y si desea mostrarlo con un número específico de lugares decimales (así como localizar la cadena para la configuración regional actual del usuario), puede usar un NumberFormatter:

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

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

Esta es una especie de solución temporal larga, que puede ser útil si sus necesidades son un poco más complejas. Puede usar un formateador de números en Swift.

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

Suponga que su variable que desea imprimir es

var printVar = 3.567

Esto asegurará que se devuelva en el formato deseado:

numberFormatter.StringFromNumber(printVar)

El resultado aquí será "3.6" (redondeado). Si bien esta no es la solución más económica, la doy porque el OP mencionó la impresión (en cuyo caso, una Cadena no es indeseable), y porque esta clase permite establecer múltiples parámetros.

yo usaría

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

y cambie .3f a cualquier número de números decimales que necesite

Ya sea:

1. Utilizando String(format:):

   • Escribir Doublea máquina Stringcon %.3fespecificador de formato y luego volver aDouble

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

   • O extienda Doublepara manejar lugares N-Decimales:

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

2. Por cálculo

   • multiplica con 10 ^ 3, redondea y luego divide por 10 ^ 3 ...

     (1000 * 10.123546789).rounded()/1000

   • O extienda Doublepara manejar lugares N-Decimales:

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

Este es un algoritmo más flexible de redondeo a N dígitos significativos

Solució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

La mejor manera de formatear una propiedad doble es utilizar los métodos predefinidos de Apple.

mutating func round(_ rule: FloatingPointRoundingRule)

FloatingPointRoundingRule es una enumeración que tiene las siguientes posibilidades

Casos de enumeración:

case awayFromZero Redondea al valor permitido más cercano cuya magnitud es mayor o igual que la de la fuente.

caso abajo Redondear al valor permitido más cercano que sea menor o igual que la fuente.

case toNearestOrAwayFromZero Round al valor permitido más cercano; Si dos valores son igualmente cercanos, se elige el de mayor magnitud.

caso toNearestOrEven Round al valor permitido más cercano; Si dos valores son igualmente cercanos, se elige el par.

caso hacia cero Redondea al valor permitido más cercano cuya magnitud es menor o igual que la de la fuente.

caso arriba Redondea al valor permitido más cercano que sea mayor o igual que la fuente.

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

redondea un valor doble a x número de
NO decimal . de dígitos después del 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

No Swift, pero estoy seguro de que tienes la idea.

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

Esto parece funcionar en Swift 5.

Bastante sorprendido ya no hay una función estándar para esto.

// Truncamiento de dobles a n-decimales con redondeo

extension Double {

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

}

Puedes agregar esta extensión:

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

y llámalo así:

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

Para evitar imperfecciones de flotación, 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 se redondea a 1075.57 cuando se usa Float con escala: 2 y .down
1075.58 se redondea a 1075.58 cuando se usa Decimal con escala: 2 y .down

Encontré esto preguntándome si es posible corregir la entrada de un usuario. Es decir, si ingresan tres decimales en lugar de dos por un monto en dólares. Digamos 1.111 en lugar de 1.11, ¿puedes arreglarlo redondeando? ¡La respuesta por muchas razones es no! Con dinero por encima de 0.001 eventualmente causaría problemas en una chequera real.

Aquí hay una función para verificar la entrada de los usuarios para demasiados valores después del período. Pero lo que permitirá 1., 1.1 y 1.11.

Se supone que el valor ya se ha verificado para una conversión exitosa de una Cadena a una Doble.

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

Aquí hay uno para SwiftUI si necesita un elemento de texto con el valor numérico.

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

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