qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-05 20:26:13 -07:00
Code Releases Activity
d7507e9d11
go/test/float_lit2.go

165 lines
7.9 KiB
Go
Raw Normal View History

cmd/gc: fix float32 const conversion and printing of big float consts The float32 const conversion used to round to float64 and then use the hardware to round to float32. Even though there was a range check before this conversion, the double rounding introduced inaccuracy: the round to float64 might round the value further away from the float32 range, reaching a float64 value that could not actually be rounded to float32. The hardware appears to give us 0 in that case, but it is probably undefined. Double rounding also meant that the wrong value might be used for certain border cases. Do the rounding the float32 ourselves, just as we already did the rounding to float64. This makes the conversion precise and also makes the conversion match the range check. Finally, add some code to print very large (bigger than float64) floating point constants in decimal floating point notation instead of falling back to the precise but human-unreadable binary floating point notation. Fixes #8015. LGTM=iant R=golang-codereviews, iant CC=golang-codereviews, r https://golang.org/cl/100580044
2014-05-19 20:57:59 -06:00
// run
// Check conversion of constant to float32/float64 near min/max boundaries.
all: make copyright headers consistent with one space after period Follows suit with https://go-review.googlesource.com/#/c/20111. Generated by running $ grep -R 'Go Authors. All' * | cut -d":" -f1 | while read F;do perl -pi -e 's/Go Authors. All/Go Authors. All/g' $F;done The code in cmd/internal/unvendor wasn't changed. Fixes #15213 Change-Id: I4f235cee0a62ec435f9e8540a1ec08ae03b1a75f Reviewed-on: https://go-review.googlesource.com/21819 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-10 15:32:26 -06:00
// Copyright 2014 The Go Authors. All rights reserved.
cmd/gc: fix float32 const conversion and printing of big float consts The float32 const conversion used to round to float64 and then use the hardware to round to float32. Even though there was a range check before this conversion, the double rounding introduced inaccuracy: the round to float64 might round the value further away from the float32 range, reaching a float64 value that could not actually be rounded to float32. The hardware appears to give us 0 in that case, but it is probably undefined. Double rounding also meant that the wrong value might be used for certain border cases. Do the rounding the float32 ourselves, just as we already did the rounding to float64. This makes the conversion precise and also makes the conversion match the range check. Finally, add some code to print very large (bigger than float64) floating point constants in decimal floating point notation instead of falling back to the precise but human-unreadable binary floating point notation. Fixes #8015. LGTM=iant R=golang-codereviews, iant CC=golang-codereviews, r https://golang.org/cl/100580044
2014-05-19 20:57:59 -06:00
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"fmt"
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
"math"
cmd/gc: fix float32 const conversion and printing of big float consts The float32 const conversion used to round to float64 and then use the hardware to round to float32. Even though there was a range check before this conversion, the double rounding introduced inaccuracy: the round to float64 might round the value further away from the float32 range, reaching a float64 value that could not actually be rounded to float32. The hardware appears to give us 0 in that case, but it is probably undefined. Double rounding also meant that the wrong value might be used for certain border cases. Do the rounding the float32 ourselves, just as we already did the rounding to float64. This makes the conversion precise and also makes the conversion match the range check. Finally, add some code to print very large (bigger than float64) floating point constants in decimal floating point notation instead of falling back to the precise but human-unreadable binary floating point notation. Fixes #8015. LGTM=iant R=golang-codereviews, iant CC=golang-codereviews, r https://golang.org/cl/100580044
2014-05-19 20:57:59 -06:00
)
test/float_lit2: fix expressions in comment The change corrects the values of the largest float32 value (f1) and the value of the halfway point between f1 and the next, overflow value (f2). Fixes #17012 Change-Id: Idaf9997b69d61fafbffdb980d751c9857732e14d Reviewed-on: https://go-review.googlesource.com/29171 Reviewed-by: Robert Griesemer <gri@golang.org>
2016-09-14 05:17:37 -06:00
// The largest exact float32 is f₁ = (1+1-1/2²³)×2¹²⁷ = (2-2⁻²³)×2¹²⁷ = 2¹²⁸ - 2¹⁰⁴.
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
// The next float32 would be f₂ = (1+1)×2¹²⁷ = 1×2¹²⁸, except that exponent is out of range.
// Float32 conversion rounds to the nearest float32, rounding to even mantissa:
test: fix two typos in float_lit2.go Noted by gri in CL 100660044 review but I missed them. TBR=gri CC=golang-codereviews https://golang.org/cl/97570049
2014-05-21 15:19:12 -06:00
// between f₁ and f₂, values closer to f₁ round to f₁ and values closer to f₂ are rejected as out of range.
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
// f₁ is an odd mantissa, so the halfway point (f₁+f₂)/2 rounds to f₂ and is rejected.
test/float_lit2: fix expressions in comment The change corrects the values of the largest float32 value (f1) and the value of the halfway point between f1 and the next, overflow value (f2). Fixes #17012 Change-Id: Idaf9997b69d61fafbffdb980d751c9857732e14d Reviewed-on: https://go-review.googlesource.com/29171 Reviewed-by: Robert Griesemer <gri@golang.org>
2016-09-14 05:17:37 -06:00
// The halfway point is (f₁+f₂)/2 = 2¹²⁸ - 2¹⁰³.
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
//
// The same is true of float64, with different constants: s/24/53/ and s/128/1024/.
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
const (
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
two24 = 1.0 * (1 << 24)
two53 = 1.0 * (1 << 53)
two64 = 1.0 * (1 << 64)
two128 = two64 * two64
two256 = two128 * two128
two512 = two256 * two256
two768 = two512 * two256
two1024 = two512 * two512
ulp32 = two128 / two24
max32 = two128 - ulp32
ulp64 = two1024 / two53
max64 = two1024 - ulp64
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
)
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
var cvt = []struct {
bits uint64 // keep us honest
exact interface{}
approx interface{}
text string
}{
// 0
{0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32 - ulp32/2), "max32 - ulp32 - ulp32/2"},
{0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32), "max32 - ulp32"},
{0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32/2), "max32 - ulp32/2"},
{0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32 + ulp32/2), "max32 - ulp32 + ulp32/2"},
{0x7f7fffff, float32(max32), float32(max32 - ulp32 + ulp32/2 + ulp32/two64), "max32 - ulp32 + ulp32/2 + ulp32/two64"},
{0x7f7fffff, float32(max32), float32(max32 - ulp32/2 + ulp32/two64), "max32 - ulp32/2 + ulp32/two64"},
{0x7f7fffff, float32(max32), float32(max32), "max32"},
{0x7f7fffff, float32(max32), float32(max32 + ulp32/2 - ulp32/two64), "max32 + ulp32/2 - ulp32/two64"},
{0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32 - ulp32/2)), "-(max32 - ulp32 - ulp32/2)"},
{0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32)), "-(max32 - ulp32)"},
{0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32/2)), "-(max32 - ulp32/2)"},
{0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32 + ulp32/2)), "-(max32 - ulp32 + ulp32/2)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32 + ulp32/2 + ulp32/two64)), "-(max32 - ulp32 + ulp32/2 + ulp32/two64)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32/2 + ulp32/two64)), "-(max32 - ulp32/2 + ulp32/two64)"},
{0xff7fffff, float32(-(max32)), float32(-(max32)), "-(max32)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 + ulp32/2 - ulp32/two64)), "-(max32 + ulp32/2 - ulp32/two64)"},
// These are required to work: according to the Go spec, the internal float mantissa must be at least 256 bits,
// and these expressions can be represented exactly with a 256-bit mantissa.
{0x7f7fffff, float32(max32), float32(max32 - ulp32 + ulp32/2 + 1), "max32 - ulp32 + ulp32/2 + 1"},
{0x7f7fffff, float32(max32), float32(max32 - ulp32/2 + 1), "max32 - ulp32/2 + 1"},
{0x7f7fffff, float32(max32), float32(max32 + ulp32/2 - 1), "max32 + ulp32/2 - 1"},
{0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32 + ulp32/2 + 1)), "-(max32 - ulp32 + ulp32/2 + 1)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32/2 + 1)), "-(max32 - ulp32/2 + 1)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 + ulp32/2 - 1)), "-(max32 + ulp32/2 - 1)"},
{0x7f7fffff, float32(max32), float32(max32 - ulp32 + ulp32/2 + 1/two128), "max32 - ulp32 + ulp32/2 + 1/two128"},
{0x7f7fffff, float32(max32), float32(max32 - ulp32/2 + 1/two128), "max32 - ulp32/2 + 1/two128"},
{0x7f7fffff, float32(max32), float32(max32 + ulp32/2 - 1/two128), "max32 + ulp32/2 - 1/two128"},
{0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32 + ulp32/2 + 1/two128)), "-(max32 - ulp32 + ulp32/2 + 1/two128)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32/2 + 1/two128)), "-(max32 - ulp32/2 + 1/two128)"},
{0xff7fffff, float32(-(max32)), float32(-(max32 + ulp32/2 - 1/two128)), "-(max32 + ulp32/2 - 1/two128)"},
{0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64 - ulp64/2), "max64 - ulp64 - ulp64/2"},
{0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64), "max64 - ulp64"},
{0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64/2), "max64 - ulp64/2"},
{0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64 + ulp64/2), "max64 - ulp64 + ulp64/2"},
{0x7fefffffffffffff, float64(max64), float64(max64 - ulp64 + ulp64/2 + ulp64/two64), "max64 - ulp64 + ulp64/2 + ulp64/two64"},
{0x7fefffffffffffff, float64(max64), float64(max64 - ulp64/2 + ulp64/two64), "max64 - ulp64/2 + ulp64/two64"},
{0x7fefffffffffffff, float64(max64), float64(max64), "max64"},
{0x7fefffffffffffff, float64(max64), float64(max64 + ulp64/2 - ulp64/two64), "max64 + ulp64/2 - ulp64/two64"},
{0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64 - ulp64/2)), "-(max64 - ulp64 - ulp64/2)"},
{0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64)), "-(max64 - ulp64)"},
{0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64/2)), "-(max64 - ulp64/2)"},
{0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64 + ulp64/2)), "-(max64 - ulp64 + ulp64/2)"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64 + ulp64/2 + ulp64/two64)), "-(max64 - ulp64 + ulp64/2 + ulp64/two64)"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64/2 + ulp64/two64)), "-(max64 - ulp64/2 + ulp64/two64)"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64)), "-(max64)"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64 + ulp64/2 - ulp64/two64)), "-(max64 + ulp64/2 - ulp64/two64)"},
// These are required to work.
// The mantissas are exactly 256 bits.
// max64 is just below 2¹⁰²⁴ so the bottom bit we can use is 2⁷⁶⁸.
{0x7fefffffffffffff, float64(max64), float64(max64 - ulp64 + ulp64/2 + two768), "max64 - ulp64 + ulp64/2 + two768"},
{0x7fefffffffffffff, float64(max64), float64(max64 - ulp64/2 + two768), "max64 - ulp64/2 + two768"},
{0x7fefffffffffffff, float64(max64), float64(max64 + ulp64/2 - two768), "max64 + ulp64/2 - two768"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64 + ulp64/2 + two768)), "-(max64 - ulp64 + ulp64/2 + two768)"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64/2 + two768)), "-(max64 - ulp64/2 + two768)"},
{0xffefffffffffffff, float64(-(max64)), float64(-(max64 + ulp64/2 - two768)), "-(max64 + ulp64/2 - two768)"},
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
}
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
var bugged = false
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
func bug() {
if !bugged {
bugged = true
fmt.Println("BUG")
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
}
}
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
func main() {
u64 := math.Float64frombits(0x7fefffffffffffff) - math.Float64frombits(0x7feffffffffffffe)
if ulp64 != u64 {
bug()
fmt.Printf("ulp64=%g, want %g", ulp64, u64)
}
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
u32 := math.Float32frombits(0x7f7fffff) - math.Float32frombits(0x7f7ffffe)
if ulp32 != u32 {
bug()
fmt.Printf("ulp32=%g, want %g", ulp32, u32)
}
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
for _, c := range cvt {
if bits(c.exact) != c.bits {
bug()
fmt.Printf("%s: inconsistent table: bits=%#x (%g) but exact=%g (%#x)\n", c.text, c.bits, fromBits(c.bits, c.exact), c.exact, bits(c.exact))
}
if c.approx != c.exact || bits(c.approx) != c.bits {
bug()
fmt.Printf("%s: have %g (%#x) want %g (%#x)\n", c.text, c.approx, bits(c.approx), c.exact, c.bits)
}
}
}
test/float_lit2.go: compute test values from first principles These constants pass go/types constant conversions as well. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/91590047
2014-05-21 09:53:47 -06:00
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
func bits(x interface{}) interface{} {
switch x := x.(type) {
case float32:
return uint64(math.Float32bits(x))
case float64:
return math.Float64bits(x)
}
return 0
cmd/gc: fix float32 const conversion and printing of big float consts The float32 const conversion used to round to float64 and then use the hardware to round to float32. Even though there was a range check before this conversion, the double rounding introduced inaccuracy: the round to float64 might round the value further away from the float32 range, reaching a float64 value that could not actually be rounded to float32. The hardware appears to give us 0 in that case, but it is probably undefined. Double rounding also meant that the wrong value might be used for certain border cases. Do the rounding the float32 ourselves, just as we already did the rounding to float64. This makes the conversion precise and also makes the conversion match the range check. Finally, add some code to print very large (bigger than float64) floating point constants in decimal floating point notation instead of falling back to the precise but human-unreadable binary floating point notation. Fixes #8015. LGTM=iant R=golang-codereviews, iant CC=golang-codereviews, r https://golang.org/cl/100580044
2014-05-19 20:57:59 -06:00
}
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
func fromBits(b uint64, x interface{}) interface{} {
switch x.(type) {
case float32:
return math.Float32frombits(uint32(b))
case float64:
return math.Float64frombits(b)
cmd/gc: fix float32 const conversion and printing of big float consts The float32 const conversion used to round to float64 and then use the hardware to round to float32. Even though there was a range check before this conversion, the double rounding introduced inaccuracy: the round to float64 might round the value further away from the float32 range, reaching a float64 value that could not actually be rounded to float32. The hardware appears to give us 0 in that case, but it is probably undefined. Double rounding also meant that the wrong value might be used for certain border cases. Do the rounding the float32 ourselves, just as we already did the rounding to float64. This makes the conversion precise and also makes the conversion match the range check. Finally, add some code to print very large (bigger than float64) floating point constants in decimal floating point notation instead of falling back to the precise but human-unreadable binary floating point notation. Fixes #8015. LGTM=iant R=golang-codereviews, iant CC=golang-codereviews, r https://golang.org/cl/100580044
2014-05-19 20:57:59 -06:00
}
test/float_lit2.go: rewrite to test values near boundaries Add larger comment explaining testing methodology, and derive tests arithmetically. (These tests are checking rounding again; the derived tests they replace were checking exact values.) LGTM=r, gri R=gri, r CC=golang-codereviews https://golang.org/cl/100660044
2014-05-21 15:12:06 -06:00
return "?"
cmd/gc: fix float32 const conversion and printing of big float consts The float32 const conversion used to round to float64 and then use the hardware to round to float32. Even though there was a range check before this conversion, the double rounding introduced inaccuracy: the round to float64 might round the value further away from the float32 range, reaching a float64 value that could not actually be rounded to float32. The hardware appears to give us 0 in that case, but it is probably undefined. Double rounding also meant that the wrong value might be used for certain border cases. Do the rounding the float32 ourselves, just as we already did the rounding to float64. This makes the conversion precise and also makes the conversion match the range check. Finally, add some code to print very large (bigger than float64) floating point constants in decimal floating point notation instead of falling back to the precise but human-unreadable binary floating point notation. Fixes #8015. LGTM=iant R=golang-codereviews, iant CC=golang-codereviews, r https://golang.org/cl/100580044
2014-05-19 20:57:59 -06:00
}
Copy Permalink