.net core 3 yields different floating point results from version 2.2

by

.NET Core introduced a lot of floating point parsing and formatting improvements in IEEE floating point compliance. One of them is IEEE 754-2008 formatting compliance.

Before .NET Core 3.0, ToString() internally limited precision to “just” 15 places, producing string that couldn’t be parsed back to the original. The question’s values differ by a single bit.

In both .NET 4.7 and .NET Core 3, the actual bytes remains the same. In both cases, calling

BitConverter.GetBytes(d*d*d)

Produces 

85, 14, 45, 178, 157, 111, 27, 64

On the other hand, BitConverter.GetBytes(6.859) produces :

86, 14, 45, 178, 157, 111, 27, 64

Even in .NET Core 3, parsing “6.859” produces the second byte sequence :

BitConverter.GetBytes(double.Parse("6.859"))

This is a single bit difference. The old behavior produced a string that couldn’t be parsed back to the original value

The difference is explained by this change :

ToString(), ToString(“G”), and ToString(“R”) will now return the shortest roundtrippable string. This ensures that users end up with something that just works by default.

That’s why we always need to specify a precision when dealing with floating point numbers. There were improvements in this case too :

For the “G” format specifier that takes a precision (e.g. G3), the precision specifier is now always respected. For double with precisions less than 15 (inclusive) and for float with precisions less than 6 (inclusive) this means you get the same string as before. For precisions greater than that, you will get up to that many significant digits

Using ToString("G15") produces 6.859 while ToString("G16") produces 6.858999999999999, which has 16 fractional digits.

That’s a reminder that we always need to specify a precision when working with floating point numbers, whether it’s comparing or formatting

More Related Contents:

  1. Is polymorphic deserialization possible in System.Text.Json?
  2. Does C# 8 support the .NET Framework?
  3. System.Text.Json.JsonElement ToObject workaround
  4. What does null! statement mean?
  5. How to use class fields with System.Text.Json.JsonSerializer?
  6. Converting newtonsoft code to System.Text.Json in .net core 3. what’s equivalent of JObject.Parse and JsonProperty
  7. Nullable reference types with generic return type
  8. Why does Visual Studio Type a Newly Minted Array as Nullable?
  9. Nullable reference types: How to specify “T?” type without constraining to class or struct
  10. Command dotnet ef not found
  11. How to enable Nullable Reference Types feature of C# 8.0 for the whole project
  12. System.Text.Json and Dynamically Parsing polymorphic objects
  13. Factory for IAsyncEnumerable or IAsyncEnumerator
  14. Parsing a JSON file with .NET core 3.0/System.text.Json
  15. Default Interface Methods. What is deep meaningful difference now, between abstract class and interface?
  16. Can a C# class call an interface’s default interface method from its own implementation?
  17. C# 8 switch expression with multiple cases with same result
  18. Meaning of curly braces after the “is” operator
  19. What is the difference between using and await using? And how can I decide which one to use?
  20. How can I use C# 8 with Visual Studio 2017?
  21. Default implementation in interface is not seen by the compiler?
  22. Is there a built in way of using snake case as the naming policy for JSON in ASP.NET Core 3?
  23. JsonSerializer.Deserialize fails
  24. C#’s can’t make `notnull` type nullable
  25. Process.Start in Core 3.0 does not open a folder just by its name
  26. The annotation for nullable reference types should only be used in code within a ‘#nullable’ context
  27. What does exclamation mark mean before invoking a method in C# 8.0? [duplicate]
  28. Why do we get possible dereference null reference warning, when null reference does not seem to be possible?
  29. When should we use default interface method in C#?
  30. How to implement an efficient WhenEach that streams an IAsyncEnumerable of task results?

Leave a Comment