atan2_386.$O\
exp_386.$O\
exp2_386.$O\
+ expm1_386.$O\
fabs_386.$O\
floor_386.$O\
frexp_386.$O\
log_386.$O\
log1p_386.$O\
modf_386.$O\
+ remainder_386.$O\
sin_386.$O\
sincos_386.$O\
sqrt_386.$O\
fmod.go\
frexp.go\
hypot.go\
+ logb.go\
lgamma.go\
ldexp.go\
log.go\
nextafter.go\
pow.go\
pow10.go\
+ remainder.go\
sin.go\
sincos.go\
sinh.go\
6.0174879014578057187016475e-01,
2.161703872847352815363655e+00,
}
+var logb = []float64{
+ 3.0000000000000000e+00,
+ 3.0000000000000000e+00,
+ -1.0000000000000000e+00,
+ 3.0000000000000000e+00,
+ 4.0000000000000000e+00,
+ 2.0000000000000000e+00,
+ 3.0000000000000000e+00,
+ 2.0000000000000000e+00,
+ 1.0000000000000000e+00,
+ 4.0000000000000000e+00,
+}
var log10 = []float64{
6.9714316642508290997617083e-01,
8.886776901739320576279124e-01,
6.688182138451414936380374e+01,
2.0609869004248742886827439e-09,
}
+var remainder = []float64{
+ 4.197615023265299782906368e-02,
+ 2.261127525421895434476482e+00,
+ 3.231794108794261433104108e-02,
+ -2.120723654214984321697556e-02,
+ 3.637062928015826201999516e-01,
+ 1.220868282268106064236690e+00,
+ -4.581668629186133046005125e-01,
+ -9.117596417440410050403443e-01,
+ 8.734595415957246977711748e-01,
+ 1.314075231424398637614104e+00,
+}
var sin = []float64{
-9.6466616586009283766724726e-01,
9.9338225271646545763467022e-01,
NaN(),
}
+var vfilogbSC = []float64{
+ Inf(-1),
+ 0,
+ Inf(1),
+ NaN(),
+}
+var ilogbSC = []int{
+ MaxInt32,
+ MinInt32,
+ MaxInt32,
+ MaxInt32,
+}
+
var vflgammaSC = []float64{
Inf(-1),
-3,
NaN(),
}
+var vflogbSC = []float64{
+ Inf(-1),
+ 0,
+ Inf(1),
+ NaN(),
+}
+var logbSC = []float64{
+ Inf(1),
+ Inf(-1),
+ Inf(1),
+ NaN(),
+}
+
var vflog1pSC = []float64{
Inf(-1),
-Pi,
func TestFmod(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Fmod(10, vf[i]); fmod[i] != f { /*!close(fmod[i], f)*/
+ if f := Fmod(10, vf[i]); fmod[i] != f {
t.Errorf("Fmod(10, %g) = %g, want %g\n", vf[i], f, fmod[i])
}
}
}
}
+func TestIlogb(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if e := Ilogb(vf[i]); frexp[i].i != e {
+ t.Errorf("Ilogb(%g) = %d, want %d\n", vf[i], e, frexp[i].i)
+ }
+ }
+ for i := 0; i < len(vflogbSC); i++ {
+ if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e {
+ t.Errorf("Ilogb(%g) = %d, want %d\n", vflogbSC[i], e, ilogbSC[i])
+ }
+ }
+}
+
func TestLdexp(t *testing.T) {
for i := 0; i < len(vf); i++ {
if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) {
}
}
+func TestLogb(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := Logb(vf[i]); logb[i] != f {
+ t.Errorf("Logb(%g) = %g, want %g\n", vf[i], f, logb[i])
+ }
+ }
+ for i := 0; i < len(vflogbSC); i++ {
+ if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) {
+ t.Errorf("Logb(%g) = %g, want %g\n", vflogbSC[i], f, logbSC[i])
+ }
+ }
+}
+
func TestLog10(t *testing.T) {
for i := 0; i < len(vf); i++ {
a := Fabs(vf[i])
}
}
+func TestRemainder(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := Remainder(10, vf[i]); remainder[i] != f {
+ t.Errorf("Remainder(10, %g) = %g, want %g\n", vf[i], f, remainder[i])
+ }
+ }
+ for i := 0; i < len(vffmodSC); i++ {
+ if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
+ t.Errorf("Remainder(%g, %g) = %g, want %g\n", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
+ }
+ }
+}
+
func TestSin(t *testing.T) {
for i := 0; i < len(vf); i++ {
if f := Sin(vf[i]); !close(sin[i], f) {
}
}
+func BenchmarkIlogb(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Ilogb(.5)
+ }
+}
+
func BenchmarkLdexp(b *testing.B) {
for i := 0; i < b.N; i++ {
Ldexp(.5, 2)
}
}
+func BenchmarkLogb(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Logb(.5)
+ }
+}
+
func BenchmarkLog10(b *testing.B) {
for i := 0; i < b.N; i++ {
Log10(.5)
}
}
+func BenchmarkRemainder(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Remainder(10, 3)
+ }
+}
+
func BenchmarkSin(b *testing.B) {
for i := 0; i < b.N; i++ {
Sin(.5)
CMPL AX, $0x7ff00000
JEQ not_finite
FLDL2E // F0=log2(e)
- FMOVD x+0(FP), F0 // F0=x, F1=log2(e)
- FMULDP F0, F1 // F0=x*log2(e)
+ FMULD x+0(FP), F0 // F0=x*log2(e)
FMOVD F0, F1 // F0=x*log2(e), F1=x*log2(e)
FRNDINT // F0=int(x*log2(e)), F1=x*log2(e)
FSUBD F0, F1 // F0=int(x*log2(e)), F1=x*log2(e)-int(x*log2(e))
JNE not_neginf
CMPL CX, $0
JNE not_neginf
- MOVL $0, r+8(FP)
- MOVL $0, r+12(FP)
+ FLDZ // F0=0
+ FMOVDP F0, r+8(FP)
RET
not_neginf:
MOVL CX, r+8(FP)
--- /dev/null
+// 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.
+
+// func Expm1(x float64) float64
+TEXT ·Expm1(SB),7,$0
+ FLDLN2 // F0=log(2) = 1/log2(e) ~ 0.693147
+ FMOVD x+0(FP), F0 // F0=x, F1=1/log2(e)
+ FABS // F0=|x|, F1=1/log2(e)
+ FUCOMPP F0, F1 // compare F0 to F1
+ FSTSW AX
+ SAHF
+ JCC use_exp // jump if F0 >= F1
+ FLDL2E // F0=log2(e)
+ FMULD x+0(FP), F0 // F0=x*log2(e) (-1<F0<1)
+ F2XM1 // F0=e**x-1 = 2**(x*log2(e))-1
+ FMOVDP F0, r+8(FP)
+ RET
+use_exp:
+// test bits for not-finite
+ MOVL x+4(FP), AX
+ ANDL $0x7ff00000, AX
+ CMPL AX, $0x7ff00000
+ JEQ not_finite
+ FLDL2E // F0=log2(e)
+ FMULD x+0(FP), F0 // F0=x*log2(e)
+ FMOVD F0, F1 // F0=x*log2(e), F1=x*log2(e)
+ FRNDINT // F0=int(x*log2(e)), F1=x*log2(e)
+ FSUBD F0, F1 // F0=int(x*log2(e)), F1=x*log2(e)-int(x*log2(e))
+ FXCHD F0, F1 // F0=x*log2(e)-int(x*log2(e)), F1=int(x*log2(e))
+ F2XM1 // F0=2**(x*log2(e)-int(x*log2(e)))-1, F1=int(x*log2(e))
+ FLD1 // F0=1, F1=2**(x*log2(e)-int(x*log2(e)))-1, F2=int(x*log2(e))
+ FADDDP F0, F1 // F0=2**(x*log2(e)-int(x*log2(e))), F1=int(x*log2(e))
+ FSCALE // F0=e**x, F1=int(x*log2(e))
+ FMOVDP F0, F1 // F0=e**x
+ FLD1 // F0=1, F1=e**x
+ FSUBDP F0, F1 // F0=e**x-1
+ FMOVDP F0, r+8(FP)
+ RET
+not_finite:
+// test bits for -Inf
+ MOVL x+4(FP), BX
+ MOVL x+0(FP), CX
+ CMPL BX, $0xfff00000
+ JNE not_neginf
+ CMPL CX, $0
+ JNE not_neginf
+ FLD1 // F0=1
+ FCHS // F0=-1
+ FMOVDP F0, r+8(FP)
+ RET
+not_neginf:
+ MOVL CX, r+8(FP)
+ MOVL BX, r+12(FP)
+ RET
--- /dev/null
+// 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 math
+
+func Expm1(x float64) float64
--- /dev/null
+// 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 math
+
+// Logb(x) returns the binary logarithm of non-zero x.
+//
+// Special cases are:
+// Logb(±Inf) = +Inf
+// Logb(0) = -Inf
+// Logb(NaN) = NaN
+func Logb(x float64) float64 {
+ // TODO(rsc): Remove manual inlining of IsNaN, IsInf
+ // when compiler does it for us
+ // special cases
+ switch {
+ case x == 0:
+ return Inf(-1)
+ case x < -MaxFloat64 || x > MaxFloat64: // IsInf(x, 0):
+ return Inf(1)
+ case x != x: // IsNaN(x):
+ return x
+ }
+ return float64(int((Float64bits(x)>>shift)&mask) - bias)
+}
+
+// Ilogb(x) returns the binary logarithm of non-zero x as an integer.
+//
+// Special cases are:
+// Ilogb(±Inf) = MaxInt32
+// Ilogb(0) = MinInt32
+// Ilogb(NaN) = MaxInt32
+func Ilogb(x float64) int {
+ // TODO(rsc): Remove manual inlining of IsNaN, IsInf
+ // when compiler does it for us
+ // special cases
+ switch {
+ case x == 0:
+ return MinInt32
+ case x != x: // IsNaN(x):
+ return MaxInt32
+ case x < -MaxFloat64 || x > MaxFloat64: // IsInf(x, 0):
+ return MaxInt32
+ }
+ return int((Float64bits(x)>>shift)&mask) - bias
+}
--- /dev/null
+// 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 math
+
+// The original C code and the the comment below are from
+// FreeBSD's /usr/src/lib/msun/src/e_remainder.c and came
+// with this notice. The go code is a simplified version of
+// the original C.
+//
+// ====================================================
+// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+//
+// Developed at SunPro, a Sun Microsystems, Inc. business.
+// Permission to use, copy, modify, and distribute this
+// software is freely granted, provided that this notice
+// is preserved.
+// ====================================================
+//
+// __ieee754_remainder(x,y)
+// Return :
+// returns x REM y = x - [x/y]*y as if in infinite
+// 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.
+
+// Remainder returns the IEEE 754 floating-point remainder of x/y.
+//
+// Special cases are:
+// Remainder(x, NaN) = NaN
+// Remainder(NaN, y) = NaN
+// Remainder(Inf, y) = NaN
+// Remainder(x, 0) = NaN
+// Remainder(x, Inf) = x
+func Remainder(x, y float64) float64 {
+ const (
+ Tiny = 4.45014771701440276618e-308 // 0x0020000000000000
+ HalfMax = MaxFloat64 / 2
+ )
+ // TODO(rsc): Remove manual inlining of IsNaN, IsInf
+ // when compiler does it for us
+ // special cases
+ switch {
+ case x != x || y != y || x < -MaxFloat64 || x > MaxFloat64 || y == 0: // IsNaN(x) || IsNaN(y) || IsInf(x, 0) || y == 0:
+ return NaN()
+ case y < -MaxFloat64 || y > MaxFloat64: // IsInf(y):
+ return x
+ }
+ sign := false
+ if x < 0 {
+ x = -x
+ sign = true
+ }
+ if y < 0 {
+ y = -y
+ }
+ if x == y {
+ return 0
+ }
+ if y <= HalfMax {
+ x = Fmod(x, y+y) // now x < 2y
+ }
+ if y < Tiny {
+ if x+x > y {
+ x -= y
+ if x+x >= y {
+ x -= y
+ }
+ }
+ } else {
+ yHalf := 0.5 * y
+ if x > yHalf {
+ x -= y
+ if x >= yHalf {
+ x -= y
+ }
+ }
+ }
+ if sign {
+ x = -x
+ }
+ return x
+}
--- /dev/null
+// 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.
+
+// func Remainder(x, y float64) float64
+TEXT ·Remainder(SB),7,$0
+ FMOVD y+8(FP), F0 // F0=y
+ FMOVD x+0(FP), F0 // F0=x, F1=y
+ FPREM1 // F0=reduced_x, F1=y
+ FSTSW AX // AX=status word
+ ANDW $0x0400, AX
+ JNE -3(PC) // jump if reduction incomplete
+ FMOVDP F0, F1 // F0=x-q*y
+ FMOVDP F0, r+16(FP)
+ RET
--- /dev/null
+// 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 math
+
+func Remainder(x, y float64) float64