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

double nstimeinterval

Question

¿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 totalWorkTime siendo 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 ?

Answer 1

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

Para redondear totalWorkTimeInHours a 3 dígitos para imprimir, use el constructor de String que toma una cadena de format :

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

Answer 2

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, la round se 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

Answer 3

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

Answer 4

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
}

Answer 5

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

# 1 Usando el método FloatingPoint rounded()

En el caso más simple, puede usar el método 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 Uso del método rounded(_:) 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 Usando la función round Darwin

Foundation ofrece una función round 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 método personalizado de Double extensión creado con las funciones de pow y pow

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

Si es necesario, NSDecimalNumber ofrece 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. Uso de la función 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. Usando NSString init(format:arguments:) inicializador

Si desea devolver un NSString de su operación de redondeo, usar el inicializador NSString 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 tipo de String de Swift se NSString clase NSString de NSString . Por lo tanto, puede usar el siguiente código para devolver una String de 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. Usando NumberFormatter

Si espera obtener una String? desde su operación de redondeo, NumberFormatter ofrece 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")

Answer 6

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

Answer 7

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.

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

Answer 8

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.

Answer 9

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

Answer 10

Este es un código completamente trabajado

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)

salida - 123

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

salida - 123.3

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

salida - 123.33

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

salida - 123.326

Answer 11

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 {
var clean: String {
return self.truncatingRemainder(dividingBy: 1) == 0 ? String(format: "%.0f", self) : String(format: "%.2f", self)
}
}

Answer 12

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.

case 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

Answer 13

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

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

Answer 14

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

Answer 15

Puede usar la función round de Swift para lograr esto.

Para redondear un Double con precisión de 3 dígitos, primero multiplíquelo 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

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

EDITAR:
En cuanto a los comentarios de que a veces no funciona, lea esto:

Lo que todo informático debe saber sobre la aritmética de coma flotante

Answer 16

Puedes agregar esta extensión:

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

y llámalo así:

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

Answer 17

Si desea redondear valores Double , es posible que desee utilizar Swift Decimal para no introducir ningún error que pueda surgir cuando intente matemática con estos valores redondeados. Si usa Decimal , puede representar con precisión los valores decimales de ese valor de punto flotante redondeado.

Entonces puedes hacer:

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

Luego, puede obtener el valor Decimal redondeado de la siguiente manera:

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

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 :

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

Answer 18

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

Answer 19

Ya sea:

1. Usando String(format:) :

   • Typecast Double to String con el especificador de formato %.3f y luego nuevamente a Double

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

   • O extienda Double para 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 Double para manejar lugares N-Decimales:

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

Answer 20

yo usaría

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

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

Answer 21

En Swift 2.0 y Xcode 7.2:

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

Ejemplo:

Answer 22

En Swift 3.0 y Xcode 8.0:

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

Use esta extensión así,

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

Answer 23

Swift 4, Xcode 10

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

Answer 24

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

Answer 25

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

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

let formatter = NumberFormatter()
formatter.maximumFractionDigits = 2
formatter.minimumFractionDigits = 2
if let string = formatter.string(for: value) {
print(string)
}

Answer 26

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

Answer 27

totalWorkTimeInHours.roundedValue

Uso:

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