httpserver.go\
imagenew.go\
main.go\
+ math.go\
netdial.go\
netudpgroup.go\
oserrorstring.go\
--- /dev/null
+// Copyright 2011 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 main
+
+import (
+ "fmt"
+ "os"
+ "go/ast"
+)
+
+var _ fmt.Stringer
+var _ os.Error
+
+var mathFix = fix{
+ "math",
+ math,
+ `Remove the leading F from math functions such as Fabs.
+
+http://codereview.appspot.com/5158043
+`,
+}
+
+func init() {
+ register(mathFix)
+}
+
+var mathRenames = []struct{ in, out string }{
+ {"Fabs", "Abs"},
+ {"Fdim", "Dim"},
+ {"Fmax", "Max"},
+ {"Fmin", "Min"},
+ {"Fmod", "Mod"},
+}
+
+func math(f *ast.File) bool {
+ if !imports(f, "math") {
+ return false
+ }
+
+ fixed := false
+
+ walk(f, func(n interface{}) {
+ // Rename functions.
+ if expr, ok := n.(ast.Expr); ok {
+ for _, s := range mathRenames {
+ if isPkgDot(expr, "math", s.in) {
+ expr.(*ast.SelectorExpr).Sel.Name = s.out
+ fixed = true
+ return
+ }
+ }
+ }
+ })
+ return fixed
+}
--- /dev/null
+// Copyright 2011 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 main
+
+func init() {
+ addTestCases(mathTests)
+}
+
+var mathTests = []testCase{
+ {
+ Name: "math.0",
+ In: `package main
+
+import (
+ "math"
+)
+
+func f() {
+ math.Fabs(1)
+ math.Fdim(1)
+ math.Fmax(1)
+ math.Fmin(1)
+ math.Fmod(1)
+ math.Abs(1)
+ foo.Fabs(1)
+}
+`,
+ Out: `package main
+
+import (
+ "math"
+)
+
+func f() {
+ math.Abs(1)
+ math.Dim(1)
+ math.Max(1)
+ math.Min(1)
+ math.Mod(1)
+ math.Abs(1)
+ foo.Fabs(1)
+}
+`,
+ },
+}
// Asin returns the inverse sine of x.
func Asin(x complex128) complex128 {
if imag(x) == 0 {
- if math.Fabs(real(x)) > 1 {
+ if math.Abs(real(x)) > 1 {
return complex(math.Pi/2, 0) // DOMAIN error
}
return complex(math.Asin(real(x)), 0)
func Asinh(x complex128) complex128 {
// TODO check range
if imag(x) == 0 {
- if math.Fabs(real(x)) > 1 {
+ if math.Abs(real(x)) > 1 {
return complex(math.Pi/2, 0) // DOMAIN error
}
return complex(math.Asinh(real(x)), 0)
// calculate sinh and cosh
func sinhcosh(x float64) (sh, ch float64) {
- if math.Fabs(x) <= 0.5 {
+ if math.Abs(x) <= 0.5 {
return math.Sinh(x), math.Cosh(x)
}
e := math.Exp(x)
b := imag(x)
var scale float64
// Rescale to avoid internal overflow or underflow.
- if math.Fabs(a) > 4 || math.Fabs(b) > 4 {
+ if math.Abs(a) > 4 || math.Abs(b) > 4 {
a *= 0.25
b *= 0.25
scale = 2
var t float64
if a > 0 {
t = math.Sqrt(0.5*r + 0.5*a)
- r = scale * math.Fabs((0.5*b)/t)
+ r = scale * math.Abs((0.5*b)/t)
t *= scale
} else {
r = math.Sqrt(0.5*r - 0.5*a)
- t = scale * math.Fabs((0.5*b)/r)
+ t = scale * math.Abs((0.5*b)/r)
r *= scale
}
if b < 0 {
// Tan returns the tangent of x.
func Tan(x complex128) complex128 {
d := math.Cos(2*real(x)) + math.Cosh(2*imag(x))
- if math.Fabs(d) < 0.25 {
+ if math.Abs(d) < 0.25 {
d = tanSeries(x)
}
if d == 0 {
// Taylor series expansion for cosh(2y) - cos(2x)
func tanSeries(z complex128) float64 {
const MACHEP = 1.0 / (1 << 53)
- x := math.Fabs(2 * real(z))
- y := math.Fabs(2 * imag(z))
+ x := math.Abs(2 * real(z))
+ y := math.Abs(2 * imag(z))
x = reducePi(x)
x = x * x
y = y * y
t = y2 - x2
t /= f
d += t
- if math.Fabs(t/d) <= MACHEP {
+ if math.Abs(t/d) <= MACHEP {
break
}
}
// Cot returns the cotangent of x.
func Cot(x complex128) complex128 {
d := math.Cosh(2*imag(x)) - math.Cos(2*real(x))
- if math.Fabs(d) < 0.25 {
+ if math.Abs(d) < 0.25 {
d = tanSeries(x)
}
if d == 0 {
}
func genString(stddev float64) string {
- n := int(math.Fabs(rand.NormFloat64()*stddev + stddev/2))
+ n := int(math.Abs(rand.NormFloat64()*stddev + stddev/2))
c := make([]int, n)
for i := range c {
- f := math.Fabs(rand.NormFloat64()*64 + 32)
+ f := math.Abs(rand.NormFloat64()*64 + 32)
if f > 0x10ffff {
f = 0x10ffff
}
}
func genArray(n int) []interface{} {
- f := int(math.Fabs(rand.NormFloat64()) * math.Fmin(10, float64(n/2)))
+ f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
if f > n {
f = n
}
}
func genMap(n int) map[string]interface{} {
- f := int(math.Fabs(rand.NormFloat64()) * math.Fmin(10, float64(n/2)))
+ f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
if f > n {
f = n
}
sqrt_arm.$O\
OFILES_amd64=\
+ abs_amd64.$O\
+ dim_amd64.$O\
exp_amd64.$O\
- fabs_amd64.$O\
- fdim_amd64.$O\
hypot_amd64.$O\
log_amd64.$O\
sincos_amd64.$O\
sqrt_amd64.$O\
OFILES_386=\
+ abs_386.$O\
asin_386.$O\
atan_386.$O\
atan2_386.$O\
exp_386.$O\
exp2_386.$O\
expm1_386.$O\
- fabs_386.$O\
floor_386.$O\
frexp_386.$O\
- fmod_386.$O\
hypot_386.$O\
ldexp_386.$O\
log_386.$O\
log10_386.$O\
log1p_386.$O\
+ mod_386.$O\
modf_386.$O\
remainder_386.$O\
sin_386.$O\
$(OFILES_$(GOARCH))
ALLGOFILES=\
+ abs.go\
acosh.go\
asin.go\
asinh.go\
cbrt.go\
const.go\
copysign.go\
+ dim.go\
erf.go\
exp.go\
exp_port.go\
exp2.go\
expm1.go\
- fabs.go\
- fdim.go\
floor.go\
- fmod.go\
frexp.go\
gamma.go\
hypot.go\
log10.go\
log1p.go\
logb.go\
+ mod.go\
modf.go\
nextafter.go\
pow.go\
package math
-// Fabs returns the absolute value of x.
+// Abs returns the absolute value of x.
//
// Special cases are:
-// Fabs(+Inf) = +Inf
-// Fabs(-Inf) = +Inf
-// Fabs(NaN) = NaN
-func Fabs(x float64) float64 {
+// Abs(+Inf) = +Inf
+// Abs(-Inf) = +Inf
+// Abs(NaN) = NaN
+func Abs(x float64) float64 {
switch {
case x < 0:
return -x
case x == 0:
- return 0 // return correctly fabs(-0)
+ return 0 // return correctly abs(-0)
}
return x
}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// func Fabs(x float64) float64
-TEXT ·Fabs(SB),7,$0
+// func Abs(x float64) float64
+TEXT ·Abs(SB),7,$0
FMOVD x+0(FP), F0 // F0=x
FABS // F0=|x|
FMOVDP F0, r+8(FP)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// func Fabs(x float64) float64
-TEXT ·Fabs(SB),7,$0
+// func Abs(x float64) float64
+TEXT ·Abs(SB),7,$0
MOVQ $(1<<63), BX
MOVQ BX, X0 // movsd $(-0.0), x0
MOVSD x+0(FP), X1
package math
-func Fabs(x float64) float64
+func Abs(x float64) float64
func TestAcosh(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := 1 + Fabs(vf[i])
+ a := 1 + Abs(vf[i])
if f := Acosh(a); !veryclose(acosh[i], f) {
t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
}
}
}
-func TestFabs(t *testing.T) {
+func TestAbs(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Fabs(vf[i]); fabs[i] != f {
- t.Errorf("Fabs(%g) = %g, want %g", vf[i], f, fabs[i])
+ if f := Abs(vf[i]); fabs[i] != f {
+ t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i])
}
}
for i := 0; i < len(vffabsSC); i++ {
- if f := Fabs(vffabsSC[i]); !alike(fabsSC[i], f) {
- t.Errorf("Fabs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
+ if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) {
+ t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
}
}
}
-func TestFdim(t *testing.T) {
+func TestDim(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Fdim(vf[i], 0); fdim[i] != f {
- t.Errorf("Fdim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
+ if f := Dim(vf[i], 0); fdim[i] != f {
+ t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
}
}
}
}
}
-func TestFmax(t *testing.T) {
+func TestMax(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Fmax(vf[i], ceil[i]); ceil[i] != f {
- t.Errorf("Fmax(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
+ if f := Max(vf[i], ceil[i]); ceil[i] != f {
+ t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
}
}
}
-func TestFmin(t *testing.T) {
+func TestMin(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Fmin(vf[i], floor[i]); floor[i] != f {
- t.Errorf("Fmin(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
+ if f := Min(vf[i], floor[i]); floor[i] != f {
+ t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
}
}
}
-func TestFmod(t *testing.T) {
+func TestMod(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Fmod(10, vf[i]); fmod[i] != f {
- t.Errorf("Fmod(10, %g) = %g, want %g", vf[i], f, fmod[i])
+ if f := Mod(10, vf[i]); fmod[i] != f {
+ t.Errorf("Mod(10, %g) = %g, want %g", 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(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
+ if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
+ t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
}
}
}
func TestHypot(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(1e200 * tanh[i] * Sqrt(2))
+ a := Abs(1e200 * tanh[i] * Sqrt(2))
if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
}
func TestLog(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := Log(a); log[i] != f {
t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
}
func TestLog10(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := Log10(a); !veryclose(log10[i], f) {
t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
}
func TestLog2(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := Log2(a); !veryclose(log2[i], f) {
t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i])
}
func TestSqrt(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := SqrtGo(a); sqrt[i] != f {
t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
}
- a = Fabs(vf[i])
+ a = Abs(vf[i])
if f := Sqrt(a); sqrt[i] != f {
t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
}
func TestY0(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := Y0(a); !close(y0[i], f) {
t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
}
func TestY1(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := Y1(a); !soclose(y1[i], f, 2e-14) {
t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
}
func TestYn(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i])
+ a := Abs(vf[i])
if f := Yn(2, a); !close(y2[i], f) {
t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
}
}
}
-func BenchmarkFabs(b *testing.B) {
+func BenchmarkAbs(b *testing.B) {
for i := 0; i < b.N; i++ {
- Fabs(.5)
+ Abs(.5)
}
}
-func BenchmarkFdim(b *testing.B) {
+func BenchmarkDim(b *testing.B) {
for i := 0; i < b.N; i++ {
- Fdim(10, 3)
+ Dim(10, 3)
}
}
}
}
-func BenchmarkFmax(b *testing.B) {
+func BenchmarkMax(b *testing.B) {
for i := 0; i < b.N; i++ {
- Fmax(10, 3)
+ Max(10, 3)
}
}
-func BenchmarkFmin(b *testing.B) {
+func BenchmarkMin(b *testing.B) {
for i := 0; i < b.N; i++ {
- Fmin(10, 3)
+ Min(10, 3)
}
}
-func BenchmarkFmod(b *testing.B) {
+func BenchmarkMod(b *testing.B) {
for i := 0; i < b.N; i++ {
- Fmod(10, 3)
+ Mod(10, 3)
}
}
// satisfying x == y × 2**exp. It assumes x is finite and non-zero.
func normalize(x float64) (y float64, exp int) {
const SmallestNormal = 2.2250738585072014e-308 // 2**-1022
- if Fabs(x) < SmallestNormal {
+ if Abs(x) < SmallestNormal {
return x * (1 << 52), -52
}
return x, 0
package math
-// Fdim returns the maximum of x-y or 0.
-func Fdim(x, y float64) float64 {
+// Dim returns the maximum of x-y or 0.
+func Dim(x, y float64) float64 {
if x > y {
return x - y
}
return 0
}
-// Fmax returns the larger of x or y.
-func Fmax(x, y float64) float64 {
+// Max returns the larger of x or y.
+func Max(x, y float64) float64 {
if x > y {
return x
}
return y
}
-// Fmin returns the smaller of x or y.
-func Fmin(x, y float64) float64 {
+// Min returns the smaller of x or y.
+func Min(x, y float64) float64 {
if x < y {
return x
}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// func Fdim(x, y float64) float64
-TEXT ·Fdim(SB),7,$0
+// func Dim(x, y float64) float64
+TEXT ·Dim(SB),7,$0
MOVSD x+0(FP), X0
SUBSD y+8(FP), X0
MOVSD $(0.0), X1
MOVSD X0, r+16(FP)
RET
-// func Fmax(x, y float64) float64
-TEXT ·Fmax(SB),7,$0
+// func ·Max(x, y float64) float64
+TEXT ·Max(SB),7,$0
MOVSD x+0(FP), X0
MAXSD y+8(FP), X0
MOVSD X0, r+16(FP)
RET
-// func Fmin(x, y float64) float64
-TEXT ·Fmin(SB),7,$0
+// func Min(x, y float64) float64
+TEXT ·Min(SB),7,$0
MOVSD x+0(FP), X0
MINSD y+8(FP), X0
MOVSD X0, r+16(FP)
package math
-func Fdim(x, y float64) float64
-func Fmax(x, y float64) float64
-func Fmin(x, y float64) float64
+func Dim(x, y float64) float64
+func Max(x, y float64) float64
+func Min(x, y float64) float64
case x < -170.5674972726612 || x > 171.61447887182298:
return Inf(1)
}
- q := Fabs(x)
+ q := Abs(x)
p := Floor(q)
if q > 33 {
if x >= 0 {
if z == 0 {
return Inf(signgam)
}
- z = Pi / (Fabs(z) * stirling(q))
+ z = Pi / (Abs(z) * stirling(q))
return float64(signgam) * z
}
tmp := float64(n)
v := 2 / x
- tmp = tmp * Log(Fabs(v*tmp))
+ tmp = tmp * Log(Abs(v*tmp))
if tmp < 7.09782712893383973096e+02 {
for i := n - 1; i > 0; i-- {
di := float64(i + i)
lgamma = Inf(1) // -integer
return
}
- nadj = Log(Pi / Fabs(t*x))
+ nadj = Log(Pi / Abs(t*x))
if t < 0 {
sign = -1
}
z := Floor(x)
var n int
if z != x { // inexact
- x = Fmod(x, 2)
+ x = Mod(x, 2)
n = int(x * 4)
} else {
if x >= Two53 { // x must be even
Floating-point mod function.
*/
-// Fmod returns the floating-point remainder of x/y.
+// Mod 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 x is not finite, Mod returns NaN
+// if y is 0 or NaN, Mod returns NaN
+func Mod(x, y float64) float64 {
// 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)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// func Fmod(x, y float64) float64
-TEXT ·Fmod(SB),7,$0
+// func Mod(x, y float64) float64
+TEXT ·Mod(SB),7,$0
FMOVD y+8(FP), F0 // F0=y
FMOVD x+0(FP), F0 // F0=x, F1=y
FPREM // F0=reduced_x, F1=y
package math
-func Fmod(x, y float64) float64
+func Mod(x, y float64) float64
switch {
case x == -1:
return 1
- case (Fabs(x) < 1) == IsInf(y, 1):
+ case (Abs(x) < 1) == IsInf(y, 1):
return 0
default:
return Inf(1)
// precision arithmetic, where [x/y] is the (infinite bit)
// integer nearest x/y (in half way cases, choose the even one).
// Method :
-// Based on fmod() returning x - [x/y]chopped * y exactly.
+// Based on Mod() returning x - [x/y]chopped * y exactly.
// Remainder returns the IEEE 754 floating-point remainder of x/y.
//
return 0
}
if y <= HalfMax {
- x = Fmod(x, y+y) // now x < 2y
+ x = Mod(x, y+y) // now x < 2y
}
if y < Tiny {
if x+x > y {
}
func nearEqual(a, b, closeEnough, maxError float64) bool {
- absDiff := math.Fabs(a - b)
+ absDiff := math.Abs(a - b)
if absDiff < closeEnough { // Necessary when one value is zero and one value is close to zero.
return true
}
- return absDiff/max(math.Fabs(a), math.Fabs(b)) < maxError
+ return absDiff/max(math.Abs(a), math.Abs(b)) < maxError
}
var testSeeds = []int64{1, 1754801282, 1698661970, 1550503961}