blob: fb7f3d3c00c59ede1f2f3a102b39261972418bf1 [file] [log] [blame]
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package runtime_test
import (
"math"
"rand"
. "runtime"
"testing"
)
// turn uint64 op into float64 op
func fop(f func(x, y uint64) uint64) func(x, y float64) float64 {
return func(x, y float64) float64 {
bx := math.Float64bits(x)
by := math.Float64bits(y)
return math.Float64frombits(f(bx, by))
}
}
func add(x, y float64) float64 { return x + y }
func sub(x, y float64) float64 { return x - y }
func mul(x, y float64) float64 { return x * y }
func div(x, y float64) float64 { return x / y }
func TestFloat64(t *testing.T) {
base := []float64{
0,
math.Copysign(0, -1),
-1,
1,
math.NaN(),
math.Inf(+1),
math.Inf(-1),
0.1,
1.5,
1.9999999999999998, // all 1s mantissa
1.3333333333333333, // 1.010101010101...
1.1428571428571428, // 1.001001001001...
1.112536929253601e-308, // first normal
2,
4,
8,
16,
32,
64,
128,
256,
3,
12,
1234,
123456,
-0.1,
-1.5,
-1.9999999999999998,
-1.3333333333333333,
-1.1428571428571428,
-2,
-3,
1e-200,
1e-300,
1e-310,
5e-324,
1e-105,
1e-305,
1e+200,
1e+306,
1e+307,
1e+308,
}
all := make([]float64, 200)
copy(all, base)
for i := len(base); i < len(all); i++ {
all[i] = rand.NormFloat64()
}
test(t, "+", add, fop(Fadd64), all)
test(t, "-", sub, fop(Fsub64), all)
if GOARCH != "386" { // 386 is not precise!
test(t, "*", mul, fop(Fmul64), all)
test(t, "/", div, fop(Fdiv64), all)
}
}
// 64 -hw-> 32 -hw-> 64
func trunc32(f float64) float64 {
return float64(float32(f))
}
// 64 -sw->32 -hw-> 64
func to32sw(f float64) float64 {
return float64(math.Float32frombits(F64to32(math.Float64bits(f))))
}
// 64 -hw->32 -sw-> 64
func to64sw(f float64) float64 {
return math.Float64frombits(F32to64(math.Float32bits(float32(f))))
}
// float64 -hw-> int64 -hw-> float64
func hwint64(f float64) float64 {
return float64(int64(f))
}
// float64 -hw-> int32 -hw-> float64
func hwint32(f float64) float64 {
return float64(int32(f))
}
// float64 -sw-> int64 -hw-> float64
func toint64sw(f float64) float64 {
i, ok := F64toint(math.Float64bits(f))
if !ok {
// There's no right answer for out of range.
// Match the hardware to pass the test.
i = int64(f)
}
return float64(i)
}
// float64 -hw-> int64 -sw-> float64
func fromint64sw(f float64) float64 {
return math.Float64frombits(Fintto64(int64(f)))
}
var nerr int
func err(t *testing.T, format string, args ...interface{}) {
t.Errorf(format, args...)
// cut errors off after a while.
// otherwise we spend all our time
// allocating memory to hold the
// formatted output.
if nerr++; nerr >= 10 {
t.Fatal("too many errors")
}
}
func test(t *testing.T, op string, hw, sw func(float64, float64) float64, all []float64) {
for _, f := range all {
for _, g := range all {
h := hw(f, g)
s := sw(f, g)
if !same(h, s) {
err(t, "%g %s %g = sw %g, hw %g\n", f, op, g, s, h)
}
testu(t, "to32", trunc32, to32sw, h)
testu(t, "to64", trunc32, to64sw, h)
testu(t, "toint64", hwint64, toint64sw, h)
testu(t, "fromint64", hwint64, fromint64sw, h)
testcmp(t, f, h)
testcmp(t, h, f)
testcmp(t, g, h)
testcmp(t, h, g)
}
}
}
func testu(t *testing.T, op string, hw, sw func(float64) float64, v float64) {
h := hw(v)
s := sw(v)
if !same(h, s) {
err(t, "%s %g = sw %g, hw %g\n", op, v, s, h)
}
}
func hwcmp(f, g float64) (cmp int, isnan bool) {
switch {
case f < g:
return -1, false
case f > g:
return +1, false
case f == g:
return 0, false
}
return 0, true // must be NaN
}
func testcmp(t *testing.T, f, g float64) {
hcmp, hisnan := hwcmp(f, g)
scmp, sisnan := Fcmp64(math.Float64bits(f), math.Float64bits(g))
if hcmp != scmp || hisnan != sisnan {
err(t, "cmp(%g, %g) = sw %v, %v, hw %v, %v\n", f, g, scmp, sisnan, hcmp, hisnan)
}
}
func same(f, g float64) bool {
if math.IsNaN(f) && math.IsNaN(g) {
return true
}
if math.Copysign(1, f) != math.Copysign(1, g) {
return false
}
return f == g
}