code review 5484076: pkg/math: undo manual inlining of IsInf and IsNaN

src/pkg/math/pow.go

 // Copyright 2009 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 math
 
 func isOddInt(x float64) bool {
         xi, xf := Modf(x)
         return xf == 0 && int64(xi)&1 == 1
 }
@@ skipping 18 matching lines @@
 //      Pow(-1, ±Inf) = 1
 //      Pow(x, +Inf) = +Inf for |x| > 1
 //      Pow(x, -Inf) = +0 for |x| > 1
 //      Pow(x, +Inf) = +0 for |x| < 1
 //      Pow(x, -Inf) = +Inf for |x| < 1
 //      Pow(+Inf, y) = +Inf for y > 0
 //      Pow(+Inf, y) = +0 for y < 0
 //      Pow(-Inf, y) = Pow(-0, -y)
 //      Pow(x, y) = NaN for finite x < 0 and finite non-integer y
 func Pow(x, y float64) float64 {
-        // TODO(rsc): Remove manual inlining of IsNaN, IsInf
-        // when compiler does it for us
         switch {
         case y == 0 || x == 1:
                 return 1
         case y == 1:
                 return x
         case y == 0.5:
                 return Sqrt(x)
         case y == -0.5:
                 return 1 / Sqrt(x)
-        case x != x || y != y: // IsNaN(x) || IsNaN(y):
+        case IsNaN(x) || IsNaN(y):
                 return NaN()
         case x == 0:
                 switch {
                 case y < 0:
                         if isOddInt(y) {
                                 return Copysign(Inf(1), x)
                         }
                         return Inf(1)
                 case y > 0:
                         if isOddInt(y) {
                                 return x
                         }
                         return 0
                 }
-        case y > MaxFloat64 || y < -MaxFloat64: // IsInf(y, 0):
+        case IsInf(y, 0):
                 switch {
                 case x == -1:
                         return 1
                 case (Abs(x) < 1) == IsInf(y, 1):
                         return 0
                 default:
                         return Inf(1)
                 }
-        case x > MaxFloat64 || x < -MaxFloat64: // IsInf(x, 0):
+        case IsInf(x, 0):
                 if IsInf(x, -1) {
                         return Pow(1/x, -y) // Pow(-0, -y)
                 }
                 switch {
                 case y < 0:
                         return 0
                 case y > 0:
                         return Inf(1)
                 }
         }
@@ skipping 45 matching lines @@
 
         // ans = a1*2**ae
         // if flip { ans = 1 / ans }
         // but in the opposite order
         if flip {
                 a1 = 1 / a1
                 ae = -ae
         }
         return Ldexp(a1, ae)
 }