qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-21 16:14:42 -07:00
Code Releases Activity

math: special cases for Fmod

Browse Source 
Added special case tests to all_test.go for Fmod. Fixed Fmod [hung
for Fmod(+/-Inf, <finite>)]. Also added test for Ceil in all_test.go.

R=rsc
CC=golang-dev
https://golang.org/cl/186076
This commit is contained in:
Charles L. Dorian 2010-01-11 16:20:51 -08:00 committed by Russ Cox
parent 14992a4e4b
commit 3c7534104a
2 changed files with 124 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
src/pkg/math/all_test.go
View File

@ -1,4 +1,4 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Copyright 2009-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.
@ -58,6 +58,18 @@ var atan = []float64{
1.0696031952318783e+00,
-1.4561721938838085e+00,
}
var ceil = []float64{
5.0000000000000000e+00,
8.0000000000000000e+00,
0.0000000000000000e+00,
-5.0000000000000000e+00,
1.0000000000000000e+01,
3.0000000000000000e+00,
6.0000000000000000e+00,
3.0000000000000000e+00,
2.0000000000000000e+00,
-8.0000000000000000e+00,
}
var exp = []float64{
1.4533071302642137e+02,
2.2958822575694450e+03,
@ -82,6 +94,18 @@ var floor = []float64{
1.0000000000000000e+00,
-9.0000000000000000e+00,
}
var fmod = []float64{
4.1976150232653000e-02,
2.2611275254218955e+00,
3.2317941087942760e-02,
4.9893963817289251e+00,
3.6370629280158270e-01,
1.2208682822681062e+00,
4.7709165685406934e+00,
1.8161802686919694e+00,
8.7345954159572500e-01,
1.3140752314243987e+00,
}
var log = []float64{
1.6052314626930630e+00,
2.0462560018708768e+00,
@ -185,6 +209,72 @@ var vfatanSC = []float64{
var atanSC = []float64{
NaN(),
}
var vffmodSC = [][2]float64{
[2]float64{Inf(-1), Inf(-1)},
[2]float64{Inf(-1), -Pi},
[2]float64{Inf(-1), 0},
[2]float64{Inf(-1), Pi},
[2]float64{Inf(-1), Inf(1)},
[2]float64{Inf(-1), NaN()},
[2]float64{-Pi, Inf(-1)},
[2]float64{-Pi, 0},
[2]float64{-Pi, Inf(1)},
[2]float64{-Pi, NaN()},
[2]float64{0, Inf(-1)},
[2]float64{0, 0},
[2]float64{0, Inf(1)},
[2]float64{0, NaN()},
[2]float64{Pi, Inf(-1)},
[2]float64{Pi, 0},
[2]float64{Pi, Inf(1)},
[2]float64{Pi, NaN()},
[2]float64{Inf(1), Inf(-1)},
[2]float64{Inf(1), -Pi},
[2]float64{Inf(1), 0},
[2]float64{Inf(1), Pi},
[2]float64{Inf(1), Inf(1)},
[2]float64{Inf(1), NaN()},
[2]float64{NaN(), Inf(-1)},
[2]float64{NaN(), -Pi},
[2]float64{NaN(), 0},
[2]float64{NaN(), Pi},
[2]float64{NaN(), Inf(1)},
[2]float64{NaN(), NaN()},
}
var fmodSC = []float64{
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
-Pi,
NaN(),
-Pi,
NaN(),
0,
NaN(),
0,
NaN(),
Pi,
NaN(),
Pi,
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
NaN(),
}
var vfpowSC = [][2]float64{
[2]float64{-Pi, Pi},
[2]float64{-Pi, -Pi},
@ -344,6 +434,14 @@ func TestAtan(t *testing.T) {
}
}
func TestCeil(t *testing.T) {
for i := 0; i < len(vf); i++ {
if f := Ceil(vf[i]); ceil[i] != f {
t.Errorf("Ceil(%g) = %g, want %g\n", vf[i], f, ceil[i])
}
}
}
func TestExp(t *testing.T) {
for i := 0; i < len(vf); i++ {
if f := Exp(vf[i]); !veryclose(exp[i], f) {
@ -360,6 +458,19 @@ func TestFloor(t *testing.T) {
}
}
func TestFmod(t *testing.T) {
for i := 0; i < len(vf); i++ {
if f := Fmod(10, vf[i]); !close(fmod[i], f) {
t.Errorf("Fmod(10, %.17g) = %.17g, want %.17g\n", vf[i], f, fmod[i])
}
}
for i := 0; i < len(vffmodSC); i++ {
if f := Fmod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
t.Errorf("Fmod(%.17g, %.17g) = %.17g, want %.17g\n", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
}
}
}
func TestLog(t *testing.T) {
for i := 0; i < len(vf); i++ {
a := Fabs(vf[i])

16
src/pkg/math/fmod.go
View File

@ -1,4 +1,4 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Copyright 2009-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.
@ -6,13 +6,21 @@ package math
/*
Floating-point mod func without infinity or NaN checking
Floating-point mod function.
*/
// Fmod returns the floating-point remainder of x/y.
// The magnitude of the result is less than y and its
// sign agrees with that of x.
//
// Special cases are:
// if x is not finite, Fmod returns NaN
// if y is 0 or NaN, Fmod returns NaN
func Fmod(x, y float64) float64 {
if y == 0 {
return x
// TODO(rsc): Remove manual inlining of IsNaN, IsInf
// when compiler does it for us.
if y == 0 || x > MaxFloat64 || x < -MaxFloat64 || x != x || y != y { // y == 0 || IsInf(x, 0) || IsNaN(x) || IsNan(y)
return NaN()
}
if y < 0 {
y = -y