cmath: correct IsNaN for argument cmplx(Inf, NaN)

R=rsc
CC=golang-dev
https://golang.org/cl/1705041

diff --git a/src/pkg/cmath/cmath_test.go b/src/pkg/cmath/cmath_test.go
index 44706d362e438e853ac2009b2c59e4adadbdf5af..25e4f225437f398d5c2c06d68456b00068e0cafd 100644 (file)
--- a/src/pkg/cmath/cmath_test.go
+++ b/src/pkg/cmath/cmath_test.go
@@ -38,8 +38,7 @@ var vc = []complex128{
 // at http://keisan.casio.com/.  More exact input values (array vc[], above)
 // were obtained by printing them with "%.26f".  The answers were calculated
 // to 26 digits (by using the "Digit number" drop-down control of each
-// calculator).  Twenty-six digits were chosen so that the answers would be
-// accurate even for a float128 type.
+// calculator).
 
 var abs = []float64{
        9.2022120669932650313380972e+00,
@@ -355,6 +354,28 @@ var vcExpSC = []complex128{
 var expSC = []complex128{
        NaN(),
 }
+var vcIsNaNSC = []complex128{
+       cmplx(math.Inf(-1), math.Inf(-1)),
+       cmplx(math.Inf(-1), math.NaN()),
+       cmplx(math.NaN(), math.Inf(-1)),
+       cmplx(0, math.NaN()),
+       cmplx(math.NaN(), 0),
+       cmplx(math.Inf(1), math.Inf(1)),
+       cmplx(math.Inf(1), math.NaN()),
+       cmplx(math.NaN(), math.Inf(1)),
+       cmplx(math.NaN(), math.NaN()),
+}
+var isNaNSC = []bool{
+       false,
+       false,
+       false,
+       true,
+       true,
+       false,
+       false,
+       false,
+       true,
+}
 var vcLogSC = []complex128{
        NaN(),
 }
@@ -432,7 +453,7 @@ func alike(a, b float64) bool {
        case a != a && b != b: // math.IsNaN(a) && math.IsNaN(b):
                return true
        case a == b:
-               return true
+               return math.Signbit(a) == math.Signbit(b)
        }
        return false
 }
@@ -454,7 +475,7 @@ func cAlike(a, b complex128) bool {
        case IsNaN(a) && IsNaN(b):
                return true
        case a == b:
-               return true
+               return math.Signbit(real(a)) == math.Signbit(real(b)) && math.Signbit(imag(a)) == math.Signbit(imag(b))
        }
        return false
 }
@@ -591,6 +612,13 @@ func TestExp(t *testing.T) {
                }
        }
 }
+func TestIsNaN(t *testing.T) {
+       for i := 0; i < len(vcIsNaNSC); i++ {
+               if f := IsNaN(vcIsNaNSC[i]); isNaNSC[i] != f {
+                       t.Errorf("IsNaN(%g) = %g, want %g\n", vcIsNaNSC[i], f, isNaNSC[i])
+               }
+       }
+}
 func TestLog(t *testing.T) {
        for i := 0; i < len(vc); i++ {
                if f := Log(vc[i]); !cVeryclose(log[i], f) {

diff --git a/src/pkg/cmath/isnan.go b/src/pkg/cmath/isnan.go
index 29b760135abb24e6596517eb4b6f1129359bd3fe..8e971dbd3c4e2498ef3649e56d1863fa70fa7887 100644 (file)
--- a/src/pkg/cmath/isnan.go
+++ b/src/pkg/cmath/isnan.go
@@ -6,9 +6,13 @@ package cmath
 
 import "math"
 
-// IsNaN returns true if either real(x) or imag(x) is NaN.
+// IsNaN returns true if either real(x) or imag(x) is NaN
+// and neither is an infinity.
 func IsNaN(x complex128) bool {
-       if math.IsNaN(real(x)) || math.IsNaN(imag(x)) {
+       switch {
+       case math.IsInf(real(x), 0) || math.IsInf(imag(x), 0):
+               return false
+       case math.IsNaN(real(x)) || math.IsNaN(imag(x)):
                return true
        }
        return false