Conditional format specifier and negative zero

[jeremybparagon]

I am looking for a way to make something like (-0.01).ToString("0.#;-0.#") produce "0". In .NET Core 3.0, it produces "-0". This makes the conditional format specifier unusable for me.

During my experimentation, I noticed that (-0.01).ToString("p0.#;n0.#") produces "-p0". Thus, it seems that the statement "negative values are always displayed without a minus sign when section separators are used" at https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings#the--section-separator is not followed here.

[jkotas]

cc @tannergooding

[tannergooding]

The first issue described is by design. -0.0 and +0.0 are different values for the purposes of string parsing/formating (as per the IEEE 754 specification).

The second issue described is a bug, it should print n0

[am11]

The second issue described is a bug, it should print n0

On .NET Core 2.2, Mono and .NET Framework 4.7.2, it prints p. On .NET Core 3.0, it prints -p.

The table produced by https://dotnetfiddle.net/vvAymM found some other differences:

- .NET Core 3.0
+ .NET Core 2.2, Mono and .NET Framework 4.7.2

-(-0.1).ToString("p#;n#"):               -p
-(-0.1).ToString("p0#;n0#"):             -p00
-(-0.1).ToString("p1#;n1#"):             -p1
+(-0.1).ToString("p#;n#"):               p
+(-0.1).ToString("p0#;n0#"):             p00
+(-0.1).ToString("p1#;n1#"):             p1

-(-0.01).ToString("p#;n#"):              -p
-(-0.01).ToString("p0#;n0#"):            -p00
-(-0.01).ToString("p1#;n1#"):            -p1
-(-0.01).ToString("p0.#;n0.#"):          -p0
-(-0.01).ToString("p1.#;n1.#"):          -p1
+(-0.01).ToString("p#;n#"):              p
+(-0.01).ToString("p0#;n0#"):            p00
+(-0.01).ToString("p1#;n1#"):            p1
+(-0.01).ToString("p0.#;n0.#"):          p0
+(-0.01).ToString("p1.#;n1.#"):          p1

[jeremybparagon]

I realize now that I can use (-0.01).ToString("0.#;-0.#;0") to get what I wanted initially.

Regarding the second issue, would it make sense for the comments at https://github.com/dotnet/coreclr/blob/818b35978a1681690988b2c9c3f0b6a034d91e82/src/System.Private.CoreLib/shared/System/Number.Formatting.cs#L222-L225 and https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings#the--section-separator to be updated if they are not going to be followed in .NET Core?

Thank you.

[tannergooding]

Yes, the documentation should likely be updated as well.

[ghost]

Tagging subscribers to this area: @tannergooding
Notify danmosemsft if you want to be subscribed.

[huoyaoyuan]

The documentation has already been updated:

Two sections	The first section applies to positive values and zeros, and the second section applies to negative values.If the number to be formatted is negative, but becomes zero after rounding according to the format in the second section, the resulting zero is formatted according to the first section.

[jeremybparagon]

@huoyaoyuan I see that the bug confirmed by @tannergooding is still present in .NET 7: (-0.01).ToString("p0.#;n0.#") still prints -p0. Should this issue remain open?

Also, when that is fixed, the documentation you quoted will not be correct. It says, "If the number to be formatted is negative, but becomes zero after rounding according to the format in the second section, the resulting zero is formatted according to the first section." But here we have -0.01 which will become zero after rounding but will be formatted according to the second section.

Thanks.

[huoyaoyuan]

Sorry I didn't test this locally. Can you confirm the behavior in .NET 7? Could you also examine the expected behavior according to doc?

[jeremybparagon]

@huoyaoyuan I tested it in .NET 7, and (-0.01).ToString("p0.#;n0.#") still outputs "-p0". This goes against the documentation that says, "If you want the final formatted value to have a minus sign, you should explicitly include the minus sign as part of the custom format specifier." Here I did not include a minus sign in the format specifier, but it is being added nonetheless.

The underlying issue is that the intended spec has changed as of .NET Core 3.0. Negative zero is now presented as -0 rather than 0. So the behavior specified by @tannergooding above as the intended behavior goes against the spec that says, "If the number to be formatted is negative, but becomes zero after rounding according to the format in the second section, the resulting zero is formatted according to the first section." The current behavior needs to change, and the documented behavior needs to change.