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

395

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

Leighton
fuente
1
Véase mi respuesta para encontrar hasta 9 maneras diferentes para redondear un doble uso de Darwin round(_:), Double round(), NSStringinicializador, Stringinicializador, NumberFormatter, extensión doble o incluso NSDecimalNumbere Decimal.
Imanou Petit
@Rounded, una rápida envoltura de propiedades 5.1: gist.github.com/abhijithpp/1cc41b41a5d1c8f007da90f20bc0c65f
Abhijith

Respuestas:

389

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

zisoft
fuente
Por alguna razón no ayuda ... Estoy usando esto en el siguiente caso TransformOf <Double, String> (fromJSON: {Double (round (($ 0! As NSString) .doubleValue * 100) / 100)}, toJSON: {"($ 0)"})
Fawkes
29
No me funciona en el patio de juegos: let rate = 9.94999999999; Double(round(rate * 100) / 100);Salida: 9.94999999999, 9.949999999999999solo funciona para imprimir, pero ¿cómo puedo asignarlo a variable?
Alexander Yakovlev
Debería usar Decimal para esto, no dobles simples.
csotiriou
13
"Lo que todo informático debe saber sobre la aritmética de coma flotante" tiene 73 páginas. ¿Cuál es el TL; DR en eso? :)
JaredH
1
@HardikDG No recuerdo, lo siento :-)
Alexander Yakovlev
431

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
Sebastian
fuente
17
La naturaleza del doble de Swift parece ser que puede ser impreciso, debido a la forma en que se almacena / accede en binario, incluso el uso de esta función de redondeo no devolverá un número redondeado a 3 decimales: por ejemplo, round(8.46 * pow(10.0, 3.0)) / pow(10.0, 3.0)retornos 8.460000000000001. Hacer lo mismo con Float, al menos en este escenario , de hecho parece funcionar: round(Float(8.46) * pow(10.0, 3.0)) / pow(10.0, 3.0)rendimientos 8.46. Solo algo digno de mención.
Ben Saufley
2
Desafortunadamente, esto ya no funciona en Swift 3, recibo este errorNo '*' candidates produce the expected contextual result type 'FloatingPointRoundingRule'
koen
2
Actualicé la solución y agregué una extensión para Swift 3.
Sebastian
2
Para ser más rápido 3 ... debe cambiar por funciones redondeadas (a lugares de lugares: Int) -> Doble
FouZ
2
@BenSaufley Pero tampoco funciona si ingresa 98.68. En este caso, obtengo 98.6800003
Alexander Khitev
340

¿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))
vacawama
fuente
24
Eso es truncamiento, no redondeo
Eyeball
33
@Eyeball: En realidad, sí ronda. Es el mismo comportamiento que la funcionalidad C printf, que se redondea a los dígitos solicitados. Así String(format: "%.3f", 1.23489)imprime1.235
zisoft
66
El póster original está buscando un valor numérico para usar, no una cadena para mostrar.
pr1001
17
@ pr1001, tal vez, pero eso no estaba claro en ese momento y otros 46 han encontrado útil mi respuesta. Stack Overflow es más que solo ayudar al OP.
vacawama
3
extraño, esto devuelve 0.00 cada vez.
Eric H
254

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")
Imanou Petit
fuente
1
Gran respuesta. Podría sugerir en el n. ° 5 que podría considerar usar Decimal, que es un puente gratuito NSDecimalNumber. Decimales tipo y ofertas nativa de Swift más elegante apoyo a los operadores nativos como +, -, etc.
Rob
@Rob He actualizado mi respuesta con la NSDecimalRound(_:_:_:_:)función. Gracias.
Imanou Petit
El uso de la opción n. ° 9 garantizará que esperará la fracción fija (número de dígitos de precisión), digamos el número decimal 43.12345 y la fracción = 6, obtendrá 43.123450
Almas Adilbek
1
@ImanouPetit Gracias por publicar esto. Puedo bombardear un par de extensiones.
Adrian
Estoy triste NumberFormatteres la última opción, aunque debería ser la primera para presentar números a los usuarios. Ningún otro método genera números adecuadamente localizados.
Sulthan
93

En Swift 2.0 y Xcode 7.2:

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

Ejemplo:

ingrese la descripción de la imagen aquí

Claudio Guirunas
fuente
50

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

Krunal Patel
fuente
1
una línea ?, parece 3 líneas;)
Petter Friberg
no puedes calcular cosas usando cadenas, no creo que sea una respuesta correcta porque es solo para mostrar.
JBarros35
25

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
}
Ceniza
fuente
20

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
jaiswal Rajan
fuente
19

Swift 4, Xcode 10

yourLabel.text =  String(format:"%.2f", yourDecimalValue)
Naishta
fuente
1
No voté en contra, pero creo que la razón podría ser porque esto está devolviendo una representación de cadena de un número, no el número. Lo cual está bien si eso es todo lo que necesita, pero es posible que desee redondear el número para su uso posterior. El OP dijo "cuando imprimo", así que creo que esta es una solución aceptable, fácil y limpia en este caso.
Ben Stahl
1
Perfecto. Solución de una línea. Solo necesitaba mostrar valores decimales como cadenas en mis etiquetas.
zeeshan
18

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

Ramazan Karami
fuente
14

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

George Filippakos
fuente
9

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
Marco Leong
fuente
9

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)
}
Robar
fuente
2
La mejor respuesta hasta ahora.
Codetard
(4.81).roundedDecimal(to: 2, mode: .down)devolverá 4.8 en lugar de 4.81, Decimal(string: self.description)!decimalValue
úselo
1
@ vk.edward.li: Sí, se debe tener cuidado al redondear decimales hacia arriba / abajo, porque valores como 4.81 simplemente no se pueden representar con precisión con Double(se convierte 4.8099999999999996). Pero aconsejaría no usar description(ya que el redondeo que emplea no está documentado y está sujeto a cambios). Si realmente quieres estar haciendo cálculos con precisión decimal, debes evitarlos por Doublecompleto y en su lugar debes usarlos Decimaldirectamente (por ejemplo, Decimal(sign: .plus, exponent: -2, significand: 481)o Decimal(string: "4.81"). Pero no los uses description.)
Rob
@Rob generalmente es imposible obtener el valor de cadena de "4.81" si se almacena como Doble, por lo que debe usar self.description (un algoritmo Grisu2 modificado) para corregir la precisión que ya está perdida
vk.edward.li
Entiendo tu punto. Simplemente no estoy de acuerdo con tu solución. El comportamiento de redondeo del descriptionmétodo no está documentado ni garantizado. Además, no está localizado. En mi humilde opinión, es un error utilizar descriptionpara cualquier otra cosa que no sea el registro. Lo usaría Decimaltodo, evitando usarlo por Doublecompleto, o simplemente usaría un modo de redondeo diferente. O, si es necesario, use su propio método localizado que use el algoritmo de estilo Grisu (pero eso parece innecesario cuando sabe cuántos decimales desea redondear). Pero evitaría confiar en este comportamiento auxiliar de description.
Rob
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.

Inkidu616
fuente
1
Una nota rápida de que cualquier formateador es bastante costoso programáticamente, lo que lo desaconseja para las tareas que deben realizarse de forma rápida o repetitiva.
Jonathan Thornton el
7

yo usaría

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

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

Mohsen Hossein pour
fuente
Quería imprimir con 3 dígitos, no obtenerlo en NSTimeInterval
Mohsen Hossein pour
7

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
          }
      }
staticVoidMan
fuente
6

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
Nikita Ivaniushchenko
fuente
6

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
Abuzar Manzoor
fuente
6

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
Ayman Badr
fuente
¿Qué está pasando en este código? ¿Qué demuestran los tres ejemplos?
rene
Las respuestas de solo código no son útiles, intente explicar qué hace cada uno de estos ejemplos.
Moe
5

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

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

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

}
Matiu Awaiti
fuente
2

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
TOUZENE Mohamed Wassim
fuente
Esta es una implementación ordenada de representarlo como una cadena. Me pregunto si es posible o racional escribir una extensión de la representación del número de dígitos después del período, manteniéndolo como Doble.
thinkwift
2

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

Yervand Saribekyan
fuente
1

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


}
Hombre Montaña
fuente
1
//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"
Davender Verma
fuente
1
extension String{
  var roundedValue:String {
     return String(format: "%.3f", self)
}}

Uso:

totalWorkTimeInHours.roundedValue
Bhargav Sejpal
fuente
1

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))
    }
}
FrankByte.com
fuente