cmd/gc: loss of precision in very low constant bits?

[rsc]

I expect this program to print the precision of the internal multiprecision floats used
for storing floating-point constants in the compiler. cmd/gc uses an Mpint with 16
29-bit values, which should be 463 bits plus a sign bit. The program prints 434 on the
playground, which is 15*29-1, not 16*29-1. 

It is possible that my logic here is wrong and that the program does not in fact compute
the precision of the internal floating point representation used for constants. However,
being off by 29 in a compiler with 29-bit mp limbs cannot be a coincidence.

I wonder if the final word in the compiler representation is being maintained or used
incorrectly. It wouldn't be the first time.

package main

import (
    "fmt"
    "math"
)

const ulp = (1.0+(2.0/3.0)) - (5.0/3.0)

func main() {
    fmt.Println(math.Log(1/math.Abs(ulp))/math.Log(2))
}

http://play.golang.org/p/_3XxPwYeVx

[griesemer]

Comment 1:

issue #6866 may be related to this

[rsc]

Comment 2:

Labels changed: added release-go1.5, removed release-go1.4.

[josharian]

Comment 3:

For whoever looks at this next:
The relevant line is mparith3.c:195 (function mpdivfltflt):
    mpsetexp(a, (a->exp-c.exp) - Mpscale*(Mpprec-1) + 1);
(Mpprec-1) has been there since the initial commit. It looks intentional; there's a
similar adjustment in function mpmulfltflt:
    mpsetexp(a, (a->exp + b->exp) + Mpscale*Mpprec - Mpscale - 1);
Relatedly, there's an opportunity to preserve some extra precision by doing some
exponent elimination before calling mpdivfract. Replacing ulp with:
const ulp = (1. + (.2 / .3)) - (5. / 3.)
yields only 428.5 bits of precision instead of 434 --
http://play.golang.org/p/u95M0yCcyV. Using
const ulp = (1. + (2. / 3.)) - (.5 / .3)
yields only 426.5 bits -- http://play.golang.org/p/duqoytGT0X.

Labels changed: added repo-main.

[griesemer]

Running this code after

https://golang.org/cl/7912/

produces 463.00000000000006; that is 463 as one would expect.

[josharian]

Using const ulp = (1. + (2. / 3.)) - (.5 / .3) also generates 463, but const ulp = (1. + (.2 / .3)) - (5. / 3.) generates positive infinity. I don't know whether it is a problem that they should diverge so radically.

[josharian]

Never mind. That was a stupid comment. Retracted. :)