Arrotondamento di un doppio valore a x numero di posizioni decimali in rapido

Qualcuno può dirmi come arrotondare un doppio valore al numero x di decimali in Swift?

Io ho:

var totalWorkTimeInHours = (totalWorkTime/60/60)

Con l' totalWorkTimeessere un NSTimeInterval (doppio) al secondo.

totalWorkTimeInHours mi darà le ore, ma mi dà la quantità di tempo in un numero così lungo preciso es. 1.543240952039 ......

Come posso arrotondare questo, per esempio, a 1.543 quando stampo totalWorkTimeInHours?

È possibile utilizzare la roundfunzione di Swift per ottenere questo risultato.

Per arrotondare un Doublecon precisione a 3 cifre, prima moltiplicalo per 1000, arrotondalo e dividi il risultato arrotondato per 1000:

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

A parte qualsiasi tipo di printf(...)o String(format: ...)soluzioni, il risultato di questa operazione è ancora di tipo Double.

EDIT: per
quanto riguarda i commenti che a volte non funziona, leggi questo:

Ciò che ogni programmatore dovrebbe sapere sull'aritmetica in virgola mobile

Estensione per Swift 2

Una soluzione più generale è la seguente estensione, che funziona con 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
    }
}

Estensione per Swift 3

In Swift 3 roundè sostituito da 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
    }
}

Esempio che restituisce Double arrotondato al 4 decimale:

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

Come posso arrotondare questo, per esempio, 1.543 quando stampo totalWorkTimeInHours?

Per arrotondare totalWorkTimeInHoursa 3 cifre per la stampa, utilizzare il Stringcostruttore che accetta una formatstringa:

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

Con Swift 5, in base alle tue esigenze, puoi scegliere uno dei 9 seguenti stili per ottenere un risultato arrotondato da a Double.

# 1. Usando il FloatingPoint rounded()metodo

Nel caso più semplice, è possibile utilizzare il Double rounded()metodo

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 il FloatingPoint rounded(_:)metodo

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. Utilizzo della roundfunzione Darwin

La Fondazione offre una roundfunzione tramite 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. Utilizzo di un Doublemetodo personalizzato di estensione creato con Darwin rounde powfunzioni

Se si desidera ripetere più volte l'operazione precedente, il refactoring del codice può essere una buona 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. Usando il NSDecimalNumber rounding(accordingToBehavior:)metodo

Se necessario, NSDecimalNumberoffre una soluzione dettagliata ma potente per arrotondare i numeri decimali.

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. Utilizzando la NSDecimalRound(_:_:_:_:)funzione

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. Utilizzando l' NSString init(format:arguments:)inizializzatore

Se si desidera restituire un NSStringdalla propria operazione di arrotondamento, l'uso NSStringdell'inizializzatore è una soluzione semplice ma efficace.

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. Utilizzando l' String init(format:_:)inizializzatore

Il Stringtipo di Swift è colmato con la NSStringclasse della Fondazione . Pertanto, è possibile utilizzare il seguente codice per restituire un Stringdalla propria operazione di arrotondamento:

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

Se ti aspetti di ottenere un risultato String?dalla tua operazione di arrotondamento, NumberFormatteroffre una soluzione altamente personalizzabile.

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

In Swift 2.0 e Xcode 7.2:

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

Esempio:

Questo è un codice completamente funzionante

Swift 3.0 / 4.0 / 5.0, Xcode 9.0 GM / 9.2 e versioni successive

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

uscita - 123

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

uscita - 123.3

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

uscita - 123.33

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

uscita - 123.326

Sulla base della risposta di Yogi, ecco una funzione Swift che fa il lavoro:

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

In Swift 3.0 e Xcode 8.0:

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

Usa questa estensione in questo modo:

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)

Il codice per cifre specifiche dopo i decimali è:

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

Qui% .3f indica allo swift di arrotondare questo numero a 3 cifre decimali e se si desidera un numero doppio, è possibile utilizzare questo codice:

// String to Double

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

Usa la libreria Foundation Darwin integrata

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

Uscite: 12.988

Un modo pratico può essere l'uso dell'estensione di 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 si desidera arrotondare i Doublevalori, è possibile utilizzare Swift in Decimalmodo da non introdurre errori che possono sorgere quando si tenta di eseguire la matematica con questi valori arrotondati. Se lo si utilizza Decimal, può rappresentare accuratamente i valori decimali di quel valore in virgola mobile arrotondato.

Quindi puoi fare:

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

Quindi, puoi ottenere il Decimalvalore arrotondato in questo modo:

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

E se si desidera visualizzarlo con un numero specificato di posizioni decimali (oltre a localizzare la stringa per la locale corrente dell'utente), è possibile utilizzare un NumberFormatter:

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

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

Questa è una sorta di soluzione alternativa, che può tornare utile se le tue esigenze sono un po 'più complesse. Puoi usare un formattatore di numeri in Swift.

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

Supponiamo che la variabile che si desidera stampare sia

var printVar = 3.567

Ciò assicurerà che venga restituito nel formato desiderato:

numberFormatter.StringFromNumber(printVar)

Il risultato qui sarà quindi "3,6" (arrotondato). Sebbene questa non sia la soluzione più economica, la dò perché l'OP menzionava la stampa (nel qual caso una stringa non è indesiderabile) e perché questa classe consente di impostare più parametri.

io userei

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

e cambia .3f in qualsiasi numero di numeri decimali di cui hai bisogno

O:

1. Utilizzando String(format:):

   • Typecast Doubleto Stringcon identificatore di %.3fformato e poi di nuovo aDouble

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

   • Oppure estendi Doubleper gestire i punti N-decimali:

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

2. Per calcolo

   • moltiplicare per 10 ^ 3, arrotondarlo e poi dividere per 10 ^ 3 ...

     (1000 * 10.123546789).rounded()/1000

   • Oppure estendi Doubleper gestire i punti N-decimali:

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

Questo è un algoritmo più flessibile di arrotondamento a N cifre significative

Soluzione 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

Il modo migliore per formattare una doppia proprietà è utilizzare i metodi predefiniti di Apple.

mutating func round(_ rule: FloatingPointRoundingRule)

FloatingPointRoundingRule è un enum che ha le seguenti possibilità

Casi di enumerazione:

case awayFromZero Arrotonda al valore consentito più vicino la cui grandezza è maggiore o uguale a quella della sorgente.

case down Arrotonda al valore consentito più vicino che è minore o uguale alla fonte.

case toNearestOrAwayFromZero Arrotonda al valore consentito più vicino; se due valori sono ugualmente vicini, viene scelto quello con maggiore magnitudine.

case toNearestOrEven Round al valore consentito più vicino; se due valori sono ugualmente vicini, viene scelto quello pari.

case verso Zero Arrotondare al valore consentito più vicino la cui grandezza è inferiore o uguale a quella della sorgente.

case up Arrotonda al valore consentito più vicino che è maggiore o uguale alla sorgente.

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

arrotondare un doppio valore a x numero di
NO decimale . di cifre dopo i decimali

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

Non Swift ma sono sicuro che avrai l'idea.

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

Questo sembra funzionare in Swift 5.

Abbastanza sorpreso che non ci sia già una funzione standard per questo.

// Troncamento delle posizioni dal doppio al n decimale con arrotondamento

extension Double {

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

}

È possibile aggiungere questa estensione:

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

e chiamalo così:

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

Per evitare le imperfezioni Float, usare Decimale

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 arrotondamenti a 1075,57 quando si utilizza Float con scala: 2 e. Giù
1075,58 arrotondamenti a 1075,58 quando si utilizza Decimale con scala: 2 e. Giù

Ho trovato questo chiedendosi se è possibile correggere l'input di un utente. Cioè se inseriscono tre decimali anziché due per un importo in dollari. Di '1.111 invece di 1.11, puoi aggiustarlo arrotondando? La risposta per molte ragioni è no! Con denaro superiore a 0,001, alla fine si potrebbero causare problemi in un vero libretto degli assegni.

Ecco una funzione per controllare l'input degli utenti per troppi valori dopo il periodo. Ma ciò consentirà 1., 1.1 e 1.11.

Si presume che il valore sia già stato verificato per la corretta conversione da una stringa a una doppia.

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

Utilizzo:

totalWorkTimeInHours.roundedValue

Eccone uno per SwiftUI se hai bisogno di un elemento Text con il valore numerico.

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

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