7

In Swift, is there a way to truncate a float to 2 decimals, such that you can perform further calculations with it? All of the threads I've seen deal with casting to a string, which I can't figure out how to then use mathematically.

I tried using an extension (found on this forum), figuring I could cast back to float after the truncation, but I end up where I started, with another, non-truncated float. I need my return value to be in quarter steps (i.e. 6.50, 6.75, 5.25, etc), and what I'm ending up with, are results like 6.990022....

There has to be a simple way to do this, but I'm hitting a wall. Thanks in advance...

Here's the issue: 

func roundToNearestQuarter(#power : Float) -> String {

     var errorToLowerQuarterRaw : Float = power % 0.25  // 0.210000038146973

     var errorToLowerQuarterString = errorToLowerQuarterStepRaw.string(2)  // "0.21"

     var errorToLowerQuarter = NSString(string: errorToLowerQuaterStepString).floatValue  // 0.209999993443489

// more code

}

roundToNearestQuater(6.71)
sjagr
  • 15,983
  • 5
  • 40
  • 67
NoClue
  • 211
  • 4
  • 13

2 Answers2

11

You cannot round a Float or Double to 2 decimal digits exactly. The reason is that these data types use a binary floating point representation, and cannot represent numbers like 0.1 or 0.01 exactly. See for example

But you said:

I need my return value to be in quarter steps (i.e. 6.50, 6.75, 5.25, etc),

and that is exactly possible because 0.25 = 2-2 can be represented exactly as a floating point number.

The round() function rounds a floating point number to the nearest integral value. To round to the nearest quarter, you just have to "scale" the calculation with the factor 4:

func roundToNearestQuarter(num : Float) -> Float {
    return round(num * 4.0)/4.0
}

roundToNearestQuarter(6.71) // 6.75
roundToNearestQuarter(6.6)  // 6.5
Community
  • 1
  • 1
Martin R
  • 529,903
  • 94
  • 1,240
  • 1,382
  • @Attackfarm: Why do you think so? Everything said in this answer is true for Double as well. – Martin R May 03 '15 at 15:31
  • @Attackfarm: It may *seem* that a Double stores all numbers exactly, because println() rounds the output to 6 decimals, and Double has a precision of about 15 decimals. But try `let x = 0.1 ; let y = 0.2 ; println(x + y - 0.3)` ... – Martin R May 05 '15 at 05:17
  • Fair enough. Didn't realize println() had that limitation – Attackfarm May 05 '15 at 14:36
  • 2
    If you want to truncate by rounding down, use ``floor`` instead of ``round`` – Nick Yap Sep 11 '15 at 15:35
1

If you need to work with true precision (for currency-related applications, for example), you will probably want to use NSDecimalNumber instead of floating point.

The above approach can be applied to NSDecimalNumbers as shown below. In this example, the "step" that you are rounding to can be anything you choose, just set "increment" accordingly.

let number: NSDecimalNumber = 100.52
let increment: NSDecimalNumber = 0.25

let handler = NSDecimalNumberHandler(roundingMode: NSRoundingMode.RoundBankers, scale: 0, raiseOnExactness: false, raiseOnOverflow: false, raiseOnUnderflow: false, raiseOnDivideByZero: false)     // Rounds to the nearest whole number
let result = number.decimalNumberByDividingBy(increment).decimalNumberByRoundingAccordingToBehavior(handler).decimalNumberByMultiplyingBy(increment)

For more on rounding with NSDecimalNumber see here: How to round an NSDecimalNumber in swift?

And yes, working with NSDecimalNumber is a terribly verbose way to do math, but it's not complicated. If you find yourself doing a project involving them frequently, I recommend you consider setting up Swift operator extensions so you can manipulate them in a more elegant way. Check out here for a nice example: https://gist.github.com/mattt/1ed12090d7c89f36fd28

Community
  • 1
  • 1
RGood
  • 111
  • 1
  • 6