math.Signbit(-float64(0)) is false

[gopherbot]

by mikesamuel:

What steps will reproduce the problem?
1. In the Go playground enter the below and hit COMPILE & RUN

package main

import (
    "fmt"
    "math"
    )

func main() {
    fmt.Println(math.Copysign(0, -1))
}

2. See "-0" printed as expected
3. In the Go playground enter the below and hit COMPILE & RUN

package main

import "fmt"

func main() {
    z := float64(0)
    nz := -z
    fmt.Println(nz)
}
4. See "-0" printed
5. In the Go playground enter the below and hit COMPILE & RUN

package main

import "fmt"

func main() {
    nz := -float64(0)
    fmt.Println(nz)
}
6. See "0" printed

What is the expected output?

I expect all 3 programs to print "-0".


What do you see instead?

The first 2 print "-0" but the third prints "0".


Which compiler are you using (5g, 6g, 8g, gccgo)?

I tested using the playground, but can repeat this behavior on 6g.


Which operating system are you using?

Mac OS


Which revision are you using?  (hg identify)

5e1053337103+ tip

[gopherbot]

Comment 1 by mikesamuel:

A shorter test.  The below run in the playground prints "false, true", but I expect it
to print "true, true".
package main
import (
    "fmt"
    "math"
)
func main() {
        z := float64(0)
    nz := -z
    fmt.Printf("%t, %t\n", math.Signbit(-float64(0)), math.Signbit(nz))
}

[rsc]

Comment 2:

What you are seeing is a mismatch between the
run time behavior of floating point numbers and
the ideal constant evaluation in the Go compiler.
They're different: the constants in Go are just that:
constants.  There's no infinity, no NaN, no negative zero.
Those are all IEEE754 concepts, so they exist at
run time, but not in the compiler.  If you want an
IEEE754 negative zero, you can be explicit by
using math.Copysign.
Russ

[rsc]

Comment 3:

Owner changed to @rsc.

Status changed to WorkingAsIntended.

[gopherbot]

Comment 4 by mikesamuel:

From the language spec ( http://golang.org/doc/go_spec.html#Conversions )
"Converting a constant yields a typed constant as result."
"     float32(2.718281828)     // 2.718281828 of type float32"
"The values of typed constants must always be accurately representable as values of the
constant type."
so I expect float64(0) is not an ideal constant, but is a typed constant of type
float64, and the negation operator applied to that should behave as advertised in
"For floating-point numbers, +x is the same as x, while -x is the negation of x."

[gopherbot]

Comment 5 by mikesamuel:

Your argument makes sense for float64(-0), but I don't see how it applies to -float64(0).

[gopherbot]

Comment 6 by asaz989:

Do you mean the other way around? float64(-0) is a conversion of the ideal constant -0
to float64, which seems like it should discard the sign bit, while -float64(0) should
apply the negation to a (non-ideal) typed constant, and so keep the sign bit.

[gopherbot]

CL https://golang.org/cl/14261 mentions this issue.