proposal: Go 2: hexadecimal floats

[seebs]

What version of Go are you using (go version)?

1.11, but N/A

Does this issue reproduce with the latest release?

Yes.

What operating system and processor architecture are you using (go env)?

N/A

What did you do?

Read the fmt specs and the language spec, and ponder floating point representation.

What did you expect to see?

Support for hexadecimal floats.

What did you see instead?

No support for hexadecimal floats.

I'm aware that Go's decimal-parsing for floats is superior to that available to C compilers in a number of ways (see issue #12518), but people who want hexadecimal floats often prefer them for reasons beyond that. This does have some overlap with 12518's suggestion for allowing binary exponents with a p suffix, but hexadecimal floats give stronger and easier-to-reason-about guarantees. With decimal representations, it is non-trivial for a human to tell at a glance whether the representation is precise. With hexadecimal floats, the representation is definitionally precise.

Ideally, this would be present in fmt (both for input and output), and also in numeric constants. C used %a/%A, and the format [-]0xh.hhhp[+-]d, with the hexadecimal digits after the period optional, and I don't see any obvious reason to think this specification would cause problems. So far as I know, this wouldn't break any existing code (any valid hex literal would be a syntax error in current go), and it would make life marginally easier for some people doing numerical work.

[seebs]

Someone pointed out that I haven't explained why I don't think Float64FromBits solves this problem.

1. It's runtime.
2. It requires you to count a lot of zeroes to write a simple value.

0x1p-3
0.125
Float64FromBits(0x3fc0000000000000)

In this case, obviously decimal is fine, but I am pretty convinced that a hex float literal is way more legible than Float64FromBits for that value.

[josharian]

Two observations:

With appropriate compiler optimizations, it doesn’t have to be runtime.

If #28493 goes in, the zeros will be easier to count.

[seebs]

So that's a good counterargument to what I said, but I don't feel persuaded, making me think I didn't actually say anything that communicated what I'm looking for. A better way of expressing it might be: I don't want to have to think about the zeroes at all. They're a weird artifact of the normalized representation. Say I want to have a floating-point constant. if I write it as a hex float, I get a 100% predictable float constant that can be used for both float32 and float64, assuming they have sufficient precision, and I know exactly what it means in either of them, and don't have to guess about or think about rounding errors. If I write it in Float##FromBits, I have to have two forms of it because they're different lengths.

Hex floats offer a convenient way to express mantissa values with reliable precision. They are much more human-reader friendly than IEEE's normalized mantissa values, and getting the exponent in decimal, but still in powers of 2, turns out to map nicely onto what's actually happening.

When people first proposed this for C, I was... sort of skeptical. Why would you want floats in hex? That's not how they work! That's not how anything works! But there were enough floating point people on the committee to get it adopted, and I didn't really have an objection, I just didn't see the point. But as I've spent time trying to decipher float values, it's become increasingly clear to me that, while dealing with the whole float as a large unsigned integer certainly works, it's not really easy to read. I can't look at a Float##FromBits value and know what it is without having to do some kind of math in my head. Why is 3fc negative? Because the sign bit for the exponent is the 4, which isn't where I normally look for sign bits, because the 8 is the sign bit for the whole number. Why is a 13-byte string of 0s actually a 1? (Any short punchy explanation is probably wrong.)

It's a lot easier for me to understand "p-3" than "0x3FC". YMMV.

EDIT: I was wrong, though, the 4 isn't the sign bit, the exponent is stored unsigned using a bias of +127. This goes back to my basic assertion that this is not a programmer-friendly way to view float values.

[baryluk]

Some examples:

0x1.FFFFFFFFFFFFFp1023 // double.max
0x1p-52                // double.epsilon
1.175494351e-38F       // float.min

2.645_751
6.022140857E+23
6_022.140857E+20
6_022_.140_857E+20_

Obviously both could be combined.

0x1.F_FFFF_FFFF_FFFFp1_023

[rsc]

We've posted a combined proposal for #19308, #12711, #28493, and #29008 at golang.org/design/19308-number-literals. It includes hex floats as suggested in this issue. (I could have sworn there was an earlier issue proposing hex floats, but I can't find it.)

Note that this will be the first proposal to follow the process outlined in the Go 2 here we come! blog post: we will have everything ready to go and checked in at the start of the Go 1.13 cycle (Feb 1), we will spend the next three months using those features and soliciting feedback based on actual usage, and then at the start of the release freeze (May 1), we will make the "launch decision" about whether to include the work in Go 1.13 or not.

Thanks for your feedback and all your help improving Go.

[seebs]

Thanks! The proposal looks excellent to me.

[gopherbot]

Change https://golang.org/cl/157677 mentions this issue: cmd/compile: accept new Go2 number literals

[gopherbot]

Change https://golang.org/cl/159297 mentions this issue: math/big: permit upper-case 'P' binary exponent (not just 'p')

[gopherbot]

Change https://golang.org/cl/159997 mentions this issue: go/scanner: accept new Go2 number literals

[gopherbot]

Change https://golang.org/cl/160018 mentions this issue: cmd/gofmt: test that Go 2 number literals can be formatted

[gopherbot]

Change https://golang.org/cl/160239 mentions this issue: go/constant: accept new Go2 number literals

[gopherbot]

Change https://golang.org/cl/160240 mentions this issue: go/types: add tests for new Go 2 number literals

[gopherbot]

Change https://golang.org/cl/160247 mentions this issue: fmt: scan new number syntax

[gopherbot]

Change https://golang.org/cl/160242 mentions this issue: strconv: format hex floats

[gopherbot]

Change https://golang.org/cl/160248 mentions this issue: text/template: accept new number syntax

[gopherbot]

Change https://golang.org/cl/160241 mentions this issue: strconv: parse hex floats

[gopherbot]

Change https://golang.org/cl/160245 mentions this issue: fmt: format hex floats and complexes

[gopherbot]

Change https://golang.org/cl/160249 mentions this issue: math/big: add %x float format

[gopherbot]

Change https://golang.org/cl/160184 mentions this issue: cmd/gofmt: normalize number prefixes and exponents

[gopherbot]

Change https://golang.org/cl/160478 mentions this issue: design/19308-number-literals: add note about gofmt

[gopherbot]

Change https://golang.org/cl/163079 mentions this issue: text/scanner: don't liberally consume (invalid) floats or underbars

[gopherbot]

Change https://golang.org/cl/174897 mentions this issue: cmd/compile: disable Go1.13 language features for -lang=go1.12 and below

[rsc]

As a reminder, we introduced a new process for these Go 2-related language changes in our blog post blog.golang.org/go2-here-we-come. The Go 1.13 development cycle is now over and it’s time for the final decision.

The feedback on the Go 2 number literal changes has been strongly positive, with very few negative voices. These changes modernize and harmonize Go’s number literal syntax without adding significant complexity to the language: There is now a uniform prefix notation for the three common non-decimal number bases, which matches the notation used in other modern programming languages. The introduction of hexadecimal floating-point literals addresses a pain point for people concerning themselves with numeric code. The suffix “i” may now be used with any (non-imaginary) number literal to create an imaginary constant in a uniform way. And finally, underscores may be used to split longer literals into groups of digits for improved readability.

Proposal accepted for Go 1.13. Closing because the changes have landed.

- rsc for proposal review

[gopherbot]

Change https://golang.org/cl/189718 mentions this issue: compiler: support new numeric literal syntax