Swift 4: Strange Double and Float behaviour

Question

Basically the problem is that in this example:

let d1 = NSNumber(value: 1.4);
let d2 = d1.doubleValue;

let f1 = NSNumber(value: Float(1.4));
let f2 = d1.floatValue;

d1 results 1.4
d2 results 1.3999999999999999

f1 results 1.4
f2 results 1.3999999999999998

Does anyone know why is that?

I'm trying to parse JSON file like:

{"name": "something", "version": 1.4}

with the following code:

let json = try (JSONSerialization.jsonObject(with: someData) as? [String: Any])!;
let version: Double = (json["version"] as! NSNumber).doubleValue;

OR

let version: Double = json["version"] as! Double;

OR

let version: Double = json["version"] as! Float;

And I just can't get 1.4...

Rounding the number is not a solution for me, because I want to write back this number to JSON file, that will be parsed by other programs/languages and needs to be exactly 1.4 in the file.

Any suggestions?

UPDATE: The problem is only with 1.1 and 1.4. There is no problem with 1.2, 1.3, 1.5

UPDATE 2: Serialization code:

    let jsonDict: Dictionary<String,Any> = [
        "name" : name,
        "version" : version
    ];

    let data = try? JSONSerialization.data(withJSONObject: jsonDict, options: []);
    let jsonString = String(data:data, encoding:.utf8);

Answer 1

Ok, just to finalise the discussion.

At the end Decimal type did the trick. So I changed all variable references to Decimal and NOT NSDecimalNumber, because I got error that it doesn't comply with Codable and Decodable protocols. Maybe there is a workaround for this, but the easiest solution is just to stick with Decimal.

I would like to thanks to @JamesBucanek and @EricPostpischil for joining the discussion and help resolving this issue !!!

Answer 2

I had the same story.

I need to sent/receive float values using API endpoint. So I followed advice and changed Double to Decimal. It worked fine for encoding data, but not for decoding.

let value = "0.0006"
let decimal = Decimal(string: value)!
print(decimal) // 0.0006 OK
let jsonData = try JSONEncoder().encode(decimal)
print(String(data: jsonData, encoding: .utf8)!) // 0.0006 OK
let decocdedDecimal = try JSONDecoder().decode(Decimal.self, from: jsonData)
print(decocdedDecimal) // 0.0005999999999999998976 NOOOOOO!!!

However decode to Double works fine.

let decocdedDouble = try JSONDecoder().decode(Double.self, from: jsonData)
print(decocdedDouble) // 0.0006 OK

Also as was mentioned in answers above - Decimal should be inited with String to be encoded correctly

let decimal = Decimal(0.0006)
print(decimal) // 0.0005999999999999998976, it will be encoded same way

And ofcourse Double encoding not working as expected, otherwise we didn't have such issue.

// 0.00059999999999999995 for all cases ofcourse
print(String(data: try JSONEncoder().encode(0.0006), encoding: .utf8)!)
print(String(data: try JSONEncoder().encode(decocdedDouble), encoding: .utf8)!)
print(String(data: try JSONEncoder().encode(Double(value)!), encoding: .utf8)!)

So my dirty solution for now is to use wrapper for Double values. It will decode value as Double, but encode as Decimal(string:)

struct CodableDouble: Codable {
    var value: Double
    
    init(_ value: Double) {
        self.value = value
    }
    
    init(from decoder: Decoder) throws {
        value = try decoder.singleValueContainer().decode(Double.self)
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        let decimal = Decimal(string: "\(value)") ?? 0
        try container.encode(decimal)
    }
}

But I still don't understand what is the correct way to handle this issue. (except not using float values)