diff options
Diffstat (limited to 'vendor/modernc.org/libc/ccgo_linux_arm64.go')
| -rw-r--r-- | vendor/modernc.org/libc/ccgo_linux_arm64.go | 1636 |
1 files changed, 818 insertions, 818 deletions
diff --git a/vendor/modernc.org/libc/ccgo_linux_arm64.go b/vendor/modernc.org/libc/ccgo_linux_arm64.go index dd003c214..cd1f7cb31 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm64.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm64.go @@ -607,8 +607,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v2 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)<<Int32FromInt32(20))<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) scale2 = *(*float64)(unsafe.Pointer(&v2)) v3 = [2]float64{ - 0: Xcos(tls, y) * exp_x * scale1 * scale2, - 1: Xsin(tls, y) * exp_x * scale1 * scale2, + 0: float64(float64(float64(Xcos(tls, y)*exp_x)*scale1) * scale2), + 1: float64(float64(float64(Xsin(tls, y)*exp_x)*scale1) * scale2), } return *(*complex128)(unsafe.Pointer(&v3)) } @@ -660,8 +660,8 @@ func X__ldexp_cexpf(tls *TLS, z complex64, expt int32) (r complex64) { v2 = Uint32FromInt32((int32(0x7f) + half_expt) << int32(23)) scale2 = *(*float32)(unsafe.Pointer(&v2)) v3 = [2]float32{ - 0: Xcosf(tls, y) * exp_x * scale1 * scale2, - 1: Xsinf(tls, y) * exp_x * scale1 * scale2, + 0: float32(float32(float32(Xcosf(tls, y)*exp_x)*scale1) * scale2), + 1: float32(float32(float32(Xsinf(tls, y)*exp_x)*scale1) * scale2), } return *(*complex64)(unsafe.Pointer(&v3)) } @@ -864,8 +864,8 @@ func Xcasin(tls *TLS, z complex128) (r1 complex128) { x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] v1 = [2]float64{ - 0: float64(1) - (x-y)*(x+y), - 1: -Float64FromFloat64(2) * x * y, + 0: float64(1) - float64((x-y)*(x+y)), + 1: float64(float64(-Float64FromFloat64(2)*x) * y), } w = *(*complex128)(unsafe.Pointer(&v1)) v2 = [2]float64{ @@ -895,7 +895,7 @@ func Xcasinf(tls *TLS, z complex64) (r1 complex64) { y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] v1 = [2]float32{ 0: float32(Float64FromFloat64(1) - float64((x-y)*(x+y))), - 1: float32(-Float64FromFloat64(2) * float64(x) * float64(y)), + 1: float32(float64(float64(-Float64FromFloat64(2)*float64(x)) * float64(y))), } w = *(*complex64)(unsafe.Pointer(&v1)) v2 = [2]float32{ @@ -985,7 +985,7 @@ func __redupi(tls *TLS, x float64) (r float64) { } i = int64(t) /* the multiple */ t = float64(i) - t = x - t*_DP1 - t*_DP2 - t*_DP3 + t = x - float64(t*_DP1) - float64(t*_DP2) - float64(t*_DP3) return t } @@ -1000,17 +1000,17 @@ func Xcatan(tls *TLS, z complex128) (r complex128) { _, _, _, _, _, _, _ = a, t, w, x, x2, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] - x2 = x * x - a = float64(1) - x2 - y*y - t = float64(0.5) * Xatan2(tls, float64(2)*x, a) + x2 = float64(x * x) + a = float64(1) - x2 - float64(y*y) + t = float64(float64(0.5) * Xatan2(tls, float64(float64(2)*x), a)) w = Complex128FromFloat64(__redupi(tls, t)) t = y - float64(1) - a = x2 + t*t + a = x2 + float64(t*t) t = y + float64(1) - a = (x2 + t*t) / a + a = (x2 + float64(t*t)) / a v1 = [2]float64{ 0: Float64FromComplex128(w), - 1: float64(0.25) * Xlog(tls, a), + 1: float64(float64(0.25) * Xlog(tls, a)), } w = *(*complex128)(unsafe.Pointer(&v1)) return w @@ -1037,7 +1037,7 @@ func __redupif(tls *TLS, xx float32) (r float32) { } i = int64(t) /* the multiple */ t = float32(i) - t = float32(float64(x) - float64(t)*_DP11 - float64(t)*_DP21 - float64(t)*_DP31) + t = float32(float64(x) - float64(float64(t)*_DP11) - float64(float64(t)*_DP21) - float64(float64(t)*_DP31)) return t } @@ -1052,17 +1052,17 @@ func Xcatanf(tls *TLS, z complex64) (r complex64) { _, _, _, _, _, _, _ = a, t, w, x, x2, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] - x2 = x * x - a = Float32FromFloat32(1) - x2 - y*y - t = Float32FromFloat32(0.5) * Xatan2f(tls, Float32FromFloat32(2)*x, a) + x2 = float32(x * x) + a = Float32FromFloat32(1) - x2 - float32(y*y) + t = float32(Float32FromFloat32(0.5) * Xatan2f(tls, float32(Float32FromFloat32(2)*x), a)) w = Complex64FromFloat32(__redupif(tls, t)) t = y - Float32FromFloat32(1) - a = x2 + t*t + a = x2 + float32(t*t) t = y + Float32FromFloat32(1) - a = (x2 + t*t) / a + a = (x2 + float32(t*t)) / a v1 = [2]float32{ 0: Float32FromComplex64(w), - 1: Float32FromFloat32(0.25) * Xlogf(tls, a), + 1: float32(Float32FromFloat32(0.25) * Xlogf(tls, a)), } w = *(*complex64)(unsafe.Pointer(&v1)) return w @@ -1183,24 +1183,24 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if iy|ly == 0 { v1 = [2]float64{ 0: Xcosh(tls, x), - 1: x * y, + 1: float64(x * y), } return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ v2 = [2]float64{ - 0: Xcosh(tls, x) * Xcos(tls, y), - 1: Xsinh(tls, x) * Xsin(tls, y), + 0: float64(Xcosh(tls, x) * Xcos(tls, y)), + 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v2)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ - h = Xexp(tls, Xfabs(tls, x)) * float64(0.5) + h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) v3 = [2]float64{ - 0: h * Xcos(tls, y), - 1: Xcopysign(tls, h, x) * Xsin(tls, y), + 0: float64(h * Xcos(tls, y)), + 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v3)) } else { @@ -1213,15 +1213,15 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float64{ 0: Float64FromComplex128(z), - 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x), + 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } return *(*complex128)(unsafe.Pointer(&v5)) } else { /* x >= 1455: the result always overflows */ - h = _huge * x + h = float64(_huge * x) v6 = [2]float64{ - 0: h * h * Xcos(tls, y), - 1: h * Xsin(tls, y), + 0: float64(float64(h*h) * Xcos(tls, y)), + 1: float64(h * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v6)) } @@ -1239,7 +1239,7 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if ix|lx == 0 && iy >= int32(0x7ff00000) { v7 = [2]float64{ 0: y - y, - 1: Xcopysign(tls, Float64FromInt32(0), x*(y-y)), + 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } return *(*complex128)(unsafe.Pointer(&v7)) } @@ -1252,14 +1252,14 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { v8 = [2]float64{ - 0: x * x, - 1: Xcopysign(tls, Float64FromInt32(0), x) * y, + 0: float64(x * x), + 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } return *(*complex128)(unsafe.Pointer(&v8)) } v9 = [2]float64{ - 0: x * x, - 1: Xcopysign(tls, Float64FromInt32(0), (x+x)*y), + 0: float64(x * x), + 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } return *(*complex128)(unsafe.Pointer(&v9)) } @@ -1274,7 +1274,7 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { v10 = [2]float64{ 0: y - y, - 1: x * (y - y), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v10)) } @@ -1290,14 +1290,14 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { v11 = [2]float64{ - 0: x * x, - 1: x * (y - y), + 0: float64(x * x), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v11)) } v12 = [2]float64{ - 0: x * x * Xcos(tls, y), - 1: x * Xsin(tls, y), + 0: float64(float64(x*x) * Xcos(tls, y)), + 1: float64(x * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v12)) } @@ -1313,8 +1313,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero y. Choice = don't raise (except for signaling NaNs). */ v13 = [2]float64{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float64(float64(x*x) * (y - y)), + 1: float64((x + x) * (y - y)), } return *(*complex128)(unsafe.Pointer(&v13)) } @@ -1340,24 +1340,24 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { if iy == 0 { v1 = [2]float32{ 0: Xcoshf(tls, x), - 1: x * y, + 1: float32(x * y), } return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ v2 = [2]float32{ - 0: Xcoshf(tls, x) * Xcosf(tls, y), - 1: Xsinhf(tls, x) * Xsinf(tls, y), + 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), + 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v2)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ - h = Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5) + h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) v3 = [2]float32{ - 0: h * Xcosf(tls, y), - 1: Xcopysignf(tls, h, x) * Xsinf(tls, y), + 0: float32(h * Xcosf(tls, y)), + 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v3)) } else { @@ -1370,15 +1370,15 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float32{ 0: Float32FromComplex64(z), - 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x), + 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } return *(*complex64)(unsafe.Pointer(&v5)) } else { /* x >= 192.7: the result always overflows */ - h = _huge1 * x + h = float32(_huge1 * x) v6 = [2]float32{ - 0: h * h * Xcosf(tls, y), - 1: h * Xsinf(tls, y), + 0: float32(float32(h*h) * Xcosf(tls, y)), + 1: float32(h * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v6)) } @@ -1387,48 +1387,48 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { if ix == 0 && iy >= int32(0x7f800000) { v7 = [2]float32{ 0: y - y, - 1: Xcopysignf(tls, Float32FromInt32(0), x*(y-y)), + 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } return *(*complex64)(unsafe.Pointer(&v7)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { v8 = [2]float32{ - 0: x * x, - 1: Xcopysignf(tls, Float32FromInt32(0), x) * y, + 0: float32(x * x), + 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } return *(*complex64)(unsafe.Pointer(&v8)) } v9 = [2]float32{ - 0: x * x, - 1: Xcopysignf(tls, Float32FromInt32(0), (x+x)*y), + 0: float32(x * x), + 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } return *(*complex64)(unsafe.Pointer(&v9)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { v10 = [2]float32{ 0: y - y, - 1: x * (y - y), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v10)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { v11 = [2]float32{ - 0: x * x, - 1: x * (y - y), + 0: float32(x * x), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v11)) } v12 = [2]float32{ - 0: x * x * Xcosf(tls, y), - 1: x * Xsinf(tls, y), + 0: float32(float32(x*x) * Xcosf(tls, y)), + 1: float32(x * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v12)) } v13 = [2]float32{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float32(float32(x*x) * (y - y)), + 1: float32((x + x) * (y - y)), } return *(*complex64)(unsafe.Pointer(&v13)) } @@ -1529,8 +1529,8 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { */ exp_x = Xexp(tls, x) v6 = [2]float64{ - 0: exp_x * Xcos(tls, y), - 1: exp_x * Xsin(tls, y), + 0: float64(exp_x * Xcos(tls, y)), + 1: float64(exp_x * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v6)) } @@ -1609,8 +1609,8 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { */ exp_x = Xexpf(tls, x) v6 = [2]float32{ - 0: exp_x * Xcosf(tls, y), - 1: exp_x * Xsinf(tls, y), + 0: float32(exp_x * Xcosf(tls, y)), + 1: float32(exp_x * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v6)) } @@ -1945,18 +1945,18 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { } if ix < int32(0x40360000) { /* small x: normal case */ v2 = [2]float64{ - 0: Xsinh(tls, x) * Xcos(tls, y), - 1: Xcosh(tls, x) * Xsin(tls, y), + 0: float64(Xsinh(tls, x) * Xcos(tls, y)), + 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v2)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ - h = Xexp(tls, Xfabs(tls, x)) * float64(0.5) + h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) v3 = [2]float64{ - 0: Xcopysign(tls, h, x) * Xcos(tls, y), - 1: h * Xsin(tls, y), + 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), + 1: float64(h * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v3)) } else { @@ -1968,16 +1968,16 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { } z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float64{ - 0: Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x), + 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } return *(*complex128)(unsafe.Pointer(&v5)) } else { /* x >= 1455: the result always overflows */ - h = _huge2 * x + h = float64(_huge2 * x) v6 = [2]float64{ - 0: h * Xcos(tls, y), - 1: h * h * Xsin(tls, y), + 0: float64(h * Xcos(tls, y)), + 1: float64(float64(h*h) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v6)) } @@ -1994,7 +1994,7 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix|lx == 0 && iy >= int32(0x7ff00000) { v7 = [2]float64{ - 0: Xcopysign(tls, Float64FromInt32(0), x*(y-y)), + 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } return *(*complex128)(unsafe.Pointer(&v7)) @@ -2029,7 +2029,7 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { v10 = [2]float64{ 0: y - y, - 1: x * (y - y), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v10)) } @@ -2047,14 +2047,14 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { v11 = [2]float64{ - 0: x * x, - 1: x * (y - y), + 0: float64(x * x), + 1: float64(x * (y - y)), } return *(*complex128)(unsafe.Pointer(&v11)) } v12 = [2]float64{ - 0: x * Xcos(tls, y), - 1: float64(X__builtin_inff(tls)) * Xsin(tls, y), + 0: float64(x * Xcos(tls, y)), + 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } return *(*complex128)(unsafe.Pointer(&v12)) } @@ -2070,8 +2070,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero y. Choice = don't raise (except for signaling NaNs). */ v13 = [2]float64{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float64(float64(x*x) * (y - y)), + 1: float64((x + x) * (y - y)), } return *(*complex128)(unsafe.Pointer(&v13)) } @@ -2103,18 +2103,18 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } if ix < int32(0x41100000) { /* small x: normal case */ v2 = [2]float32{ - 0: Xsinhf(tls, x) * Xcosf(tls, y), - 1: Xcoshf(tls, x) * Xsinf(tls, y), + 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), + 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v2)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ - h = Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5) + h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) v3 = [2]float32{ - 0: Xcopysignf(tls, h, x) * Xcosf(tls, y), - 1: h * Xsinf(tls, y), + 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), + 1: float32(h * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v3)) } else { @@ -2126,16 +2126,16 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) v5 = [2]float32{ - 0: Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x), + 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } return *(*complex64)(unsafe.Pointer(&v5)) } else { /* x >= 192.7: the result always overflows */ - h = _huge3 * x + h = float32(_huge3 * x) v6 = [2]float32{ - 0: h * Xcosf(tls, y), - 1: h * h * Xsinf(tls, y), + 0: float32(h * Xcosf(tls, y)), + 1: float32(float32(h*h) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v6)) } @@ -2143,7 +2143,7 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } if ix == 0 && iy >= int32(0x7f800000) { v7 = [2]float32{ - 0: Xcopysignf(tls, Float32FromInt32(0), x*(y-y)), + 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } return *(*complex64)(unsafe.Pointer(&v7)) @@ -2165,27 +2165,27 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { v10 = [2]float32{ 0: y - y, - 1: x * (y - y), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v10)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { v11 = [2]float32{ - 0: x * x, - 1: x * (y - y), + 0: float32(x * x), + 1: float32(x * (y - y)), } return *(*complex64)(unsafe.Pointer(&v11)) } v12 = [2]float32{ - 0: x * Xcosf(tls, y), - 1: X__builtin_inff(tls) * Xsinf(tls, y), + 0: float32(x * Xcosf(tls, y)), + 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } return *(*complex64)(unsafe.Pointer(&v12)) } v13 = [2]float32{ - 0: x * x * (y - y), - 1: (x + x) * (y - y), + 0: float32(float32(x*x) * (y - y)), + 1: float32((x + x) * (y - y)), } return *(*complex64)(unsafe.Pointer(&v13)) } @@ -2313,16 +2313,16 @@ _9: } /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { - t = Xsqrt(tls, (a+Xhypot(tls, a, b))*float64(0.5)) + t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) v14 = [2]float64{ 0: t, - 1: b / (Float64FromInt32(2) * t), + 1: b / float64(Float64FromInt32(2)*t), } result = *(*complex128)(unsafe.Pointer(&v14)) } else { - t = Xsqrt(tls, (-a+Xhypot(tls, a, b))*float64(0.5)) + t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) v15 = [2]float64{ - 0: Xfabs(tls, b) / (Float64FromInt32(2) * t), + 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } result = *(*complex128)(unsafe.Pointer(&v15)) @@ -2429,16 +2429,16 @@ _9: * This is Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float32FromInt32(0) { - t = Xsqrt(tls, (float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5)) + t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) v14 = [2]float32{ 0: float32(t), - 1: float32(float64(b) / (Float64FromFloat64(2) * t)), + 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } return *(*complex64)(unsafe.Pointer(&v14)) } else { - t = Xsqrt(tls, (float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5)) + t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) v15 = [2]float32{ - 0: float32(float64(Xfabsf(tls, b)) / (Float64FromFloat64(2) * t)), + 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } return *(*complex64)(unsafe.Pointer(&v15)) @@ -2541,7 +2541,7 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { if y == Float64FromInt32(0) { v2 = y } else { - v2 = x * y + v2 = float64(x * y) } v1 = [2]float64{ 0: x, @@ -2558,7 +2558,7 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { v5 = y } else { - v5 = Xsin(tls, y) * Xcos(tls, y) + v5 = float64(Xsin(tls, y) * Xcos(tls, y)) } v4 = [2]float64{ 0: x, @@ -2597,18 +2597,18 @@ _9: exp_mx = Xexp(tls, -Xfabs(tls, x)) v12 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), - 1: Float64FromInt32(4) * Xsin(tls, y) * Xcos(tls, y) * exp_mx * exp_mx, + 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } return *(*complex128)(unsafe.Pointer(&v12)) } /* Kahan's algorithm */ t = Xtan(tls, y) - beta = float64(1) + t*t /* = 1 / cos^2(y) */ + beta = float64(1) + float64(t*t) /* = 1 / cos^2(y) */ s = Xsinh(tls, x) - rho = Xsqrt(tls, Float64FromInt32(1)+s*s) /* = cosh(x) */ - denom = Float64FromInt32(1) + beta*s*s + rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ + denom = Float64FromInt32(1) + float64(float64(beta*s)*s) v13 = [2]float64{ - 0: beta * rho * s / denom, + 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } return *(*complex128)(unsafe.Pointer(&v13)) @@ -2639,7 +2639,7 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { if y == Float32FromInt32(0) { v2 = y } else { - v2 = x * y + v2 = float32(x * y) } v1 = [2]float32{ 0: x, @@ -2656,7 +2656,7 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { v5 = y } else { - v5 = Xsinf(tls, y) * Xcosf(tls, y) + v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } v4 = [2]float32{ 0: x, @@ -2684,17 +2684,17 @@ _9: exp_mx = Xexpf(tls, -Xfabsf(tls, x)) v12 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), - 1: Float32FromInt32(4) * Xsinf(tls, y) * Xcosf(tls, y) * exp_mx * exp_mx, + 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } return *(*complex64)(unsafe.Pointer(&v12)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) - rho = Xsqrtf(tls, Float32FromInt32(1)+s*s) - denom = Float32FromInt32(1) + beta*s*s + rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) + denom = Float32FromInt32(1) + float32(float32(beta*s)*s) v13 = [2]float32{ - 0: beta * rho * s / denom, + 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } return *(*complex64)(unsafe.Pointer(&v13)) @@ -26219,19 +26219,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Handle zero specially to avoid nasty special cases later */ if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { - return float64(sign) * float64(0) + return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) + return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) } if lrp > int64(-emin/int32(2)) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(1.79769313486231570815e+308) * Float64FromFloat64(1.79769313486231570815e+308) + return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(2.22507385850720138309e-308) * Float64FromFloat64(2.22507385850720138309e-308) + return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ if j != 0 { @@ -26255,14 +26255,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) + return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) } if rp < int32(9) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]) * float64(_p10s[rp-int32(10)]) + return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ @@ -26416,7 +26416,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, z = v30 (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) } - y = Float64FromFloat64(1e+09)*y + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _28 _28: ; @@ -26442,16 +26442,16 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(0.25) * float64(sign) + frac += float64(float64(0.25) * float64(sign)) } else { if t > uint32(500000000) { - frac += float64(0.75) * float64(sign) + frac += float64(float64(0.75) * float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(0.5) * float64(sign) + frac += float64(float64(0.5) * float64(sign)) } else { - frac += float64(0.75) * float64(sign) + frac += float64(float64(0.75) * float64(sign)) } } } @@ -26593,10 +26593,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { scale /= Float64FromInt32(16) - y += float64(d) * scale + y += float64(float64(d) * scale) } else { if d != 0 && !(gottail != 0) { - y += Float64FromFloat64(0.5) * scale + y += float64(Float64FromFloat64(0.5) * scale) gottail = int32(1) } } @@ -26632,7 +26632,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } else { X__shlim(tls, f, int64(Int32FromInt32(0))) } - return float64(sign) * float64(0) + return float64(float64(sign) * float64(0)) } if !(gotrad != 0) { rp = dc @@ -26661,15 +26661,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } e2 += int64(4)*rp - int64(32) if !(x != 0) { - return float64(sign) * float64(0) + return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(1.79769313486231570815e+308) * Float64FromFloat64(1.79769313486231570815e+308) + return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) - return float64(sign) * Float64FromFloat64(2.22507385850720138309e-308) * Float64FromFloat64(2.22507385850720138309e-308) + return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { @@ -26694,7 +26694,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x++ y = Float64FromInt32(0) } - y = bias + float64(sign)*float64(x) + float64(sign)*y + y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y -= bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -28246,7 +28246,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { if !(i < n) { break } - *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8))) + *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)<<Int32FromInt32(SI_LOAD_SHIFT)) * float64(*(*uint64)(unsafe.Pointer(bp + 8 + uintptr(i)*8)))) goto _2 _2: ; @@ -100536,12 +100536,12 @@ func X__cos(tls *TLS, x float64, y float64) (r1 float64) { } var hz, r, w, z Tdouble_t _, _, _, _ = hz, r, w, z - z = x * x - w = z * z - r = z*(_C1+z*(_C2+z*_C3)) + w*w*(_C4+z*(_C5+z*_C6)) - hz = float64(0.5) * z + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = Tdouble_t(z*(_C1+float64(z*(_C2+float64(z*_C3))))) + Tdouble_t(Tdouble_t(w*w)*(_C4+float64(z*(_C5+float64(z*_C6))))) + hz = Tdouble_t(float64(0.5) * z) w = float64(1) - hz - return w + (Float64FromFloat64(1) - w - hz + (z*r - x*y)) + return w + (Float64FromFloat64(1) - w - hz + (Tdouble_t(z*r) - Tdouble_t(x*y))) } // C documentation @@ -100561,10 +100561,10 @@ func X__cosdf(tls *TLS, x float64) (r1 float32) { var r, w, z Tdouble_t _, _, _ = r, w, z /* Try to optimize for parallel evaluation as in __tandf.c. */ - z = x * x - w = z * z - r = _C21 + z*_C31 - return float32(float64(1) + z*_C0 + w*_C11 + w*z*r) + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = _C21 + float64(z*_C31) + return float32(float64(1) + float64(z*_C0) + float64(w*_C11) + float64(Tdouble_t(w*z)*r)) } // C documentation @@ -100589,7 +100589,7 @@ func X__expo2(tls *TLS, x float64, sign float64) (r float64) { scale = *(*float64)(unsafe.Pointer(&v1)) /* exp(x - k ln2) * 2**(k-1) */ /* in directed rounding correct sign before rounding or overflow is important */ - return Xexp(tls, x-_kln22) * (sign * scale) * scale + return float64(float64(Xexp(tls, x-_kln22)*float64(sign*scale)) * scale) } // C documentation @@ -100614,7 +100614,7 @@ func X__expo2f(tls *TLS, x float32, sign float32) (r float32) { scale = *(*float32)(unsafe.Pointer(&v1)) /* exp(x - k ln2) * 2**(k-1) */ /* in directed rounding correct sign before rounding or overflow is important */ - return Xexpf(tls, x-_kln23) * (sign * scale) * scale + return float32(float32(Xexpf(tls, x-_kln23)*float32(sign*scale)) * scale) } func X__fpclassify(tls *TLS, x float64) (r int32) { @@ -100812,7 +100812,7 @@ func X__math_xflow(tls *TLS, sign Tuint32_t, y2 float64) (r float64) { v2 = y1 goto _3 _3: - y = v2 * y2 + y = float64(v2 * y2) v4 = y goto _5 _5: @@ -100835,7 +100835,7 @@ func X__math_xflowf(tls *TLS, sign Tuint32_t, y2 float32) (r float32) { v2 = y1 goto _3 _3: - y = v2 * y2 + y = float32(v2 * y2) v4 = y goto _5 _5: @@ -100916,14 +100916,14 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } } else { if !(sign != 0) { - z = x - Float64FromInt32(2)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z - Float64FromInt32(2)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Float64FromInt32(2)*_pio2_1t + z = x - float64(Float64FromInt32(2)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { - z = x + Float64FromInt32(2)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + Float64FromInt32(2)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Float64FromInt32(2)*_pio2_1t + z = x + float64(Float64FromInt32(2)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -100934,14 +100934,14 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { goto medium } if !(sign != 0) { - z = x - Float64FromInt32(3)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z - Float64FromInt32(3)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Float64FromInt32(3)*_pio2_1t + z = x - float64(Float64FromInt32(3)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { - z = x + Float64FromInt32(3)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + Float64FromInt32(3)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Float64FromInt32(3)*_pio2_1t + z = x + float64(Float64FromInt32(3)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -100949,14 +100949,14 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { goto medium } if !(sign != 0) { - z = x - Float64FromInt32(4)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z - Float64FromInt32(4)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Float64FromInt32(4)*_pio2_1t + z = x - float64(Float64FromInt32(4)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { - z = x + Float64FromInt32(4)*_pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + Float64FromInt32(4)*_pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Float64FromInt32(4)*_pio2_1t + z = x + float64(Float64FromInt32(4)*_pio2_1) + *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -100968,22 +100968,22 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { medium: ; /* rint(x/(pi/2)) */ - fn = x*_invpio2 + _toint - _toint + fn = Tdouble_t(x*_invpio2) + _toint - _toint n = int32(fn) - r = x - fn*_pio2_1 - w = fn * _pio2_1t /* 1st round, good to 85 bits */ + r = x - float64(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) /* 1st round, good to 85 bits */ /* Matters with directed rounding. */ if r-w < -_pio4 { n-- fn-- - r = x - fn*_pio2_1 - w = fn * _pio2_1t + r = x - float64(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) } else { if r-w > _pio4 { n++ fn++ - r = x - fn*_pio2_1 - w = fn * _pio2_1t + r = x - float64(fn*_pio2_1) + w = Tdouble_t(fn * _pio2_1t) } } *(*float64)(unsafe.Pointer(y)) = r - w @@ -100992,17 +100992,17 @@ medium: ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ t = r - w = fn * _pio2_2 + w = Tdouble_t(fn * _pio2_2) r = t - w - w = fn*_pio2_2t - (t - r - w) + w = Tdouble_t(fn*_pio2_2t) - (t - r - w) *(*float64)(unsafe.Pointer(y)) = r - w *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r - w = fn * _pio2_3 + w = Tdouble_t(fn * _pio2_3) r = t - w - w = fn*_pio2_3t - (t - r - w) + w = Tdouble_t(fn*_pio2_3t) - (t - r - w) *(*float64)(unsafe.Pointer(y)) = r - w } } @@ -101030,7 +101030,7 @@ _1: break } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = (z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07) + z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; @@ -101210,7 +101210,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += *(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j] + fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) goto _4 _4: ; @@ -101234,8 +101234,8 @@ recompute: if !(j > 0) { break } - fw = float64(int32(Float64FromFloat64(5.960464477539063e-08) * z)) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - Float64FromFloat64(1.6777216e+07)*fw) + fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) + (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101244,8 +101244,8 @@ recompute: j-- } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(8) * Xfloor(tls, z*float64(0.125)) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) z -= float64(n) ih = 0 @@ -101338,7 +101338,7 @@ recompute: if !(j <= jx) { break } - fw += *(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j] + fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) goto _10 _10: ; @@ -101365,8 +101365,8 @@ recompute: } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { - fw = float64(int32(Float64FromFloat64(5.960464477539063e-08) * z)) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - Float64FromFloat64(1.6777216e+07)*fw) + fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) + (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz += int32(1) q0 += int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) @@ -101381,7 +101381,7 @@ recompute: if !(i >= 0) { break } - q[i] = fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i]) + q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) fw *= float64(5.960464477539063e-08) goto _11 _11: @@ -101400,7 +101400,7 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += _PIo2[k] * q[i+k] + fw += float64(_PIo2[k] * q[i+k]) goto _13 _13: ; @@ -101591,19 +101591,19 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* 25+53 bit pi is good enough for medium size */ if ix < uint32(0x4dc90fdb) { /* |x| ~< 2^28*(pi/2), medium size */ /* Use a specialized rint() to get fn. */ - fn = float64(x)*_invpio21 + _toint1 - _toint1 + fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - fn*_pio2_11 - fn*_pio2_1t1 + *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { n-- fn-- - *(*float64)(unsafe.Pointer(y)) = float64(x) - fn*_pio2_11 - fn*_pio2_1t1 + *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { n++ fn++ - *(*float64)(unsafe.Pointer(y)) = float64(x) - fn*_pio2_11 - fn*_pio2_1t1 + *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n @@ -101700,14 +101700,14 @@ func X__sin(tls *TLS, x float64, y float64, iy int32) (r1 float64) { } var r, v, w, z Tdouble_t _, _, _, _ = r, v, w, z - z = x * x - w = z * z - r = _S2 + z*(_S3+z*_S4) + z*w*(_S5+z*_S6) - v = z * x + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = _S2 + float64(z*(_S3+float64(z*_S4))) + float64(Tdouble_t(z*w)*(_S5+float64(z*_S6))) + v = Tdouble_t(z * x) if iy == 0 { - return x + v*(_S1+z*r) + return x + float64(v*(_S1+float64(z*r))) } else { - return x - (z*(Float64FromFloat64(0.5)*y-v*r) - y - v*_S1) + return x - (Tdouble_t(z*(float64(Float64FromFloat64(0.5)*y)-float64(v*r))) - y - Tdouble_t(v*_S1)) } return r1 } @@ -101729,11 +101729,11 @@ func X__sindf(tls *TLS, x float64) (r1 float32) { var r, s, w, z Tdouble_t _, _, _, _ = r, s, w, z /* Try to optimize for parallel evaluation as in __tandf.c. */ - z = x * x - w = z * z - r = _S31 + z*_S41 - s = z * x - return float32(x + s*(_S11+z*_S21) + s*w*r) + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) + r = _S31 + float64(z*_S41) + s = Tdouble_t(z * x) + return float32(x + float64(s*(_S11+float64(z*_S21))) + float64(Tdouble_t(s*w)*r)) } var _T = [13]float64{ @@ -101776,21 +101776,21 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { x = _pio42 - x + (_pio4lo - y) y = float64(0) } - z = x * x - w = z * z + z = Tdouble_t(x * x) + w = Tdouble_t(z * z) /* * Break x^5*(T[1]+x^2*T[2]+...) into * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) + * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12])) */ - r = _T[int32(1)] + w*(_T[int32(3)]+w*(_T[int32(5)]+w*(_T[int32(7)]+w*(_T[int32(9)]+w*_T[int32(11)])))) - v = z * (_T[int32(2)] + w*(_T[int32(4)]+w*(_T[int32(6)]+w*(_T[int32(8)]+w*(_T[int32(10)]+w*_T[int32(12)]))))) - s = z * x - r = y + z*(s*(r+v)+y) + s*_T[0] + r = _T[int32(1)] + float64(w*(_T[int32(3)]+float64(w*(_T[int32(5)]+float64(w*(_T[int32(7)]+float64(w*(_T[int32(9)]+float64(w*_T[int32(11)]))))))))) + v = Tdouble_t(z * (_T[int32(2)] + float64(w*(_T[int32(4)]+float64(w*(_T[int32(6)]+float64(w*(_T[int32(8)]+float64(w*(_T[int32(10)]+float64(w*_T[int32(12)]))))))))))) + s = Tdouble_t(z * x) + r = y + float64(z*(Tdouble_t(s*(r+v))+y)) + float64(s*_T[0]) w = x + r if big != 0 { s = float64(int32(1) - int32(2)*odd) - v = s - float64(2)*(x+(r-w*w/(w+s))) + v = s - Tdouble_t(float64(2)*(x+(r-Tdouble_t(w*w)/(w+s)))) if sign != 0 { v1 = -v } else { @@ -101811,7 +101811,7 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { a0 = v3 v4 = *(*Tuint64_t)(unsafe.Pointer(&a0))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) a0 = *(*float64)(unsafe.Pointer(&v4)) - return a0 + a*(Float64FromFloat64(1)+a0*w0+a0*v) + return a0 + float64(a*(Float64FromFloat64(1)+float64(a0*w0)+float64(a0*v))) } // C documentation @@ -101834,7 +101834,7 @@ func X__tandf(tls *TLS, x float64, odd int32) (r1 float32) { var r, s, t, u, w, z Tdouble_t var v1 float64 _, _, _, _, _, _, _ = r, s, t, u, w, z, v1 - z = x * x + z = Tdouble_t(x * x) /* * Split up the polynomial into small independent terms to give * opportunities for parallel evaluation. The chosen splitting is @@ -101849,12 +101849,12 @@ func X__tandf(tls *TLS, x float64, odd int32) (r1 float32) { * and would give results as accurate as Horner's method if the * small terms were added from highest degree down. */ - r = _T1[int32(4)] + z*_T1[int32(5)] - t = _T1[int32(2)] + z*_T1[int32(3)] - w = z * z - s = z * x - u = _T1[0] + z*_T1[int32(1)] - r = x + s*u + s*w*(t+w*r) + r = _T1[int32(4)] + float64(z*_T1[int32(5)]) + t = _T1[int32(2)] + float64(z*_T1[int32(3)]) + w = Tdouble_t(z * z) + s = Tdouble_t(z * x) + u = _T1[0] + float64(z*_T1[int32(1)]) + r = x + float64(s*u) + float64(Tdouble_t(s*w)*(t+Tdouble_t(w*r))) if odd != 0 { v1 = -Float64FromFloat64(1) / r } else { @@ -101879,8 +101879,8 @@ var _qS4 = float64(0.07703815055590194) /* 0x3FB3B8C5, 0xB12E9282 */ func _R(tls *TLS, z float64) (r float64) { var p, q Tdouble_t _, _ = p, q - p = z * (_pS0 + z*(_pS1+z*(_pS2+z*(_pS3+z*(_pS4+z*_pS5))))) - q = float64(1) + z*(_qS1+z*(_qS2+z*(_qS3+z*_qS4))) + p = Tdouble_t(z * (_pS0 + float64(z*(_pS1+float64(z*(_pS2+float64(z*(_pS3+float64(z*(_pS4+float64(z*_pS5))))))))))) + q = float64(1) + float64(z*(_qS1+float64(z*(_qS2+float64(z*(_qS3+float64(z*_qS4))))))) return p / q } @@ -101901,7 +101901,7 @@ func Xacos(tls *TLS, x float64) (r float64) { if ix-uint32(0x3ff00000)|lx == uint32(0) { /* acos(1)=0, acos(-1)=pi */ if hx>>int32(31) != 0 { - return Float64FromInt32(2)*_pio2_hi + Float64FromFloat32(7.52316384526264e-37) + return float64(Float64FromInt32(2)*_pio2_hi) + Float64FromFloat32(7.52316384526264e-37) } return Float64FromInt32(0) } @@ -101912,24 +101912,24 @@ func Xacos(tls *TLS, x float64) (r float64) { if ix <= uint32(0x3c600000) { /* |x| < 2**-57 */ return _pio2_hi + Float64FromFloat32(7.52316384526264e-37) } - return _pio2_hi - (x - (_pio2_lo - x*_R(tls, x*x))) + return _pio2_hi - (x - (_pio2_lo - float64(x*_R(tls, float64(x*x))))) } /* x < -0.5 */ if hx>>int32(31) != 0 { - z = (float64(1) + x) * float64(0.5) + z = float64((float64(1) + x) * float64(0.5)) s = Xsqrt(tls, z) - w = _R(tls, z)*s - _pio2_lo - return Float64FromInt32(2) * (_pio2_hi - (s + w)) + w = float64(_R(tls, z)*s) - _pio2_lo + return float64(Float64FromInt32(2) * (_pio2_hi - (s + w))) } /* x > 0.5 */ - z = (float64(1) - x) * float64(0.5) + z = float64((float64(1) - x) * float64(0.5)) s = Xsqrt(tls, z) df = s v1 = *(*Tuint64_t)(unsafe.Pointer(&df))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) df = *(*float64)(unsafe.Pointer(&v1)) - c = (z - df*df) / (s + df) - w = _R(tls, z)*s + c - return Float64FromInt32(2) * (df + w) + c = (z - float64(df*df)) / (s + df) + w = float64(_R(tls, z)*s) + c + return float64(Float64FromInt32(2) * (df + w)) } var _pio2_hi1 = float32(1.5707962513) /* 0x3fc90fda */ @@ -101942,8 +101942,8 @@ var _qS11 = float32(-Float64FromFloat64(0.7066296339)) func _R1(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = z * (_pS01 + z*(_pS11+z*_pS21)) - q = Float32FromFloat32(1) + z*_qS11 + p = Tfloat_t(z * (_pS01 + float32(z*(_pS11+float32(z*_pS21))))) + q = Float32FromFloat32(1) + float32(z*_qS11) return p / q } @@ -101961,7 +101961,7 @@ func Xacosf(tls *TLS, x float32) (r float32) { if ix >= uint32(0x3f800000) { if ix == uint32(0x3f800000) { if hx>>int32(31) != 0 { - return Float32FromInt32(2)*_pio2_hi1 + Float32FromFloat32(7.52316384526264e-37) + return float32(Float32FromInt32(2)*_pio2_hi1) + Float32FromFloat32(7.52316384526264e-37) } return Float32FromInt32(0) } @@ -101972,24 +101972,24 @@ func Xacosf(tls *TLS, x float32) (r float32) { if ix <= uint32(0x32800000) { /* |x| < 2**-26 */ return _pio2_hi1 + Float32FromFloat32(7.52316384526264e-37) } - return _pio2_hi1 - (x - (_pio2_lo1 - x*_R1(tls, x*x))) + return _pio2_hi1 - (x - (_pio2_lo1 - float32(x*_R1(tls, float32(x*x))))) } /* x < -0.5 */ if hx>>int32(31) != 0 { - z = (Float32FromInt32(1) + x) * Float32FromFloat32(0.5) + z = float32((Float32FromInt32(1) + x) * Float32FromFloat32(0.5)) s = Xsqrtf(tls, z) - w = _R1(tls, z)*s - _pio2_lo1 - return Float32FromInt32(2) * (_pio2_hi1 - (s + w)) + w = float32(_R1(tls, z)*s) - _pio2_lo1 + return float32(Float32FromInt32(2) * (_pio2_hi1 - (s + w))) } /* x > 0.5 */ - z = (Float32FromInt32(1) - x) * Float32FromFloat32(0.5) + z = float32((Float32FromInt32(1) - x) * Float32FromFloat32(0.5)) s = Xsqrtf(tls, z) hx = *(*Tuint32_t)(unsafe.Pointer(&s)) v1 = hx & uint32(0xfffff000) df = *(*float32)(unsafe.Pointer(&v1)) - c = (z - df*df) / (s + df) - w = _R1(tls, z)*s + c - return Float32FromInt32(2) * (df + w) + c = (z - float32(df*df)) / (s + df) + w = float32(_R1(tls, z)*s) + c + return float32(Float32FromInt32(2) * (df + w)) } // C documentation @@ -102020,11 +102020,11 @@ func Xacosh(tls *TLS, x float64) (r float64) { /* x < 1 domain error is handled in the called functions */ if e < Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1)) { /* |x| < 2, up to 2ulp error in [1,1.125] */ - return Xlog1p(tls, x-Float64FromInt32(1)+Xsqrt(tls, (x-Float64FromInt32(1))*(x-Float64FromInt32(1))+Float64FromInt32(2)*(x-Float64FromInt32(1)))) + return Xlog1p(tls, x-Float64FromInt32(1)+Xsqrt(tls, float64((x-Float64FromInt32(1))*(x-Float64FromInt32(1)))+float64(Float64FromInt32(2)*(x-Float64FromInt32(1))))) } if e < Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(26)) { /* |x| < 0x1p26 */ - return Xlog(tls, Float64FromInt32(2)*x-Float64FromInt32(1)/(x+Xsqrt(tls, x*x-Float64FromInt32(1)))) + return Xlog(tls, float64(Float64FromInt32(2)*x)-Float64FromInt32(1)/(x+Xsqrt(tls, float64(x*x)-Float64FromInt32(1)))) } /* |x| >= 0x1p26 or nan */ return Xlog(tls, x) + float64(0.6931471805599453) @@ -102058,11 +102058,11 @@ func Xacoshf(tls *TLS, x float32) (r float32) { if a < Uint32FromInt32(Int32FromInt32(0x3f800000)+Int32FromInt32(1)<<Int32FromInt32(23)) { /* |x| < 2, invalid if x < 1 */ /* up to 2ulp error in [1,1.125] */ - return Xlog1pf(tls, x-Float32FromInt32(1)+Xsqrtf(tls, (x-Float32FromInt32(1))*(x-Float32FromInt32(1))+Float32FromInt32(2)*(x-Float32FromInt32(1)))) + return Xlog1pf(tls, x-Float32FromInt32(1)+Xsqrtf(tls, float32((x-Float32FromInt32(1))*(x-Float32FromInt32(1)))+float32(Float32FromInt32(2)*(x-Float32FromInt32(1))))) } if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(0x3f800000)+Int32FromInt32(12)<<Int32FromInt32(23)) { /* 2 <= x < 0x1p12 */ - return Xlogf(tls, Float32FromInt32(2)*x-Float32FromInt32(1)/(x+Xsqrtf(tls, x*x-Float32FromInt32(1)))) + return Xlogf(tls, float32(Float32FromInt32(2)*x)-Float32FromInt32(1)/(x+Xsqrtf(tls, float32(x*x)-Float32FromInt32(1)))) } /* x >= 0x1p12 or x <= -2 or nan */ return Xlogf(tls, x) + Float32FromFloat32(0.6931471805599453) @@ -102101,8 +102101,8 @@ var _qS41 = float64(0.07703815055590194) /* 0x3FB3B8C5, 0xB12E9282 * func _R2(tls *TLS, z float64) (r float64) { var p, q Tdouble_t _, _ = p, q - p = z * (_pS02 + z*(_pS12+z*(_pS22+z*(_pS31+z*(_pS41+z*_pS51))))) - q = float64(1) + z*(_qS12+z*(_qS21+z*(_qS31+z*_qS41))) + p = Tdouble_t(z * (_pS02 + float64(z*(_pS12+float64(z*(_pS22+float64(z*(_pS31+float64(z*(_pS41+float64(z*_pS51))))))))))) + q = float64(1) + float64(z*(_qS12+float64(z*(_qS21+float64(z*(_qS31+float64(z*_qS41))))))) return p / q } @@ -102122,7 +102122,7 @@ func Xasin(tls *TLS, x float64) (r1 float64) { lx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x))) if ix-uint32(0x3ff00000)|lx == uint32(0) { /* asin(1) = +-pi/2 with inexact */ - return x*_pio2_hi2 + Float64FromFloat32(7.52316384526264e-37) + return float64(x*_pio2_hi2) + Float64FromFloat32(7.52316384526264e-37) } return Float64FromInt32(0) / (x - x) } @@ -102132,21 +102132,21 @@ func Xasin(tls *TLS, x float64) (r1 float64) { if ix < uint32(0x3e500000) && ix >= uint32(0x00100000) { return x } - return x + x*_R2(tls, x*x) + return x + float64(x*_R2(tls, float64(x*x))) } /* 1 > |x| >= 0.5 */ - z = (Float64FromInt32(1) - Xfabs(tls, x)) * float64(0.5) + z = float64((Float64FromInt32(1) - Xfabs(tls, x)) * float64(0.5)) s = Xsqrt(tls, z) r = _R2(tls, z) if ix >= uint32(0x3fef3333) { /* if |x| > 0.975 */ - x = _pio2_hi2 - (Float64FromInt32(2)*(s+s*r) - _pio2_lo2) + x = _pio2_hi2 - (float64(Float64FromInt32(2)*(s+float64(s*r))) - _pio2_lo2) } else { /* f+c = sqrt(z) */ f = s v1 = *(*Tuint64_t)(unsafe.Pointer(&f))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) f = *(*float64)(unsafe.Pointer(&v1)) - c = (z - f*f) / (s + f) - x = float64(0.5)*_pio2_hi2 - (Float64FromInt32(2)*s*r - (_pio2_lo2 - Float64FromInt32(2)*c) - (float64(0.5)*_pio2_hi2 - Float64FromInt32(2)*f)) + c = (z - float64(f*f)) / (s + f) + x = float64(float64(0.5)*_pio2_hi2) - (float64(float64(Float64FromInt32(2)*s)*r) - (_pio2_lo2 - float64(Float64FromInt32(2)*c)) - (float64(float64(0.5)*_pio2_hi2) - float64(Float64FromInt32(2)*f))) } if hx>>int32(31) != 0 { return -x @@ -102165,8 +102165,8 @@ var _qS13 = float32(-Float64FromFloat64(0.7066296339)) func _R3(tls *TLS, z float32) (r float32) { var p, q Tfloat_t _, _ = p, q - p = z * (_pS03 + z*(_pS13+z*_pS23)) - q = Float32FromFloat32(1) + z*_qS13 + p = Tfloat_t(z * (_pS03 + float32(z*(_pS13+float32(z*_pS23))))) + q = Float32FromFloat32(1) + float32(z*_qS13) return p / q } @@ -102183,7 +102183,7 @@ func Xasinf(tls *TLS, x float32) (r float32) { ix = hx & uint32(0x7fffffff) if ix >= uint32(0x3f800000) { /* |x| >= 1 */ if ix == uint32(0x3f800000) { /* |x| == 1 */ - return float32(float64(x)*_pio2 + Float64FromFloat32(7.52316384526264e-37)) + return float32(float64(float64(x)*_pio2) + Float64FromFloat32(7.52316384526264e-37)) } /* asin(+-1) = +-pi/2 with inexact */ return Float32FromInt32(0) / (x - x) /* asin(|x|>1) is NaN */ } @@ -102192,12 +102192,12 @@ func Xasinf(tls *TLS, x float32) (r float32) { if ix < uint32(0x39800000) && ix >= uint32(0x00800000) { return x } - return x + x*_R3(tls, x*x) + return x + float32(x*_R3(tls, float32(x*x))) } /* 1 > |x| >= 0.5 */ - z = (Float32FromInt32(1) - Xfabsf(tls, x)) * Float32FromFloat32(0.5) + z = float32((Float32FromInt32(1) - Xfabsf(tls, x)) * Float32FromFloat32(0.5)) s = Xsqrt(tls, float64(z)) - x = float32(_pio2 - Float64FromInt32(2)*(s+s*float64(_R3(tls, z)))) + x = float32(_pio2 - float64(Float64FromInt32(2)*(s+float64(s*float64(_R3(tls, z)))))) if hx>>int32(31) != 0 { return -x } @@ -102241,11 +102241,11 @@ func Xasinh(tls *TLS, x3 float64) (r float64) { } else { if e >= Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1)) { /* |x| >= 2 */ - x3 = Xlog(tls, Float64FromInt32(2)*x3+Float64FromInt32(1)/(Xsqrt(tls, x3*x3+Float64FromInt32(1))+x3)) + x3 = Xlog(tls, float64(Float64FromInt32(2)*x3)+Float64FromInt32(1)/(Xsqrt(tls, float64(x3*x3)+Float64FromInt32(1))+x3)) } else { if e >= Uint32FromInt32(Int32FromInt32(0x3ff)-Int32FromInt32(26)) { /* |x| >= 0x1p-26, up to 1.6ulp error in [0.125,0.5] */ - x3 = Xlog1p(tls, x3+x3*x3/(Xsqrt(tls, x3*x3+Float64FromInt32(1))+Float64FromInt32(1))) + x3 = Xlog1p(tls, x3+float64(x3*x3)/(Xsqrt(tls, float64(x3*x3)+Float64FromInt32(1))+Float64FromInt32(1))) } else { /* |x| < 0x1p-26, raise inexact if x != 0 */ if uint64(8) == uint64(4) { @@ -102306,11 +102306,11 @@ func Xasinhf(tls *TLS, x3 float32) (r float32) { } else { if i >= Uint32FromInt32(Int32FromInt32(0x3f800000)+Int32FromInt32(1)<<Int32FromInt32(23)) { /* |x| >= 2 */ - x3 = Xlogf(tls, Float32FromInt32(2)*x3+Float32FromInt32(1)/(Xsqrtf(tls, x3*x3+Float32FromInt32(1))+x3)) + x3 = Xlogf(tls, float32(Float32FromInt32(2)*x3)+Float32FromInt32(1)/(Xsqrtf(tls, float32(x3*x3)+Float32FromInt32(1))+x3)) } else { if i >= Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(12)<<Int32FromInt32(23)) { /* |x| >= 0x1p-12, up to 1.6ulp error in [0.125,0.5] */ - x3 = Xlog1pf(tls, x3+x3*x3/(Xsqrtf(tls, x3*x3+Float32FromInt32(1))+Float32FromInt32(1))) + x3 = Xlog1pf(tls, x3+float32(x3*x3)/(Xsqrtf(tls, float32(x3*x3)+Float32FromInt32(1))+Float32FromInt32(1))) } else { /* |x| < 0x1p-12, raise inexact if x!=0 */ if uint64(4) == uint64(4) { @@ -102436,7 +102436,7 @@ func Xatan(tls *TLS, x3 float64) (r float64) { if ix < uint32(0x3ff30000) { /* |x| < 1.1875 */ if ix < uint32(0x3fe60000) { /* 7/16 <= |x| < 11/16 */ id = 0 - x3 = (float64(2)*x3 - float64(1)) / (float64(2) + x3) + x3 = (float64(float64(2)*x3) - float64(1)) / (float64(2) + x3) } else { /* 11/16 <= |x| < 19/16 */ id = int32(1) x3 = (x3 - float64(1)) / (x3 + float64(1)) @@ -102444,7 +102444,7 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } else { if ix < uint32(0x40038000) { /* |x| < 2.4375 */ id = int32(2) - x3 = (x3 - float64(1.5)) / (float64(1) + float64(1.5)*x3) + x3 = (x3 - float64(1.5)) / (float64(1) + float64(float64(1.5)*x3)) } else { /* 2.4375 <= |x| < 2^66 */ id = int32(3) x3 = -Float64FromFloat64(1) / x3 @@ -102452,15 +102452,15 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } } /* end of argument reduction */ - z = x3 * x3 - w = z * z + z = Tdouble_t(x3 * x3) + w = Tdouble_t(z * z) /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ - s1 = z * (_aT[0] + w*(_aT[int32(2)]+w*(_aT[int32(4)]+w*(_aT[int32(6)]+w*(_aT[int32(8)]+w*_aT[int32(10)]))))) - s2 = w * (_aT[int32(1)] + w*(_aT[int32(3)]+w*(_aT[int32(5)]+w*(_aT[int32(7)]+w*_aT[int32(9)])))) + s1 = Tdouble_t(z * (_aT[0] + float64(w*(_aT[int32(2)]+float64(w*(_aT[int32(4)]+float64(w*(_aT[int32(6)]+float64(w*(_aT[int32(8)]+float64(w*_aT[int32(10)]))))))))))) + s2 = Tdouble_t(w * (_aT[int32(1)] + float64(w*(_aT[int32(3)]+float64(w*(_aT[int32(5)]+float64(w*(_aT[int32(7)]+float64(w*_aT[int32(9)]))))))))) if id < 0 { - return x3 - x3*(s1+s2) + return x3 - float64(x3*(s1+s2)) } - z = _atanhi[id] - (x3*(s1+s2) - _atanlo[id] - x3) + z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { v4 = -z } else { @@ -102546,9 +102546,9 @@ _2: case uint32(1): return -_pi / Float64FromInt32(4) /* atan(-INF,+INF) */ case uint32(2): - return Float64FromInt32(3) * _pi / Float64FromInt32(4) /* atan(+INF,-INF) */ + return float64(Float64FromInt32(3)*_pi) / Float64FromInt32(4) /* atan(+INF,-INF) */ case uint32(3): - return float64(-Int32FromInt32(3)) * _pi / Float64FromInt32(4) /* atan(-INF,-INF) */ + return float64(float64(-Int32FromInt32(3))*_pi) / Float64FromInt32(4) /* atan(-INF,-INF) */ } } else { switch m { @@ -102663,9 +102663,9 @@ _2: case uint32(1): return -_pi1 / Float32FromInt32(4) /* atan(-INF,+INF) */ case uint32(2): - return Float32FromInt32(3) * _pi1 / Float32FromInt32(4) /*atan(+INF,-INF)*/ + return float32(Float32FromInt32(3)*_pi1) / Float32FromInt32(4) /*atan(+INF,-INF)*/ case uint32(3): - return float32(-Int32FromInt32(3)) * _pi1 / Float32FromInt32(4) /*atan(-INF,-INF)*/ + return float32(float32(-Int32FromInt32(3))*_pi1) / Float32FromInt32(4) /*atan(-INF,-INF)*/ } } else { switch m { @@ -102780,7 +102780,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x00800000) { /* raise underflow for subnormal x */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -102797,7 +102797,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { if ix < uint32(0x3f980000) { /* |x| < 1.1875 */ if ix < uint32(0x3f300000) { /* 7/16 <= |x| < 11/16 */ id = 0 - x3 = (Float32FromFloat32(2)*x3 - Float32FromFloat32(1)) / (Float32FromFloat32(2) + x3) + x3 = (float32(Float32FromFloat32(2)*x3) - Float32FromFloat32(1)) / (Float32FromFloat32(2) + x3) } else { /* 11/16 <= |x| < 19/16 */ id = int32(1) x3 = (x3 - Float32FromFloat32(1)) / (x3 + Float32FromFloat32(1)) @@ -102805,7 +102805,7 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } else { if ix < uint32(0x401c0000) { /* |x| < 2.4375 */ id = int32(2) - x3 = (x3 - Float32FromFloat32(1.5)) / (Float32FromFloat32(1) + Float32FromFloat32(1.5)*x3) + x3 = (x3 - Float32FromFloat32(1.5)) / (Float32FromFloat32(1) + float32(Float32FromFloat32(1.5)*x3)) } else { /* 2.4375 <= |x| < 2**26 */ id = int32(3) x3 = -Float32FromFloat32(1) / x3 @@ -102813,15 +102813,15 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } } /* end of argument reduction */ - z = x3 * x3 - w = z * z + z = Tfloat_t(x3 * x3) + w = Tfloat_t(z * z) /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ - s1 = z * (_aT1[0] + w*(_aT1[int32(2)]+w*_aT1[int32(4)])) - s2 = w * (_aT1[int32(1)] + w*_aT1[int32(3)]) + s1 = Tfloat_t(z * (_aT1[0] + float32(w*(_aT1[int32(2)]+float32(w*_aT1[int32(4)]))))) + s2 = Tfloat_t(w * (_aT1[int32(1)] + float32(w*_aT1[int32(3)]))) if id < 0 { - return x3 - x3*(s1+s2) + return x3 - float32(x3*(s1+s2)) } - z = _atanhi1[id] - (x3*(s1+s2) - _atanlo1[id] - x3) + z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { v4 = -z } else { @@ -102878,11 +102878,11 @@ func Xatanh(tls *TLS, x3 float64) (r float64) { } } else { /* |x| < 0.5, up to 1.7ulp error */ - y3 = float64(0.5) * Xlog1p(tls, Float64FromInt32(2)*y3+Float64FromInt32(2)*y3*y3/(Float64FromInt32(1)-y3)) + y3 = Tdouble_t(float64(0.5) * Xlog1p(tls, Tdouble_t(Float64FromInt32(2)*y3)+Tdouble_t(Tdouble_t(Float64FromInt32(2)*y3)*y3)/(Float64FromInt32(1)-y3))) } } else { /* avoid overflow */ - y3 = float64(0.5) * Xlog1p(tls, Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))) + y3 = Tdouble_t(float64(0.5) * Xlog1p(tls, float64(Float64FromInt32(2)*(y3/(Float64FromInt32(1)-y3))))) } if s != 0 { v1 = -y3 @@ -102928,22 +102928,22 @@ func Xatanhf(tls *TLS, x3 float32) (r float32) { /* handle underflow */ if *(*Tuint32_t)(unsafe.Pointer(bp)) < Uint32FromInt32(Int32FromInt32(1)<<Int32FromInt32(23)) { if uint64(4) == uint64(4) { - y = y3 * y3 + y = Tfloat_t(y3 * y3) } else { if uint64(4) == uint64(8) { - y1 = float64(y3 * y3) + y1 = float64(Tfloat_t(y3 * y3)) } else { - y2 = float64(y3 * y3) + y2 = float64(Tfloat_t(y3 * y3)) } } } } else { /* |x| < 0.5, up to 1.7ulp error */ - y3 = Float32FromFloat32(0.5) * Xlog1pf(tls, Float32FromInt32(2)*y3+Float32FromInt32(2)*y3*y3/(Float32FromInt32(1)-y3)) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, Tfloat_t(Float32FromInt32(2)*y3)+Tfloat_t(Tfloat_t(Float32FromInt32(2)*y3)*y3)/(Float32FromInt32(1)-y3))) } } else { /* avoid overflow */ - y3 = Float32FromFloat32(0.5) * Xlog1pf(tls, Float32FromInt32(2)*(y3/(Float32FromInt32(1)-y3))) + y3 = Tfloat_t(Float32FromFloat32(0.5) * Xlog1pf(tls, float32(Float32FromInt32(2)*(y3/(Float32FromInt32(1)-y3))))) } if s != 0 { v1 = -y3 @@ -103025,7 +103025,7 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * division rounds towards minus infinity; this is also efficient. */ if hx < uint32(0x00100000) { /* zero or subnormal? */ - *(*float64)(unsafe.Pointer(bp)) = x * float64(1.8014398509481984e+16) + *(*float64)(unsafe.Pointer(bp)) = float64(x * float64(1.8014398509481984e+16)) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if hx == uint32(0) { return x @@ -103048,8 +103048,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { * * Try to optimize for parallel evaluation as in __tanf.c. */ - r = t * t * (t / x) - t = t * (_P0 + r*(_P1+r*_P2) + r*r*r*(_P3+r*_P4)) + r = Tdouble_t(Tdouble_t(t*t) * (t / x)) + t = Tdouble_t(t * (_P0 + float64(r*(_P1+float64(r*_P2))) + float64(Tdouble_t(Tdouble_t(r*r)*r)*(_P3+float64(r*_P4))))) /* * Round t away from zero to 23 bits (sloppily except for ensuring that * the result is larger in magnitude than cbrt(x) but not much more than @@ -103064,11 +103064,11 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000) t = *(*float64)(unsafe.Pointer(bp)) /* one step Newton iteration to 53 bits with error < 0.667 ulps */ - s = t * t /* t*t is exact */ - r = x / s /* error <= 0.5 ulps; |r| < |t| */ - w = t + t /* t+t is exact */ - r = (r - t) / (w + r) /* r-t is exact; w+r ~= 3*t */ - t = t + t*r /* error <= 0.5 + 0.5/3 + epsilon */ + s = Tdouble_t(t * t) /* t*t is exact */ + r = x / s /* error <= 0.5 ulps; |r| < |t| */ + w = t + t /* t+t is exact */ + r = (r - t) / (w + r) /* r-t is exact; w+r ~= 3*t */ + t = t + Tdouble_t(t*r) /* error <= 0.5 + 0.5/3 + epsilon */ return t } @@ -103106,7 +103106,7 @@ func Xcbrtf(tls *TLS, x float32) (r1 float32) { if hx == uint32(0) { return x } /* cbrt(+-0) is itself */ - *(*float32)(unsafe.Pointer(bp)) = x * Float32FromFloat32(1.6777216e+07) + *(*float32)(unsafe.Pointer(bp)) = float32(x * Float32FromFloat32(1.6777216e+07)) hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) hx = hx/uint32(3) + _B21 } else { @@ -103120,14 +103120,14 @@ func Xcbrtf(tls *TLS, x float32) (r1 float32) { * without causing overflow or underflow. */ T = float64(*(*float32)(unsafe.Pointer(bp))) - r = T * T * T - T = T * (float64(x) + float64(x) + r) / (float64(x) + r + r) + r = Tdouble_t(Tdouble_t(T*T) * T) + T = Tdouble_t(T*(float64(x)+float64(x)+r)) / (float64(x) + r + r) /* * Second step Newton iteration to 47 bits. In double precision for * efficiency and accuracy. */ - r = T * T * T - T = T * (float64(x) + float64(x) + r) / (float64(x) + r + r) + r = Tdouble_t(Tdouble_t(T*T) * T) + T = Tdouble_t(T*(float64(x)+float64(x)+r)) / (float64(x) + r + r) /* rounding to 24 bits is perfect in round-to-nearest mode */ return float32(T) } @@ -103420,10 +103420,10 @@ const M_PI_23 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _c1pio2 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _c2pio2 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _c3pio2 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _c4pio2 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _c1pio2 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _c2pio2 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _c3pio2 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _c4pio2 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xcosf(tls *TLS, x3 float32) (r float32) { if __ccgo_strace { @@ -103559,13 +103559,13 @@ func Xcosh(tls *TLS, x3 float64) (r float64) { return Float64FromInt32(1) } t = Xexpm1(tls, x3) - return Float64FromInt32(1) + t*t/(Float64FromInt32(2)*(Float64FromInt32(1)+t)) + return Float64FromInt32(1) + float64(t*t)/float64(Float64FromInt32(2)*(Float64FromInt32(1)+t)) } /* |x| < log(DBL_MAX) */ if w < uint32(0x40862e42) { t = Xexp(tls, x3) /* note: if x>log(0x1p26) then the 1/t is not needed */ - return float64(0.5) * (t + Float64FromInt32(1)/t) + return float64(float64(0.5) * (t + Float64FromInt32(1)/t)) } /* |x| > log(DBL_MAX) or nan */ /* note: the result is stored to handle overflow */ @@ -103615,12 +103615,12 @@ func Xcoshf(tls *TLS, x3 float32) (r float32) { return Float32FromInt32(1) } t = Xexpm1f(tls, x3) - return Float32FromInt32(1) + t*t/(Float32FromInt32(2)*(Float32FromInt32(1)+t)) + return Float32FromInt32(1) + float32(t*t)/float32(Float32FromInt32(2)*(Float32FromInt32(1)+t)) } /* |x| < log(FLT_MAX) */ if w < uint32(0x42b17217) { t = Xexpf(tls, x3) - return Float32FromFloat32(0.5) * (t + Float32FromInt32(1)/t) + return float32(Float32FromFloat32(0.5) * (t + Float32FromInt32(1)/t)) } /* |x| > log(FLT_MAX) or nan */ t = X__expo2f(tls, x3, Float32FromFloat32(1)) @@ -103715,8 +103715,8 @@ func _erfc1(tls *TLS, x float64) (r float64) { var P, Q, s Tdouble_t _, _, _ = P, Q, s s = Xfabs(tls, x) - Float64FromInt32(1) - P = _pa0 + s*(_pa1+s*(_pa2+s*(_pa3+s*(_pa4+s*(_pa5+s*_pa6))))) - Q = Float64FromInt32(1) + s*(_qa1+s*(_qa2+s*(_qa3+s*(_qa4+s*(_qa5+s*_qa6))))) + P = _pa0 + float64(s*(_pa1+float64(s*(_pa2+float64(s*(_pa3+float64(s*(_pa4+float64(s*(_pa5+float64(s*_pa6))))))))))) + Q = Float64FromInt32(1) + Tdouble_t(s*(_qa1+float64(s*(_qa2+float64(s*(_qa3+float64(s*(_qa4+float64(s*(_qa5+float64(s*_qa6))))))))))) return Float64FromInt32(1) - _erx - P/Q } @@ -103729,18 +103729,18 @@ func _erfc2(tls *TLS, ix Tuint32_t, x float64) (r float64) { return _erfc1(tls, x) } x = Xfabs(tls, x) - s = Float64FromInt32(1) / (x * x) + s = Float64FromInt32(1) / float64(x*x) if ix < uint32(0x4006db6d) { /* |x| < 1/.35 ~ 2.85714 */ - R = _ra0 + s*(_ra1+s*(_ra2+s*(_ra3+s*(_ra4+s*(_ra5+s*(_ra6+s*_ra7)))))) - S = float64(1) + s*(_sa1+s*(_sa2+s*(_sa3+s*(_sa4+s*(_sa5+s*(_sa6+s*(_sa7+s*_sa8))))))) + R = _ra0 + float64(s*(_ra1+float64(s*(_ra2+float64(s*(_ra3+float64(s*(_ra4+float64(s*(_ra5+float64(s*(_ra6+float64(s*_ra7))))))))))))) + S = float64(1) + float64(s*(_sa1+float64(s*(_sa2+float64(s*(_sa3+float64(s*(_sa4+float64(s*(_sa5+float64(s*(_sa6+float64(s*(_sa7+float64(s*_sa8))))))))))))))) } else { /* |x| > 1/.35 */ - R = _rb0 + s*(_rb1+s*(_rb2+s*(_rb3+s*(_rb4+s*(_rb5+s*_rb6))))) - S = float64(1) + s*(_sb1+s*(_sb2+s*(_sb3+s*(_sb4+s*(_sb5+s*(_sb6+s*_sb7)))))) + R = _rb0 + float64(s*(_rb1+float64(s*(_rb2+float64(s*(_rb3+float64(s*(_rb4+float64(s*(_rb5+float64(s*_rb6))))))))))) + S = float64(1) + float64(s*(_sb1+float64(s*(_sb2+float64(s*(_sb3+float64(s*(_sb4+float64(s*(_sb5+float64(s*(_sb6+float64(s*_sb7))))))))))))) } z = x v1 = *(*Tuint64_t)(unsafe.Pointer(&z))>>Int32FromInt32(32)<<Int32FromInt32(32) | uint64(Uint32FromInt32(Int32FromInt32(0))) z = *(*float64)(unsafe.Pointer(&v1)) - return Xexp(tls, -z*z-float64(0.5625)) * Xexp(tls, (z-x)*(z+x)+R/S) / x + return float64(Xexp(tls, float64(-z*z)-float64(0.5625))*Xexp(tls, float64((z-x)*(z+x))+R/S)) / x } func Xerf(tls *TLS, x float64) (r1 float64) { @@ -103762,13 +103762,13 @@ func Xerf(tls *TLS, x float64) (r1 float64) { if ix < uint32(0x3feb0000) { /* |x| < 0.84375 */ if ix < uint32(0x3e300000) { /* |x| < 2**-28 */ /* avoid underflow */ - return float64(0.125) * (Float64FromInt32(8)*x + _efx8*x) + return float64(float64(0.125) * (float64(Float64FromInt32(8)*x) + float64(_efx8*x))) } - z = x * x - r = _pp0 + z*(_pp1+z*(_pp2+z*(_pp3+z*_pp4))) - s = float64(1) + z*(_qq1+z*(_qq2+z*(_qq3+z*(_qq4+z*_qq5)))) + z = float64(x * x) + r = _pp0 + float64(z*(_pp1+float64(z*(_pp2+float64(z*(_pp3+float64(z*_pp4))))))) + s = float64(1) + float64(z*(_qq1+float64(z*(_qq2+float64(z*(_qq3+float64(z*(_qq4+float64(z*_qq5))))))))) y = r / s - return x + x*y + return x + float64(x*y) } if ix < uint32(0x40180000) { /* 0.84375 <= |x| < 6 */ y = Float64FromInt32(1) - _erfc2(tls, ix, x) @@ -103803,14 +103803,14 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { if ix < uint32(0x3c700000) { /* |x| < 2**-56 */ return float64(1) - x } - z = x * x - r = _pp0 + z*(_pp1+z*(_pp2+z*(_pp3+z*_pp4))) - s = float64(1) + z*(_qq1+z*(_qq2+z*(_qq3+z*(_qq4+z*_qq5)))) + z = float64(x * x) + r = _pp0 + float64(z*(_pp1+float64(z*(_pp2+float64(z*(_pp3+float64(z*_pp4))))))) + s = float64(1) + float64(z*(_qq1+float64(z*(_qq2+float64(z*(_qq3+float64(z*(_qq4+float64(z*_qq5))))))))) y = r / s if sign != 0 || ix < uint32(0x3fd00000) { /* x < 1/4 */ - return float64(1) - (x + x*y) + return float64(1) - (x + float64(x*y)) } - return float64(0.5) - (x - float64(0.5) + x*y) + return float64(0.5) - (x - float64(0.5) + float64(x*y)) } if ix < uint32(0x403c0000) { /* 0.84375 <= |x| < 28 */ if sign != 0 { @@ -103823,7 +103823,7 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { if sign != 0 { v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308) + v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } return v2 } @@ -103900,8 +103900,8 @@ func _erfc11(tls *TLS, x float32) (r float32) { var P, Q, s Tfloat_t _, _, _ = P, Q, s s = Xfabsf(tls, x) - Float32FromInt32(1) - P = _pa01 + s*(_pa11+s*(_pa21+s*(_pa31+s*(_pa41+s*(_pa51+s*_pa61))))) - Q = Float32FromInt32(1) + s*(_qa11+s*(_qa21+s*(_qa31+s*(_qa41+s*(_qa51+s*_qa61))))) + P = _pa01 + float32(s*(_pa11+float32(s*(_pa21+float32(s*(_pa31+float32(s*(_pa41+float32(s*(_pa51+float32(s*_pa61))))))))))) + Q = Float32FromInt32(1) + Tfloat_t(s*(_qa11+float32(s*(_qa21+float32(s*(_qa31+float32(s*(_qa41+float32(s*(_qa51+float32(s*_qa61))))))))))) return Float32FromInt32(1) - _erx1 - P/Q } @@ -103914,18 +103914,18 @@ func _erfc21(tls *TLS, ix Tuint32_t, x float32) (r float32) { return _erfc11(tls, x) } x = Xfabsf(tls, x) - s = Float32FromInt32(1) / (x * x) + s = Float32FromInt32(1) / float32(x*x) if ix < uint32(0x4036db6d) { /* |x| < 1/0.35 */ - R = _ra01 + s*(_ra11+s*(_ra21+s*(_ra31+s*(_ra41+s*(_ra51+s*(_ra61+s*_ra71)))))) - S = Float32FromFloat32(1) + s*(_sa11+s*(_sa21+s*(_sa31+s*(_sa41+s*(_sa51+s*(_sa61+s*(_sa71+s*_sa81))))))) + R = _ra01 + float32(s*(_ra11+float32(s*(_ra21+float32(s*(_ra31+float32(s*(_ra41+float32(s*(_ra51+float32(s*(_ra61+float32(s*_ra71))))))))))))) + S = Float32FromFloat32(1) + float32(s*(_sa11+float32(s*(_sa21+float32(s*(_sa31+float32(s*(_sa41+float32(s*(_sa51+float32(s*(_sa61+float32(s*(_sa71+float32(s*_sa81))))))))))))))) } else { /* |x| >= 1/0.35 */ - R = _rb01 + s*(_rb11+s*(_rb21+s*(_rb31+s*(_rb41+s*(_rb51+s*_rb61))))) - S = Float32FromFloat32(1) + s*(_sb11+s*(_sb21+s*(_sb31+s*(_sb41+s*(_sb51+s*(_sb61+s*_sb71)))))) + R = _rb01 + float32(s*(_rb11+float32(s*(_rb21+float32(s*(_rb31+float32(s*(_rb41+float32(s*(_rb51+float32(s*_rb61))))))))))) + S = Float32FromFloat32(1) + float32(s*(_sb11+float32(s*(_sb21+float32(s*(_sb31+float32(s*(_sb41+float32(s*(_sb51+float32(s*(_sb61+float32(s*_sb71))))))))))))) } ix = *(*Tuint32_t)(unsafe.Pointer(&x)) v1 = ix & uint32(0xffffe000) z = *(*float32)(unsafe.Pointer(&v1)) - return Xexpf(tls, -z*z-Float32FromFloat32(0.5625)) * Xexpf(tls, (z-x)*(z+x)+R/S) / x + return float32(Xexpf(tls, float32(-z*z)-Float32FromFloat32(0.5625))*Xexpf(tls, float32((z-x)*(z+x))+R/S)) / x } func Xerff(tls *TLS, x float32) (r1 float32) { @@ -103947,13 +103947,13 @@ func Xerff(tls *TLS, x float32) (r1 float32) { if ix < uint32(0x3f580000) { /* |x| < 0.84375 */ if ix < uint32(0x31800000) { /* |x| < 2**-28 */ /*avoid underflow */ - return Float32FromFloat32(0.125) * (Float32FromInt32(8)*x + _efx81*x) + return float32(Float32FromFloat32(0.125) * (float32(Float32FromInt32(8)*x) + float32(_efx81*x))) } - z = x * x - r = _pp01 + z*(_pp11+z*(_pp21+z*(_pp31+z*_pp41))) - s = Float32FromInt32(1) + z*(_qq11+z*(_qq21+z*(_qq31+z*(_qq41+z*_qq51)))) + z = float32(x * x) + r = _pp01 + float32(z*(_pp11+float32(z*(_pp21+float32(z*(_pp31+float32(z*_pp41))))))) + s = Float32FromInt32(1) + float32(z*(_qq11+float32(z*(_qq21+float32(z*(_qq31+float32(z*(_qq41+float32(z*_qq51))))))))) y = r / s - return x + x*y + return x + float32(x*y) } if ix < uint32(0x40c00000) { /* |x| < 6 */ y = Float32FromInt32(1) - _erfc21(tls, ix, x) @@ -103988,14 +103988,14 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { if ix < uint32(0x23800000) { /* |x| < 2**-56 */ return Float32FromFloat32(1) - x } - z = x * x - r = _pp01 + z*(_pp11+z*(_pp21+z*(_pp31+z*_pp41))) - s = Float32FromFloat32(1) + z*(_qq11+z*(_qq21+z*(_qq31+z*(_qq41+z*_qq51)))) + z = float32(x * x) + r = _pp01 + float32(z*(_pp11+float32(z*(_pp21+float32(z*(_pp31+float32(z*_pp41))))))) + s = Float32FromFloat32(1) + float32(z*(_qq11+float32(z*(_qq21+float32(z*(_qq31+float32(z*(_qq41+float32(z*_qq51))))))))) y = r / s if sign != 0 || ix < uint32(0x3e800000) { /* x < 1/4 */ - return Float32FromFloat32(1) - (x + x*y) + return Float32FromFloat32(1) - (x + float32(x*y)) } - return Float32FromFloat32(0.5) - (x - Float32FromFloat32(0.5) + x*y) + return Float32FromFloat32(0.5) - (x - Float32FromFloat32(0.5) + float32(x*y)) } if ix < uint32(0x41e00000) { /* |x| < 28 */ if sign != 0 { @@ -104008,7 +104008,7 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { if sign != 0 { v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37) + v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } return v2 } @@ -104052,7 +104052,7 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo /* k > 0, the exponent of scale might have overflowed by <= 460. */ sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<<Int32FromInt32(52)) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = float64(5.486124068793689e+303) * (scale + scale*tmp) + y3 = Tdouble_t(float64(5.486124068793689e+303) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -104062,9 +104062,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo /* k < 0, need special care in the subnormal range. */ sbits = Tuint64_t(sbits + Uint64FromUint64(1022)<<Int32FromInt32(52)) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = scale + scale*tmp + y3 = scale + Tdouble_t(scale*tmp) if y3 < float64(1) { - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = float64(1) + y3 lo = float64(1) - hi + y3 + lo y = hi + lo @@ -104081,9 +104081,9 @@ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r flo v5 = y1 goto _6 _6: - y2 = v5 * float64(2.2250738585072014e-308) + y2 = float64(v5 * float64(2.2250738585072014e-308)) } - y3 = float64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(float64(2.2250738585072014e-308) * y3) y = y3 v7 = y goto _8 @@ -104134,7 +104134,7 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { } /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ - z = X__exp_data.Finvln2N * x1 + z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift v2 = y @@ -104144,7 +104144,7 @@ _3: v4 = kd ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) kd -= X__exp_data.Fshift - r = x1 + kd*X__exp_data.Fnegln2hiN + kd*X__exp_data.Fnegln2loN + r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(EXP_TABLE_BITS))) top = ki << (Int32FromInt32(52) - Int32FromInt32(EXP_TABLE_BITS)) @@ -104154,17 +104154,17 @@ _3: sbits = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 112 + uintptr(idx+uint64(1))*8)) + top /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r + r2 = Tdouble_t(r * r) /* Without fma the worst case error is 0.25/N ulp larger. */ /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. */ - tmp = tail + r + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))) + r2*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))) + tmp = tail + r + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))))) + Tdouble_t(Tdouble_t(r2*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))))) if abstop == uint32(0) { return _specialcase(tls, tmp, sbits, ki) } scale = *(*float64)(unsafe.Pointer(&sbits)) /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ - y = scale + scale*tmp + y = scale + Tdouble_t(scale*tmp) v6 = y goto _7 _7: @@ -104201,8 +104201,8 @@ func Xexp10(tls *TLS, x float64) (r float64) { if !(y != 0) { return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] } - y = Xexp2(tls, float64(3.321928094887362)*y) - return y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + y = Xexp2(tls, float64(float64(3.321928094887362)*y)) + return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104277,10 +104277,10 @@ func Xexp10f(tls *TLS, x float32) (r float32) { if !(y != 0) { return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] } - y = Xexp2f(tls, Float32FromFloat32(3.321928094887362)*y) - return y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) + return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) } - return float32(Xexp2(tls, float64(3.321928094887362)*float64(x))) + return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } var _p101 = [15]float32{ @@ -104342,7 +104342,7 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl /* k > 0, the exponent of scale might have overflowed by 1. */ sbits = Tuint64_t(sbits - Uint64FromUint64(1)<<Int32FromInt32(52)) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = Float64FromInt32(2) * (scale + scale*tmp) + y3 = Tdouble_t(Float64FromInt32(2) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -104352,9 +104352,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl /* k < 0, need special care in the subnormal range. */ sbits = Tuint64_t(sbits + Uint64FromUint64(1022)<<Int32FromInt32(52)) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = scale + scale*tmp + y3 = scale + Tdouble_t(scale*tmp) if y3 < float64(1) { - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = float64(1) + y3 lo = float64(1) - hi + y3 + lo y = hi + lo @@ -104371,9 +104371,9 @@ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl v5 = y1 goto _6 _6: - y2 = v5 * float64(2.2250738585072014e-308) + y2 = float64(v5 * float64(2.2250738585072014e-308)) } - y3 = float64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(float64(2.2250738585072014e-308) * y3) y = y3 v7 = y goto _8 @@ -104448,17 +104448,17 @@ _5: sbits = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 112 + uintptr(idx+uint64(1))*8)) + top /* exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r + r2 = Tdouble_t(r * r) /* Without fma the worst case error is 0.5/N ulp larger. */ /* Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp. */ - tmp = tail + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72)) + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 1*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 2*8))) + r2*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 3*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 4*8))) + tmp = tail + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72))) + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 2*8))))) + Tdouble_t(Tdouble_t(r2*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 72 + 4*8))))) if abstop == uint32(0) { return _specialcase1(tls, tmp, sbits, ki) } scale = *(*float64)(unsafe.Pointer(&sbits)) /* Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ - y = scale + scale*tmp + y = scale + Tdouble_t(scale*tmp) v8 = y goto _9 _9: @@ -104526,11 +104526,11 @@ _3: t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)))*8)) t += ki << (Int32FromInt32(52) - Int32FromInt32(EXP2F_TABLE_BITS)) s = *(*float64)(unsafe.Pointer(&t)) - z = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) - r2 = r * r - y2 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r + Float64FromInt32(1) - y2 = z*r2 + y2 - y2 = y2 * s + z = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) + r2 = Tdouble_t(r * r) + y2 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r) + Float64FromInt32(1) + y2 = Tdouble_t(z*r2) + y2 + y2 = Tdouble_t(y2 * s) y = float32(y2) v5 = y goto _6 @@ -104614,7 +104614,7 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { } } /* x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k. */ - z = X__exp2f_data.Finvln2_scaled * xd + z = Tdouble_t(X__exp2f_data.Finvln2_scaled * xd) /* Round and convert z to int, the result is in [-150*N, 128*N] and ideally ties-to-even rule is used, otherwise the magnitude of r can be bigger which gives larger approximation error. */ @@ -104631,11 +104631,11 @@ _3: t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)))*8)) t += ki << (Int32FromInt32(52) - Int32FromInt32(EXP2F_TABLE_BITS)) s = *(*float64)(unsafe.Pointer(&t)) - z = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 1*8)) - r2 = r * r - y2 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 2*8))*r + Float64FromInt32(1) - y2 = z*r2 + y2 - y2 = y2 * s + z = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 1*8)) + r2 = Tdouble_t(r * r) + y2 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 304 + 2*8))*r) + Float64FromInt32(1) + y2 = Tdouble_t(z*r2) + y2 + y2 = Tdouble_t(y2 * s) y = float32(y2) v5 = y goto _6 @@ -104729,10 +104729,10 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { } else { v3 = float64(0.5) } - k = int32(_invln2*x3 + v3) + k = int32(float64(_invln2*x3) + v3) t = float64(k) - hi = x3 - t*_ln2_hi /* t*ln2_hi is exact here */ - lo = t * _ln2_lo + hi = x3 - float64(t*_ln2_hi) /* t*ln2_hi is exact here */ + lo = Tdouble_t(t * _ln2_lo) } x3 = hi - lo c = hi - x3 - lo @@ -104755,42 +104755,42 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { } } /* x is now in primary range */ - hfx = float64(0.5) * x3 - hxs = x3 * hfx - r1 = float64(1) + hxs*(_Q1+hxs*(_Q2+hxs*(_Q3+hxs*(_Q4+hxs*_Q5)))) - t = float64(3) - r1*hfx - e = hxs * ((r1 - t) / (Float64FromFloat64(6) - x3*t)) + hfx = Tdouble_t(float64(0.5) * x3) + hxs = Tdouble_t(x3 * hfx) + r1 = float64(1) + float64(hxs*(_Q1+float64(hxs*(_Q2+float64(hxs*(_Q3+float64(hxs*(_Q4+float64(hxs*_Q5))))))))) + t = float64(3) - float64(r1*hfx) + e = Tdouble_t(hxs * ((r1 - t) / (Float64FromFloat64(6) - float64(x3*t)))) if k == 0 { /* c is 0 */ - return x3 - (x3*e - hxs) + return x3 - (float64(x3*e) - hxs) } - e = x3*(e-c) - c + e = float64(x3*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return float64(0.5)*(x3-e) - float64(0.5) + return float64(float64(0.5)*(x3-e)) - float64(0.5) } if k == int32(1) { if x3 < -Float64FromFloat64(0.25) { - return -Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5))) + return float64(-Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5)))) } - return float64(1) + float64(2)*(x3-e) + return float64(1) + float64(float64(2)*(x3-e)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(Int32FromInt32(0x3ff)+k) << int32(52) /* 2^k */ twopk = *(*float64)(unsafe.Pointer(bp + 8)) if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */ y3 = x3 - e + float64(1) if k == int32(1024) { - y3 = y3 * float64(2) * float64(8.98846567431158e+307) + y3 = Tdouble_t(Tdouble_t(y3*float64(2)) * float64(8.98846567431158e+307)) } else { - y3 = y3 * twopk + y3 = Tdouble_t(y3 * twopk) } return y3 - float64(1) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(Int32FromInt32(0x3ff)-k) << int32(52) /* 2^-k */ if k < int32(20) { - y3 = (x3 - e + (Float64FromInt32(1) - *(*float64)(unsafe.Pointer(bp + 8)))) * twopk + y3 = Tdouble_t((x3 - e + (Float64FromInt32(1) - *(*float64)(unsafe.Pointer(bp + 8)))) * twopk) } else { - y3 = (x3 - (e + *(*float64)(unsafe.Pointer(bp + 8))) + Float64FromInt32(1)) * twopk + y3 = Tdouble_t((x3 - (e + *(*float64)(unsafe.Pointer(bp + 8))) + Float64FromInt32(1)) * twopk) } return y3 } @@ -104864,10 +104864,10 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { } else { v1 = Float32FromFloat32(0.5) } - k = int32(_invln21*x3 + v1) + k = int32(float32(_invln21*x3) + v1) t = float32(k) - hi = x3 - t*_ln2_hi1 /* t*ln2_hi is exact here */ - lo = t * _ln2_lo1 + hi = x3 - float32(t*_ln2_hi1) /* t*ln2_hi is exact here */ + lo = Tfloat_t(t * _ln2_lo1) } x3 = hi - lo c = hi - x3 - lo @@ -104875,7 +104875,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */ if hx < uint32(0x00800000) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -104890,42 +104890,42 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { } } /* x is now in primary range */ - hfx = Float32FromFloat32(0.5) * x3 - hxs = x3 * hfx - r1 = Float32FromFloat32(1) + hxs*(_Q11+hxs*_Q21) - t = Float32FromFloat32(3) - r1*hfx - e = hxs * ((r1 - t) / (Float32FromFloat32(6) - x3*t)) + hfx = Tfloat_t(Float32FromFloat32(0.5) * x3) + hxs = Tfloat_t(x3 * hfx) + r1 = Float32FromFloat32(1) + float32(hxs*(_Q11+float32(hxs*_Q21))) + t = Float32FromFloat32(3) - float32(r1*hfx) + e = Tfloat_t(hxs * ((r1 - t) / (Float32FromFloat32(6) - float32(x3*t)))) if k == 0 { /* c is 0 */ - return x3 - (x3*e - hxs) + return x3 - (float32(x3*e) - hxs) } - e = x3*(e-c) - c + e = float32(x3*(e-c)) - c e -= hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { - return Float32FromFloat32(0.5)*(x3-e) - Float32FromFloat32(0.5) + return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) } if k == int32(1) { if x3 < -Float32FromFloat32(0.25) { - return -Float32FromFloat32(2) * (e - (x3 + Float32FromFloat32(0.5))) + return float32(-Float32FromFloat32(2) * (e - (x3 + Float32FromFloat32(0.5)))) } - return Float32FromFloat32(1) + Float32FromFloat32(2)*(x3-e) + return Float32FromFloat32(1) + float32(Float32FromFloat32(2)*(x3-e)) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) + k) << int32(23)) /* 2^k */ twopk = *(*float32)(unsafe.Pointer(bp)) if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */ y3 = x3 - e + Float32FromFloat32(1) if k == int32(128) { - y3 = y3 * Float32FromFloat32(2) * Float32FromFloat32(1.7014118346046923e+38) + y3 = Tfloat_t(Tfloat_t(y3*Float32FromFloat32(2)) * Float32FromFloat32(1.7014118346046923e+38)) } else { - y3 = y3 * twopk + y3 = Tfloat_t(y3 * twopk) } return y3 - Float32FromFloat32(1) } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) - k) << int32(23)) /* 2^-k */ if k < int32(23) { - y3 = (x3 - e + (Float32FromInt32(1) - *(*float32)(unsafe.Pointer(bp)))) * twopk + y3 = Tfloat_t((x3 - e + (Float32FromInt32(1) - *(*float32)(unsafe.Pointer(bp)))) * twopk) } else { - y3 = (x3 - (e + *(*float32)(unsafe.Pointer(bp))) + Float32FromInt32(1)) * twopk + y3 = Tfloat_t((x3 - (e + *(*float32)(unsafe.Pointer(bp))) + Float32FromInt32(1)) * twopk) } return y3 } @@ -105274,7 +105274,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { sign = e & int32(0x800) e &= int32(0x7ff) if !(e != 0) { - v1 = x * float64(9.223372036854776e+18) + v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) e = Int32FromUint64(ix >> int32(52) & uint64(0x7ff)) if e != 0 { @@ -105330,11 +105330,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { ny = _normalize(tls, y) nz = _normalize(tls, z) if nx.Fe >= Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) || ny.Fe >= Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) { - return x1*y + z + return float64(x1*y) + z } if nz.Fe >= Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) { if nz.Fe > Int32FromInt32(0x7ff)-Int32FromInt32(0x3ff)-Int32FromInt32(52)-Int32FromInt32(1) { /* z==0 */ - return x1*y + z + return float64(x1*y) + z } return z } @@ -105425,7 +105425,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } } else { /* exact +-0 */ - return x1*y + z + return float64(x1*y) + z } } e -= d @@ -105446,8 +105446,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* min normal after rounding, underflow depends on arch behaviour which can be imitated by a double to float conversion */ - fltmin = float32(Float64FromFloat64(1.0842021401737618e-19) * Float64FromFloat32(1.1754943508222875e-38) * r) - return Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin) + fltmin = float32(float64(Float64FromFloat64(1.0842021401737618e-19)*Float64FromFloat32(1.1754943508222875e-38)) * r) + return float64(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * float64(fltmin)) } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ @@ -105457,11 +105457,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { i = -i } r = float64(i) - r = Float64FromInt32(2)*r - c /* remove top bit */ + r = float64(Float64FromInt32(2)*r) - c /* remove top bit */ /* raise underflow portably, such that it cannot be optimized away */ - tiny = Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r - r += tiny * tiny * (r - r) + tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) + r += float64(Tdouble_t(tiny*tiny) * (r - r)) } } else { /* only round once when scaled */ @@ -105785,11 +105785,11 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { _2: } if v3 || BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 || ex == int32(0x7ff) { - return x * y / (x * y) + return float64(x*y) / float64(x*y) } if uxi<<int32(1) <= *(*Tuint64_t)(unsafe.Pointer(bp + 16))<<int32(1) { if uxi<<int32(1) == *(*Tuint64_t)(unsafe.Pointer(bp + 16))<<int32(1) { - return Float64FromInt32(0) * x + return float64(Float64FromInt32(0) * x) } return x } @@ -105838,7 +105838,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { if i == uint64(0) { - return Float64FromInt32(0) * x + return float64(Float64FromInt32(0) * x) } uxi = i } @@ -105851,7 +105851,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { if i == uint64(0) { - return Float64FromInt32(0) * x + return float64(Float64FromInt32(0) * x) } uxi = i } @@ -105928,11 +105928,11 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { _2: } if v3 || BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 || ex == int32(0xff) { - return x * y / (x * y) + return float32(x*y) / float32(x*y) } if uxi<<int32(1) <= *(*Tuint32_t)(unsafe.Pointer(bp + 8))<<int32(1) { if uxi<<int32(1) == *(*Tuint32_t)(unsafe.Pointer(bp + 8))<<int32(1) { - return Float32FromInt32(0) * x + return float32(Float32FromInt32(0) * x) } return x } @@ -105979,7 +105979,7 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { if i == uint32(0) { - return Float32FromInt32(0) * x + return float32(Float32FromInt32(0) * x) } uxi = i } @@ -105992,7 +105992,7 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { if i == uint32(0) { - return Float32FromInt32(0) * x + return float32(Float32FromInt32(0) * x) } uxi = i } @@ -106051,7 +106051,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { ee = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if !(ee != 0) { if x != 0 { - x = Xfrexp(tls, x*float64(1.8446744073709552e+19), e) + x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) *(*int32)(unsafe.Pointer(e)) -= int32(64) } else { *(*int32)(unsafe.Pointer(e)) = 0 @@ -106127,11 +106127,11 @@ const SPLIT = 1 func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { var xc, xh, xl Tdouble_t _, _, _ = xc, xh, xl - xc = x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1)) + xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = x * x - *(*Tdouble_t)(unsafe.Pointer(lo)) = xh*xh - *(*Tdouble_t)(unsafe.Pointer(hi)) + Float64FromInt32(2)*xh*xl + xl*xl + *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) + *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106232,7 +106232,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16))) + return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106311,7 +106311,7 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { y *= Float32FromFloat32(1.2379400392853803e+27) } } - return z * Xsqrtf(tls, float32(float64(x)*float64(x)+float64(y)*float64(y))) + return float32(z * Xsqrtf(tls, float32(float64(float64(x)*float64(x))+float64(float64(y)*float64(y))))) } func Xhypotl(tls *TLS, x float64, y float64) (r float64) { @@ -106504,8 +106504,8 @@ func _common(tls *TLS, ix Tuint32_t, x float64, y0 int32) (r float64) { /* avoid overflow in 2*x, big ulp error when x>=0x1p1023 */ if ix < uint32(0x7fe00000) { ss = s - c - z = -Xcos(tls, Float64FromInt32(2)*x) - if s*c < Float64FromInt32(0) { + z = -Xcos(tls, float64(Float64FromInt32(2)*x)) + if float64(s*c) < Float64FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -106514,10 +106514,10 @@ func _common(tls *TLS, ix Tuint32_t, x float64, y0 int32) (r float64) { if y0 != 0 { ss = -ss } - cc = _pzero(tls, x)*cc - _qzero(tls, x)*ss + cc = float64(_pzero(tls, x)*cc) - float64(_qzero(tls, x)*ss) } } - return _invsqrtpi * cc / Xsqrt(tls, x) + return float64(_invsqrtpi*cc) / Xsqrt(tls, x) } // C documentation @@ -106545,7 +106545,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { ix &= uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { - return Float64FromInt32(1) / (x * x) + return Float64FromInt32(1) / float64(x*x) } x = Xfabs(tls, x) if ix >= uint32(0x40000000) { /* |x| >= 2 */ @@ -106555,16 +106555,16 @@ func Xj0(tls *TLS, x float64) (r1 float64) { /* 1 - x*x/4 + x*x*R(x^2)/S(x^2) */ if ix >= uint32(0x3f200000) { /* |x| >= 2**-13 */ /* up to 4ulp error close to 2 */ - z = x * x - r = z * (_R02 + z*(_R03+z*(_R04+z*_R05))) - s = Float64FromInt32(1) + z*(_S01+z*(_S02+z*(_S03+z*_S04))) - return (Float64FromInt32(1)+x/Float64FromInt32(2))*(Float64FromInt32(1)-x/Float64FromInt32(2)) + z*(r/s) + z = float64(x * x) + r = float64(z * (_R02 + float64(z*(_R03+float64(z*(_R04+float64(z*_R05))))))) + s = Float64FromInt32(1) + float64(z*(_S01+float64(z*(_S02+float64(z*(_S03+float64(z*_S04))))))) + return float64((Float64FromInt32(1)+x/Float64FromInt32(2))*(Float64FromInt32(1)-x/Float64FromInt32(2))) + float64(z*(r/s)) } /* 1 - x*x/4 */ /* prevent underflow */ /* inexact should be raised when x!=0, this is not done correctly */ if ix >= uint32(0x38000000) { /* |x| >= 2**-127 */ - x = float64(0.25) * x * x + x = float64(float64(float64(0.25)*x) * x) } return Float64FromInt32(1) - x } @@ -106610,12 +106610,12 @@ func Xy0(tls *TLS, x float64) (r float64) { /* U(x^2)/V(x^2) + (2/pi)*j0(x)*log(x) */ if ix >= uint32(0x3e400000) { /* x >= 2**-27 */ /* large ulp error near the first zero, x ~= 0.89 */ - z = x * x - u = _u00 + z*(_u01+z*(_u02+z*(_u03+z*(_u04+z*(_u05+z*_u06))))) - v = float64(1) + z*(_v01+z*(_v02+z*(_v03+z*_v04))) - return u/v + _tpi*(Xj0(tls, x)*Xlog(tls, x)) + z = float64(x * x) + u = _u00 + float64(z*(_u01+float64(z*(_u02+float64(z*(_u03+float64(z*(_u04+float64(z*(_u05+float64(z*_u06))))))))))) + v = float64(1) + float64(z*(_v01+float64(z*(_v02+float64(z*(_v03+float64(z*_v04))))))) + return u/v + float64(_tpi*float64(Xj0(tls, x)*Xlog(tls, x))) } - return _u00 + _tpi*Xlog(tls, x) + return _u00 + float64(_tpi*Xlog(tls, x)) } // C documentation @@ -106716,9 +106716,9 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z**(*float64)(unsafe.Pointer(q + 4*8)))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) return float64(1) + r/s } @@ -106824,9 +106824,9 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z*(*(*float64)(unsafe.Pointer(q + 4*8))+z**(*float64)(unsafe.Pointer(q + 5*8))))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -106848,8 +106848,8 @@ func _common1(tls *TLS, ix Tuint32_t, x float32, y0 int32) (r float32) { cc = s + c if ix < uint32(0x7f000000) { ss = s - c - z = -Xcosf(tls, Float32FromInt32(2)*x) - if s*c < Float32FromInt32(0) { + z = -Xcosf(tls, float32(Float32FromInt32(2)*x)) + if float32(s*c) < Float32FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -106858,10 +106858,10 @@ func _common1(tls *TLS, ix Tuint32_t, x float32, y0 int32) (r float32) { if y0 != 0 { ss = -ss } - cc = _pzerof(tls, x)*cc - _qzerof(tls, x)*ss + cc = float32(_pzerof(tls, x)*cc) - float32(_qzerof(tls, x)*ss) } } - return _invsqrtpi1 * cc / Xsqrtf(tls, x) + return float32(_invsqrtpi1*cc) / Xsqrtf(tls, x) } // C documentation @@ -106888,7 +106888,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { ix = *(*Tuint32_t)(unsafe.Pointer(&x)) ix &= uint32(0x7fffffff) if ix >= uint32(0x7f800000) { - return Float32FromInt32(1) / (x * x) + return Float32FromInt32(1) / float32(x*x) } x = Xfabsf(tls, x) if ix >= uint32(0x40000000) { /* |x| >= 2 */ @@ -106897,13 +106897,13 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { } if ix >= uint32(0x3a000000) { /* |x| >= 2**-11 */ /* up to 4ulp error near 2 */ - z = x * x - r = z * (_R021 + z*(_R031+z*(_R041+z*_R051))) - s = Float32FromInt32(1) + z*(_S011+z*(_S021+z*(_S031+z*_S041))) - return (Float32FromInt32(1)+x/Float32FromInt32(2))*(Float32FromInt32(1)-x/Float32FromInt32(2)) + z*(r/s) + z = float32(x * x) + r = float32(z * (_R021 + float32(z*(_R031+float32(z*(_R041+float32(z*_R051))))))) + s = Float32FromInt32(1) + float32(z*(_S011+float32(z*(_S021+float32(z*(_S031+float32(z*_S041))))))) + return float32((Float32FromInt32(1)+x/Float32FromInt32(2))*(Float32FromInt32(1)-x/Float32FromInt32(2))) + float32(z*(r/s)) } if ix >= uint32(0x21800000) { /* |x| >= 2**-60 */ - x = Float32FromFloat32(0.25) * x * x + x = float32(float32(Float32FromFloat32(0.25)*x) * x) } return Float32FromInt32(1) - x } @@ -106944,12 +106944,12 @@ func Xy0f(tls *TLS, x float32) (r float32) { } if ix >= uint32(0x39000000) { /* x >= 2**-13 */ /* large ulp error at x ~= 0.89 */ - z = x * x - u = _u001 + z*(_u011+z*(_u021+z*(_u031+z*(_u041+z*(_u051+z*_u061))))) - v = Float32FromInt32(1) + z*(_v011+z*(_v021+z*(_v031+z*_v041))) - return u/v + _tpi1*(Xj0f(tls, x)*Xlogf(tls, x)) + z = float32(x * x) + u = _u001 + float32(z*(_u011+float32(z*(_u021+float32(z*(_u031+float32(z*(_u041+float32(z*(_u051+float32(z*_u061))))))))))) + v = Float32FromInt32(1) + float32(z*(_v011+float32(z*(_v021+float32(z*(_v031+float32(z*_v041))))))) + return u/v + float32(_tpi1*float32(Xj0f(tls, x)*Xlogf(tls, x))) } - return _u001 + _tpi1*Xlogf(tls, x) + return _u001 + float32(_tpi1*Xlogf(tls, x)) } // C documentation @@ -107049,9 +107049,9 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z**(*float32)(unsafe.Pointer(q + 4*4)))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107157,9 +107157,9 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z*(*(*float32)(unsafe.Pointer(q + 4*4))+z**(*float32)(unsafe.Pointer(q + 5*4))))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107186,8 +107186,8 @@ func _common2(tls *TLS, ix Tuint32_t, x float64, y1 int32, sign int32) (r float6 if ix < uint32(0x7fe00000) { /* avoid overflow in 2*x */ ss = -s - c - z = Xcos(tls, Float64FromInt32(2)*x) - if s*c > Float64FromInt32(0) { + z = Xcos(tls, float64(Float64FromInt32(2)*x)) + if float64(s*c) > Float64FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -107196,13 +107196,13 @@ func _common2(tls *TLS, ix Tuint32_t, x float64, y1 int32, sign int32) (r float6 if y1 != 0 { ss = -ss } - cc = _pone(tls, x)*cc - _qone(tls, x)*ss + cc = float64(_pone(tls, x)*cc) - float64(_qone(tls, x)*ss) } } if sign != 0 { cc = -cc } - return _invsqrtpi2 * cc / Xsqrt(tls, x) + return float64(_invsqrtpi2*cc) / Xsqrt(tls, x) } // C documentation @@ -107232,21 +107232,21 @@ func Xj1(tls *TLS, x float64) (r1 float64) { sign = Int32FromUint32(ix >> int32(31)) ix &= uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { - return Float64FromInt32(1) / (x * x) + return Float64FromInt32(1) / float64(x*x) } if ix >= uint32(0x40000000) { /* |x| >= 2 */ return _common2(tls, ix, Xfabs(tls, x), 0, sign) } if ix >= uint32(0x38000000) { /* |x| >= 2**-127 */ - z = x * x - r = z * (_r00 + z*(_r01+z*(_r02+z*_r03))) - s = Float64FromInt32(1) + z*(_s01+z*(_s02+z*(_s03+z*(_s04+z*_s05)))) + z = float64(x * x) + r = float64(z * (_r00 + float64(z*(_r01+float64(z*(_r02+float64(z*_r03))))))) + s = Float64FromInt32(1) + float64(z*(_s01+float64(z*(_s02+float64(z*(_s03+float64(z*(_s04+float64(z*_s05))))))))) z = r / s } else { /* avoid underflow, raise inexact if x!=0 */ z = x } - return (float64(0.5) + z) * x + return float64((float64(0.5) + z) * x) } var _U0 = [5]float64{ @@ -107292,10 +107292,10 @@ func Xy1(tls *TLS, x float64) (r float64) { if ix < uint32(0x3c900000) { /* x < 2**-54 */ return -_tpi2 / x } - z = x * x - u = _U0[0] + z*(_U0[int32(1)]+z*(_U0[int32(2)]+z*(_U0[int32(3)]+z*_U0[int32(4)]))) - v = Float64FromInt32(1) + z*(_V0[0]+z*(_V0[int32(1)]+z*(_V0[int32(2)]+z*(_V0[int32(3)]+z*_V0[int32(4)])))) - return x*(u/v) + _tpi2*(Xj1(tls, x)*Xlog(tls, x)-Float64FromInt32(1)/x) + z = float64(x * x) + u = _U0[0] + float64(z*(_U0[int32(1)]+float64(z*(_U0[int32(2)]+float64(z*(_U0[int32(3)]+float64(z*_U0[int32(4)]))))))) + v = Float64FromInt32(1) + float64(z*(_V0[0]+float64(z*(_V0[int32(1)]+float64(z*(_V0[int32(2)]+float64(z*(_V0[int32(3)]+float64(z*_V0[int32(4)]))))))))) + return float64(x*(u/v)) + float64(_tpi2*(float64(Xj1(tls, x)*Xlog(tls, x))-Float64FromInt32(1)/x)) } /* For x >= 8, the asymptotic expansions of pone is @@ -107395,9 +107395,9 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z**(*float64)(unsafe.Pointer(q + 4*8)))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) return float64(1) + r/s } @@ -107502,9 +107502,9 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } } - z = float64(1) / (x * x) - r = *(*float64)(unsafe.Pointer(p)) + z*(*(*float64)(unsafe.Pointer(p + 1*8))+z*(*(*float64)(unsafe.Pointer(p + 2*8))+z*(*(*float64)(unsafe.Pointer(p + 3*8))+z*(*(*float64)(unsafe.Pointer(p + 4*8))+z**(*float64)(unsafe.Pointer(p + 5*8)))))) - s = float64(1) + z*(*(*float64)(unsafe.Pointer(q))+z*(*(*float64)(unsafe.Pointer(q + 1*8))+z*(*(*float64)(unsafe.Pointer(q + 2*8))+z*(*(*float64)(unsafe.Pointer(q + 3*8))+z*(*(*float64)(unsafe.Pointer(q + 4*8))+z**(*float64)(unsafe.Pointer(q + 5*8))))))) + z = float64(1) / float64(x*x) + r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) + s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -107522,8 +107522,8 @@ func _common3(tls *TLS, ix Tuint32_t, x float32, y1 int32, sign int32) (r float3 cc = s - c if ix < uint32(0x7f000000) { ss = -s - c - z = float64(Xcosf(tls, Float32FromInt32(2)*x)) - if s*c > Float64FromInt32(0) { + z = float64(Xcosf(tls, float32(Float32FromInt32(2)*x))) + if float64(s*c) > Float64FromInt32(0) { cc = z / ss } else { ss = z / cc @@ -107532,13 +107532,13 @@ func _common3(tls *TLS, ix Tuint32_t, x float32, y1 int32, sign int32) (r float3 if y1 != 0 { ss = -ss } - cc = float64(_ponef(tls, x))*cc - float64(_qonef(tls, x))*ss + cc = float64(float64(_ponef(tls, x))*cc) - float64(float64(_qonef(tls, x))*ss) } } if sign != 0 { cc = -cc } - return float32(float64(_invsqrtpi3) * cc / float64(Xsqrtf(tls, x))) + return float32(float64(float64(_invsqrtpi3)*cc) / float64(Xsqrtf(tls, x))) } // C documentation @@ -107568,20 +107568,20 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { sign = Int32FromUint32(ix >> int32(31)) ix &= uint32(0x7fffffff) if ix >= uint32(0x7f800000) { - return Float32FromInt32(1) / (x * x) + return Float32FromInt32(1) / float32(x*x) } if ix >= uint32(0x40000000) { /* |x| >= 2 */ return _common3(tls, ix, Xfabsf(tls, x), 0, sign) } if ix >= uint32(0x39000000) { /* |x| >= 2**-13 */ - z = x * x - r = z * (_r001 + z*(_r011+z*(_r021+z*_r031))) - s = Float32FromInt32(1) + z*(_s011+z*(_s021+z*(_s031+z*(_s041+z*_s051)))) + z = float32(x * x) + r = float32(z * (_r001 + float32(z*(_r011+float32(z*(_r021+float32(z*_r031))))))) + s = Float32FromInt32(1) + float32(z*(_s011+float32(z*(_s021+float32(z*(_s031+float32(z*(_s041+float32(z*_s051))))))))) z = Float32FromFloat32(0.5) + r/s } else { z = Float32FromFloat32(0.5) } - return z * x + return float32(z * x) } var _U01 = [5]float32{ @@ -107623,10 +107623,10 @@ func Xy1f(tls *TLS, x float32) (r float32) { if ix < uint32(0x33000000) { /* x < 2**-25 */ return -_tpi3 / x } - z = x * x - u = _U01[0] + z*(_U01[int32(1)]+z*(_U01[int32(2)]+z*(_U01[int32(3)]+z*_U01[int32(4)]))) - v = Float32FromFloat32(1) + z*(_V01[0]+z*(_V01[int32(1)]+z*(_V01[int32(2)]+z*(_V01[int32(3)]+z*_V01[int32(4)])))) - return x*(u/v) + _tpi3*(Xj1f(tls, x)*Xlogf(tls, x)-Float32FromFloat32(1)/x) + z = float32(x * x) + u = _U01[0] + float32(z*(_U01[int32(1)]+float32(z*(_U01[int32(2)]+float32(z*(_U01[int32(3)]+float32(z*_U01[int32(4)]))))))) + v = Float32FromFloat32(1) + float32(z*(_V01[0]+float32(z*(_V01[int32(1)]+float32(z*(_V01[int32(2)]+float32(z*(_V01[int32(3)]+float32(z*_V01[int32(4)]))))))))) + return float32(x*(u/v)) + float32(_tpi3*(float32(Xj1f(tls, x)*Xlogf(tls, x))-Float32FromFloat32(1)/x)) } /* For x >= 8, the asymptotic expansions of pone is @@ -107726,9 +107726,9 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z**(*float32)(unsafe.Pointer(q + 4*4)))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107833,9 +107833,9 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } } - z = Float32FromFloat32(1) / (x * x) - r = *(*float32)(unsafe.Pointer(p)) + z*(*(*float32)(unsafe.Pointer(p + 1*4))+z*(*(*float32)(unsafe.Pointer(p + 2*4))+z*(*(*float32)(unsafe.Pointer(p + 3*4))+z*(*(*float32)(unsafe.Pointer(p + 4*4))+z**(*float32)(unsafe.Pointer(p + 5*4)))))) - s = Float32FromFloat32(1) + z*(*(*float32)(unsafe.Pointer(q))+z*(*(*float32)(unsafe.Pointer(q + 1*4))+z*(*(*float32)(unsafe.Pointer(q + 2*4))+z*(*(*float32)(unsafe.Pointer(q + 3*4))+z*(*(*float32)(unsafe.Pointer(q + 4*4))+z**(*float32)(unsafe.Pointer(q + 5*4))))))) + z = Float32FromFloat32(1) / float32(x*x) + r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -107910,7 +107910,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { temp = Xcos(tls, x) + Xsin(tls, x) break } - b = _invsqrtpi4 * temp / Xsqrt(tls, x) + b = float64(_invsqrtpi4*temp) / Xsqrt(tls, x) } else { a = Xj0(tls, x) b = Xj1(tls, x) @@ -107921,7 +107921,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { } i++ temp = b - b = b*(float64(2)*float64(i)/x) - a /* avoid underflow */ + b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp goto _1 _1: @@ -107935,7 +107935,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if nm1 > int32(32) { /* underflow */ b = float64(0) } else { - temp = x * float64(0.5) + temp = float64(x * float64(0.5)) b = temp a = float64(1) i = int32(2) @@ -107954,16 +107954,16 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { } } else { nf = float64(nm1) + float64(1) - w = Float64FromInt32(2) * nf / x + w = float64(Float64FromInt32(2)*nf) / x h = Float64FromInt32(2) / x z = w + h q0 = w - q1 = w*z - float64(1) + q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { k += int32(1) z += h - tmp = z*q1 - q0 + tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp } @@ -107973,7 +107973,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i >= 0) { break } - t = Float64FromInt32(1) / (Float64FromInt32(2)*(float64(i)+nf)/x - t) + t = Float64FromInt32(1) / (float64(Float64FromInt32(2)*(float64(i)+nf))/x - t) goto _3 _3: ; @@ -107989,7 +107989,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { * then recurrent value may overflow and the result is * likely underflow to zero */ - tmp = nf * Xlog(tls, Xfabs(tls, w)) + tmp = float64(nf * Xlog(tls, Xfabs(tls, w))) if tmp < float64(709.782712893384) { i = nm1 for { @@ -107997,7 +107997,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { break } temp = b - b = b*(float64(2)*float64(i))/x - a + b = float64(b*float64(float64(2)*float64(i)))/x - a a = temp goto _4 _4: @@ -108011,7 +108011,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { break } temp = b - b = b*(float64(2)*float64(i))/x - a + b = float64(b*float64(float64(2)*float64(i)))/x - a a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { @@ -108028,9 +108028,9 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { z = Xj0(tls, x) w = Xj1(tls, x) if Xfabs(tls, z) >= Xfabs(tls, w) { - b = t * z / b + b = float64(t*z) / b } else { - b = t * w / a + b = float64(t*w) / a } } } @@ -108112,7 +108112,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { temp = Xsin(tls, x) - Xcos(tls, x) break } - b = _invsqrtpi4 * temp / Xsqrt(tls, x) + b = float64(_invsqrtpi4*temp) / Xsqrt(tls, x) } else { a = Xy0(tls, x) b = Xy1(tls, x) @@ -108125,7 +108125,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } i++ temp = b - b = float64(2)*float64(i)/x*b - a + b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) a = temp goto _2 @@ -108185,7 +108185,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { } i++ temp = b - b = b*(Float32FromFloat32(2)*float32(i)/x) - a + b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp goto _1 _1: @@ -108198,7 +108198,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if nm1 > int32(8) { /* underflow */ nm1 = int32(8) } - temp = Float32FromFloat32(0.5) * x + temp = float32(Float32FromFloat32(0.5) * x) b = temp a = Float32FromFloat32(1) i = int32(2) @@ -108216,16 +108216,16 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { b = b / a } else { nf = float32(nm1) + Float32FromFloat32(1) - w = Float32FromInt32(2) * nf / x + w = float32(Float32FromInt32(2)*nf) / x h = Float32FromInt32(2) / x z = w + h q0 = w - q1 = w*z - Float32FromFloat32(1) + q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { k += int32(1) z += h - tmp = z*q1 - q0 + tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp } @@ -108235,7 +108235,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i >= 0) { break } - t = Float32FromFloat32(1) / (Float32FromInt32(2)*(float32(i)+nf)/x - t) + t = Float32FromFloat32(1) / (float32(Float32FromInt32(2)*(float32(i)+nf))/x - t) goto _3 _3: ; @@ -108251,7 +108251,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { * then recurrent value may overflow and the result is * likely underflow to zero */ - tmp = nf * Xlogf(tls, Xfabsf(tls, w)) + tmp = float32(nf * Xlogf(tls, Xfabsf(tls, w))) if tmp < Float32FromFloat32(88.721679688) { i = nm1 for { @@ -108259,7 +108259,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { break } temp = b - b = Float32FromFloat32(2)*float32(i)*b/x - a + b = float32(float32(Float32FromFloat32(2)*float32(i))*b)/x - a a = temp goto _4 _4: @@ -108273,7 +108273,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { break } temp = b - b = Float32FromFloat32(2)*float32(i)*b/x - a + b = float32(float32(Float32FromFloat32(2)*float32(i))*b)/x - a a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { @@ -108290,9 +108290,9 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { z = Xj0f(tls, x) w = Xj1f(tls, x) if Xfabsf(tls, z) >= Xfabsf(tls, w) { - b = t * z / b + b = float32(t*z) / b } else { - b = t * w / a + b = float32(t*w) / a } } } @@ -108355,7 +108355,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { } i++ temp = b - b = Float32FromFloat32(2)*float32(i)/x*b - a + b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) a = temp goto _2 @@ -108472,8 +108472,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { var n int32 _ = n /* spurious inexact if odd int */ - x = float64(2) * (x*float64(0.5) - Xfloor(tls, x*float64(0.5))) /* x mod 2.0 */ - n = int32(x * Float64FromFloat64(4)) + x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ + n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) x -= float64(float32(n) * Float32FromFloat32(0.5)) x *= _pi2 @@ -108520,7 +108520,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { - return x * x + return float64(x * x) } if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))<<Int32FromInt32(20)) { /* |x|<2**-70, return -log(|x|) */ if sign != 0 { @@ -108540,7 +108540,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { } else { t = -t } - nadj = Xlog(tls, _pi2/(t*x)) + nadj = Xlog(tls, _pi2/Tdouble_t(t*x)) } /* purge off 1 and 2 */ if (ix == uint32(0x3ff00000) || ix == uint32(0x40000000)) && uint32(*(*Tuint64_t)(unsafe.Pointer(bp))) == uint32(0) { @@ -108578,31 +108578,31 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { } switch i { case 0: - z = y * y - p1 = _a0 + z*(_a2+z*(_a4+z*(_a6+z*(_a8+z*_a10)))) - p2 = z * (_a1 + z*(_a3+z*(_a5+z*(_a7+z*(_a9+z*_a11))))) - p = y*p1 + p2 - r += p - float64(0.5)*y + z = Tdouble_t(y * y) + p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) + p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) + p = Tdouble_t(y*p1) + p2 + r += p - Tdouble_t(float64(0.5)*y) case int32(1): - z = y * y - w = z * y - p1 = _t0 + w*(_t3+w*(_t6+w*(_t9+w*_t12))) /* parallel comp */ - p2 = _t1 + w*(_t4+w*(_t7+w*(_t10+w*_t13))) - p3 = _t2 + w*(_t5+w*(_t8+w*(_t11+w*_t14))) - p = z*p1 - (_tt - w*(p2+y*p3)) + z = Tdouble_t(y * y) + w = Tdouble_t(z * y) + p1 = _t0 + float64(w*(_t3+float64(w*(_t6+float64(w*(_t9+float64(w*_t12))))))) /* parallel comp */ + p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) + p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) + p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) r += _tf + p case int32(2): - p1 = y * (_u0 + y*(_u1+y*(_u2+y*(_u3+y*(_u4+y*_u5))))) - p2 = float64(1) + y*(_v1+y*(_v2+y*(_v3+y*(_v4+y*_v5)))) - r += -Float64FromFloat64(0.5)*y + p1/p2 + p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) + p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) + r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ i = int32(x) y = x - float64(i) - p = y * (_s0 + y*(_s1+y*(_s2+y*(_s3+y*(_s4+y*(_s5+y*_s6)))))) - q = float64(1) + y*(_r1+y*(_r2+y*(_r3+y*(_r4+y*(_r5+y*_r6))))) - r = float64(0.5)*y + p/q + p = Tdouble_t(y * (_s0 + float64(y*(_s1+float64(y*(_s2+float64(y*(_s3+float64(y*(_s4+float64(y*(_s5+float64(y*_s6))))))))))))) + q = float64(1) + float64(y*(_r1+float64(y*(_r2+float64(y*(_r3+float64(y*(_r4+float64(y*(_r5+float64(y*_r6))))))))))) + r = float64(float64(0.5)*y) + p/q z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): @@ -108626,11 +108626,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < uint32(0x43900000) { /* 8.0 <= x < 2**58 */ t = Xlog(tls, x) z = float64(1) / x - y = z * z - w = _w0 + z*(_w1+y*(_w2+y*(_w3+y*(_w4+y*(_w5+y*_w6))))) - r = (x-float64(0.5))*(t-Float64FromFloat64(1)) + w + y = Tdouble_t(z * z) + w = _w0 + float64(z*(_w1+float64(y*(_w2+float64(y*(_w3+float64(y*(_w4+float64(y*(_w5+float64(y*_w6))))))))))) + r = float64((x-float64(0.5))*(t-Float64FromFloat64(1))) + w } else { /* 2**58 <= x <= inf */ - r = x * (Xlog(tls, x) - float64(1)) + r = Tdouble_t(x * (Xlog(tls, x) - float64(1))) } } } @@ -108729,10 +108729,10 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { var y Tdouble_t _, _ = n, y /* spurious inexact if odd int */ - x = Float32FromInt32(2) * (x*Float32FromFloat32(0.5) - Xfloorf(tls, x*Float32FromFloat32(0.5))) /* x mod 2.0 */ - n = int32(x * Float32FromInt32(4)) + x = float32(Float32FromInt32(2) * (float32(x*Float32FromFloat32(0.5)) - Xfloorf(tls, float32(x*Float32FromFloat32(0.5))))) /* x mod 2.0 */ + n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) - y = float64(x - float32(n)*Float32FromFloat32(0.5)) + y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) y *= float64(3.141592653589793) switch n { default: /* case 4: */ @@ -108777,7 +108777,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { - return x * x + return float32(x * x) } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { @@ -108797,7 +108797,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } else { t = -t } - nadj = Xlogf(tls, _pi3/(t*x)) + nadj = Xlogf(tls, _pi3/float32(t*x)) } /* purge off 1 and 2 */ if ix == uint32(0x3f800000) || ix == uint32(0x40000000) { @@ -108835,31 +108835,31 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } switch i { case 0: - z = y * y - p1 = _a01 + z*(_a21+z*(_a41+z*(_a61+z*(_a81+z*_a101)))) - p2 = z * (_a12 + z*(_a31+z*(_a51+z*(_a71+z*(_a91+z*_a111))))) - p = y*p1 + p2 - r += p - Float32FromFloat32(0.5)*y + z = float32(y * y) + p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) + p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) + p = float32(y*p1) + p2 + r += p - float32(Float32FromFloat32(0.5)*y) case int32(1): - z = y * y - w = z * y - p1 = _t01 + w*(_t31+w*(_t61+w*(_t91+w*_t121))) /* parallel comp */ - p2 = _t15 + w*(_t41+w*(_t71+w*(_t101+w*_t131))) - p3 = _t21 + w*(_t51+w*(_t81+w*(_t111+w*_t141))) - p = z*p1 - (_tt1 - w*(p2+y*p3)) + z = float32(y * y) + w = float32(z * y) + p1 = _t01 + float32(w*(_t31+float32(w*(_t61+float32(w*(_t91+float32(w*_t121))))))) /* parallel comp */ + p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) + p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) + p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) r += _tf1 + p case int32(2): - p1 = y * (_u07 + y*(_u11+y*(_u21+y*(_u31+y*(_u41+y*_u51))))) - p2 = Float32FromFloat32(1) + y*(_v11+y*(_v21+y*(_v31+y*(_v41+y*_v51)))) - r += -Float32FromFloat32(0.5)*y + p1/p2 + p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) + p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) + r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ i = int32(x) y = x - float32(i) - p = y * (_s06 + y*(_s11+y*(_s21+y*(_s31+y*(_s41+y*(_s51+y*_s61)))))) - q = Float32FromFloat32(1) + y*(_r11+y*(_r21+y*(_r31+y*(_r41+y*(_r51+y*_r61))))) - r = Float32FromFloat32(0.5)*y + p/q + p = float32(y * (_s06 + float32(y*(_s11+float32(y*(_s21+float32(y*(_s31+float32(y*(_s41+float32(y*(_s51+float32(y*_s61))))))))))))) + q = Float32FromFloat32(1) + float32(y*(_r11+float32(y*(_r21+float32(y*(_r31+float32(y*(_r41+float32(y*(_r51+float32(y*_r61))))))))))) + r = float32(Float32FromFloat32(0.5)*y) + p/q z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): @@ -108883,11 +108883,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { if ix < uint32(0x5c800000) { /* 8.0 <= x < 2**58 */ t = Xlogf(tls, x) z = Float32FromFloat32(1) / x - y = z * z - w = _w01 + z*(_w11+y*(_w21+y*(_w31+y*(_w41+y*(_w51+y*_w61))))) - r = (x-Float32FromFloat32(0.5))*(t-Float32FromFloat32(1)) + w + y = float32(z * z) + w = _w01 + float32(z*(_w11+float32(y*(_w21+float32(y*(_w31+float32(y*(_w41+float32(y*(_w51+float32(y*_w61))))))))))) + r = float32((x-Float32FromFloat32(0.5))*(t-Float32FromFloat32(1))) + w } else { /* 2**58 <= x <= inf */ - r = x * (Xlogf(tls, x) - Float32FromFloat32(1)) + r = float32(x * (Xlogf(tls, x) - Float32FromFloat32(1))) } } } @@ -109022,17 +109022,17 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - r2 = r * r - r3 = r * r2 - y1 = r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8)) + r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8)) + r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8))+r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8))+r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8))+r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8))+r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))) + r2 = Tdouble_t(r * r) + r3 = Tdouble_t(r * r2) + y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ - w = r * float64(1.34217728e+08) + w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = rhi * rhi * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56)) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56)) * rlo * (rhi + r) + lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) y1 += lo y1 += hi y = y1 @@ -109054,7 +109054,7 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = x1 * float64(4.503599627370496e+15) + v9 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } @@ -109080,16 +109080,16 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) kd = float64(k) /* hi + lo = r + log(c) + k*Ln2. */ - w = kd*X__log_data.Fln2hi + logc + w = Tdouble_t(kd*X__log_data.Fln2hi) + logc hi = w + r - lo = w - hi + r + kd*X__log_data.Fln2lo + lo = w - hi + r + Tdouble_t(kd*X__log_data.Fln2lo) /* log(x) = lo + (log1p(r) - r) + hi. */ - r2 = r * r /* rounding error: 0x1p-54/N^2. */ + r2 = Tdouble_t(r * r) /* rounding error: 0x1p-54/N^2. */ /* Worst case error if |y| > 0x1p-5: 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma) Worst case error if |y| > 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16)) + r*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8))+r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8)))) + hi + y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v10 = y goto _11 @@ -109136,7 +109136,7 @@ func Xlog10(tls *TLS, x float64) (r float64) { k = 0 if hx < uint32(0x00100000) || hx>>int32(31) != 0 { if *(*Tuint64_t)(unsafe.Pointer(bp))<<int32(1) == uint64(0) { - return float64(-Int32FromInt32(1)) / (x * x) + return float64(-Int32FromInt32(1)) / float64(x*x) } /* log(+-0)=-inf */ if hx>>int32(31) != 0 { return (x - x) / float64(0) @@ -109162,12 +109162,12 @@ func Xlog10(tls *TLS, x float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff) x = *(*float64)(unsafe.Pointer(bp)) f = x - float64(1) - hfsq = float64(0.5) * f * f + hfsq = Tdouble_t(float64(float64(0.5)*f) * f) s = f / (Float64FromFloat64(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg2 + w*(_Lg4+w*_Lg6)) - t2 = z * (_Lg1 + w*(_Lg3+w*(_Lg5+w*_Lg7))) + z = Tdouble_t(s * s) + w = Tdouble_t(z * z) + t1 = Tdouble_t(w * (_Lg2 + float64(w*(_Lg4+float64(w*_Lg6))))) + t2 = Tdouble_t(z * (_Lg1 + float64(w*(_Lg3+float64(w*(_Lg5+float64(w*_Lg7))))))) R = t2 + t1 /* See log2.c for details. */ /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */ @@ -109175,12 +109175,12 @@ func Xlog10(tls *TLS, x float64) (r float64) { *(*float64)(unsafe.Pointer(bp)) = hi *(*Tuint64_t)(unsafe.Pointer(bp)) &= Uint64FromInt32(-Int32FromInt32(1)) << Int32FromInt32(32) hi = *(*float64)(unsafe.Pointer(bp)) - lo = f - hi - hfsq + s*(hfsq+R) + lo = f - hi - hfsq + Tdouble_t(s*(hfsq+R)) /* val_hi+val_lo ~ log10(1+f) + k*log10(2) */ - val_hi = hi * _ivln10hi + val_hi = Tdouble_t(hi * _ivln10hi) dk = float64(k) - y = dk * _log10_2hi - val_lo = dk*_log10_2lo + (lo+hi)*_ivln10lo + lo*_ivln10hi + y = Tdouble_t(dk * _log10_2hi) + val_lo = Tdouble_t(dk*_log10_2lo) + Tdouble_t((lo+hi)*_ivln10lo) + Tdouble_t(lo*_ivln10hi) /* * Extra precision in for adding y is not strictly needed * since there is no very large cancellation near x = sqrt(2) or @@ -109230,7 +109230,7 @@ func Xlog10f(tls *TLS, x float32) (r float32) { k = 0 if ix < uint32(0x00800000) || ix>>int32(31) != 0 { /* x < 2**-126 */ if ix<<int32(1) == uint32(0) { - return float32(-Int32FromInt32(1)) / (x * x) + return float32(-Int32FromInt32(1)) / float32(x*x) } /* log(+-0)=-inf */ if ix>>int32(31) != 0 { return (x - x) / Float32FromFloat32(0) @@ -109257,19 +109257,19 @@ func Xlog10f(tls *TLS, x float32) (r float32) { x = *(*float32)(unsafe.Pointer(bp)) f = x - Float32FromFloat32(1) s = f / (Float32FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg21 + w*_Lg41) - t2 = z * (_Lg11 + w*_Lg31) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (_Lg21 + float32(w*_Lg41))) + t2 = Tfloat_t(z * (_Lg11 + float32(w*_Lg31))) R = t2 + t1 - hfsq = Float32FromFloat32(0.5) * f * f + hfsq = Tfloat_t(float32(Float32FromFloat32(0.5)*f) * f) hi = f - hfsq *(*float32)(unsafe.Pointer(bp)) = hi *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0xfffff000) hi = *(*float32)(unsafe.Pointer(bp)) - lo = f - hi - hfsq + s*(hfsq+R) + lo = f - hi - hfsq + Tfloat_t(s*(hfsq+R)) dk = float32(k) - return dk*_log10_2lo1 + (lo+hi)*_ivln10lo1 + lo*_ivln10hi1 + hi*_ivln10hi1 + dk*_log10_2hi1 + return Tfloat_t(dk*_log10_2lo1) + Tfloat_t((lo+hi)*_ivln10lo1) + Tfloat_t(lo*_ivln10hi1) + Tfloat_t(hi*_ivln10hi1) + Tfloat_t(dk*_log10_2hi1) } func Xlog10l(tls *TLS, x float64) (r float64) { @@ -109371,15 +109371,15 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hu)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff) f = *(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1) } - hfsq = float64(0.5) * f * f + hfsq = Tdouble_t(float64(float64(0.5)*f) * f) s = f / (Float64FromFloat64(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg22 + w*(_Lg42+w*_Lg61)) - t2 = z * (_Lg12 + w*(_Lg32+w*(_Lg51+w*_Lg71))) + z = Tdouble_t(s * s) + w = Tdouble_t(z * z) + t1 = Tdouble_t(w * (_Lg22 + float64(w*(_Lg42+float64(w*_Lg61))))) + t2 = Tdouble_t(z * (_Lg12 + float64(w*(_Lg32+float64(w*(_Lg51+float64(w*_Lg71))))))) R = t2 + t1 dk = float64(k) - return s*(hfsq+R) + (dk*_ln2_lo2 + c) - hfsq + f + dk*_ln2_hi2 + return Tdouble_t(s*(hfsq+R)) + (Tdouble_t(dk*_ln2_lo2) + c) - hfsq + f + Tdouble_t(dk*_ln2_hi2) } var _ln2_hi3 = float32(0.69313812256) /* 0x3f317180 */ @@ -109428,7 +109428,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { /* underflow if subnormal */ if ix&uint32(0x7f800000) == uint32(0) { if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -109472,14 +109472,14 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { f = *(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1) } s = f / (Float32FromFloat32(2) + f) - z = s * s - w = z * z - t1 = w * (_Lg23 + w*_Lg43) - t2 = z * (_Lg13 + w*_Lg33) + z = Tfloat_t(s * s) + w = Tfloat_t(z * z) + t1 = Tfloat_t(w * (_Lg23 + float32(w*_Lg43))) + t2 = Tfloat_t(z * (_Lg13 + float32(w*_Lg33))) R = t2 + t1 - hfsq = Float32FromFloat32(0.5) * f * f + hfsq = Tfloat_t(float32(Float32FromFloat32(0.5)*f) * f) dk = float32(k) - return s*(hfsq+R) + (dk*_ln2_lo3 + c) - hfsq + f + dk*_ln2_hi3 + return Tfloat_t(s*(hfsq+R)) + (Tfloat_t(dk*_ln2_lo3) + c) - hfsq + f + Tfloat_t(dk*_ln2_hi3) } func Xlog1pl(tls *TLS, x float64) (r float64) { @@ -109529,15 +109529,15 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - hi = r * X__log2_data.Finvln2hi - lo = r*X__log2_data.Finvln2lo + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) - r2 = r * r /* rounding error: 0x1p-62. */ - r4 = r2 * r2 + hi = Tdouble_t(r * X__log2_data.Finvln2hi) + lo = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -hi)) + r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ + r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))) + p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo += hi - y1 + p - lo += r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)) + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))) + r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8))+r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))) + lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 += lo y = y1 v6 = y @@ -109558,7 +109558,7 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = x1 * float64(4.503599627370496e+15) + v9 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } @@ -109583,20 +109583,20 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* r ~= z/c - 1, |r| < 1/(2*N). */ /* rounding error: 0x1p-55/N. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) - t1 = r * X__log2_data.Finvln2hi - t2 = r*X__log2_data.Finvln2lo + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) + t1 = Tdouble_t(r * X__log2_data.Finvln2hi) + t2 = Tdouble_t(r*X__log2_data.Finvln2lo) + float64(X__builtin_fma(tls, r, X__log2_data.Finvln2hi, -t1)) /* hi + lo = r/ln2 + log2(c) + k. */ t3 = kd + logc hi = t3 + t1 lo = t3 - hi + t1 + t2 /* log2(r+1) = r/ln2 + r^2*poly(r). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r /* rounding error: 0x1p-54/N^2. */ - r4 = r2 * r2 + r2 = Tdouble_t(r * r) /* rounding error: 0x1p-54/N^2. */ + r4 = Tdouble_t(r2 * r2) /* Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8)) + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))) + r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))) - y1 = lo + r2*p + hi + p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + y1 = lo + Tdouble_t(r2*p) + hi y = y1 v10 = y goto _11 @@ -109655,7 +109655,7 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { return X__math_invalidf(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * Float32FromFloat32(8.388608e+06) + v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } @@ -109677,14 +109677,14 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ - r = z*invc - Float64FromInt32(1) + r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ - r2 = r * r - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2 + y1 - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r + y0 - y1 = y1*r2 + p + r2 = Tdouble_t(r * r) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = Tdouble_t(y1*r2) + p y = float32(y1) v2 = y goto _3 @@ -109746,10 +109746,10 @@ func Xlogb(tls *TLS, x float64) (r float64) { goto _2 _2: if !(BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0) { - return x * x + return float64(x * x) } if x == Float64FromInt32(0) { - return float64(-Int32FromInt32(1)) / (x * x) + return float64(-Int32FromInt32(1)) / float64(x*x) } return float64(Xilogb(tls, x)) } @@ -109772,10 +109772,10 @@ func Xlogbf(tls *TLS, x float32) (r float32) { goto _2 _2: if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { - return x * x + return float32(x * x) } if x == Float32FromInt32(0) { - return float32(-Int32FromInt32(1)) / (x * x) + return float32(-Int32FromInt32(1)) / float32(x*x) } return float32(Xilogbf(tls, x)) } @@ -109798,10 +109798,10 @@ func Xlogbl(tls *TLS, x float64) (r float64) { goto _2 _2: if !(BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0) { - return x * x + return float64(x * x) } if x == Float64FromInt32(0) { - return float64(-Int32FromInt32(1)) / (x * x) + return float64(-Int32FromInt32(1)) / float64(x*x) } return float64(Xilogbl(tls, x)) } @@ -109845,7 +109845,7 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { return X__math_invalidf(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * Float32FromFloat32(8.388608e+06) + v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } @@ -109866,13 +109866,13 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ - r = z*invc - Float64FromInt32(1) - y0 = logc + float64(k)*X__logf_data.Fln2 + r = Tdouble_t(z*invc) - Float64FromInt32(1) + y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ - r2 = r * r - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2 + y1 - y1 = y1*r2 + (y0 + r) + r2 = Tdouble_t(r * r) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v2 = y goto _3 @@ -110200,12 +110200,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == 0 { if uint64(8) == uint64(4) { - y = float32(x3*x3 + *(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8))) + y = float32(float64(x3*x3) + float64(*(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8)))) } else { if uint64(8) == uint64(8) { - y1 = x3*x3 + *(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8)) + y1 = float64(x3*x3) + float64(*(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8))) } else { - y2 = x3*x3 + *(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8)) + y2 = float64(x3*x3) + float64(*(*float64)(unsafe.Pointer(bp + 8))**(*float64)(unsafe.Pointer(bp + 8))) } } } @@ -110300,12 +110300,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(4) { - y = x3*x3 + *(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4)) + y = float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4))) } else { if uint64(4) == uint64(8) { - y1 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4))) + y1 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4)))) } else { - y2 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4))) + y2 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 4))**(*float32)(unsafe.Pointer(bp + 4)))) } } } @@ -110427,12 +110427,12 @@ _2: /* raise underflow if ux.f is subnormal or zero */ if e == uint32(0) { if uint64(4) == uint64(4) { - y = x3*x3 + *(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16)) + y = float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16))) } else { if uint64(4) == uint64(8) { - y1 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16))) + y1 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16)))) } else { - y2 = float64(x3*x3 + *(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16))) + y2 = float64(float32(x3*x3) + float32(*(*float32)(unsafe.Pointer(bp + 16))**(*float32)(unsafe.Pointer(bp + 16)))) } } } @@ -110507,19 +110507,19 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) /* k*Ln2 + log(c) + r. */ - t1 = kd*X__pow_log_data.Fln2hi + logc + t1 = Tdouble_t(kd*X__pow_log_data.Fln2hi) + logc t2 = t1 + r - lo1 = kd*X__pow_log_data.Fln2lo + logctail + lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r /* A[0] = -0.5. */ - ar2 = r * ar - ar3 = r * ar2 + ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar2 = Tdouble_t(r * ar) + ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ hi = t2 + ar2 lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* p = log1p(r) - r - A[0]*r*r. */ - p = ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8)) + ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8))+ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))) + p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo @@ -110544,7 +110544,7 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl /* k > 0, the exponent of scale might have overflowed by <= 460. */ sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<<Int32FromInt32(52)) scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = float64(5.486124068793689e+303) * (scale + scale*tmp) + y3 = Tdouble_t(float64(5.486124068793689e+303) * (scale + Tdouble_t(scale*tmp))) y = y3 v1 = y goto _2 @@ -110555,13 +110555,13 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl sbits = Tuint64_t(sbits + Uint64FromUint64(1022)<<Int32FromInt32(52)) /* Note: sbits is signed scale. */ scale = *(*float64)(unsafe.Pointer(&sbits)) - y3 = scale + scale*tmp + y3 = scale + Tdouble_t(scale*tmp) if Xfabs(tls, y3) < float64(1) { one = float64(1) if y3 < float64(0) { one = -Float64FromFloat64(1) } - lo = scale - y3 + scale*tmp + lo = scale - y3 + Tdouble_t(scale*tmp) hi = one + y3 lo = one - hi + y3 + lo y = hi + lo @@ -110579,9 +110579,9 @@ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r fl v6 = y1 goto _7 _7: - y2 = v6 * float64(2.2250738585072014e-308) + y2 = float64(v6 * float64(2.2250738585072014e-308)) } - y3 = float64(2.2250738585072014e-308) * y3 + y3 = Tdouble_t(float64(2.2250738585072014e-308) * y3) y = y3 v8 = y goto _9 @@ -110626,7 +110626,7 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( } /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ - z = X__exp_data.Finvln2N * x1 + z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift v3 = y @@ -110636,7 +110636,7 @@ _4: v5 = kd ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) kd -= X__exp_data.Fshift - r = x1 + kd*X__exp_data.Fnegln2hiN + kd*X__exp_data.Fnegln2loN + r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ r += xtail /* 2^(k/N) ~= scale * (1 + tail). */ @@ -110648,17 +110648,17 @@ _4: sbits = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 112 + uintptr(idx+uint64(1))*8)) + top /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ /* Evaluation is optimized assuming superscalar pipelined execution. */ - r2 = r * r + r2 = Tdouble_t(r * r) /* Without fma the worst case error is 0.25/N ulp larger. */ /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. */ - tmp = tail + r + r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))) + r2*r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))) + tmp = tail + r + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(5)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(6)-Int32FromInt32(EXP_POLY_ORDER))*8))))) + Tdouble_t(Tdouble_t(r2*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(7)-Int32FromInt32(EXP_POLY_ORDER))*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp_data)) + 32 + uintptr(Int32FromInt32(8)-Int32FromInt32(EXP_POLY_ORDER))*8))))) if abstop == uint32(0) { return _specialcase2(tls, tmp, sbits, ki) } scale = *(*float64)(unsafe.Pointer(&sbits)) /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ - y = scale + scale*tmp + y = scale + Tdouble_t(scale*tmp) v7 = y goto _8 _8: @@ -110746,10 +110746,10 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ - return y1 * y1 + return float64(y1 * y1) } if _zeroinfnan(tls, ix) != 0 { - x2 = x1 * x1 + x2 = Tdouble_t(x1 * x1) if ix>>int32(63) != 0 && _checkint(tls, iy) == int32(1) { x2 = -x2 } @@ -110809,15 +110809,15 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = x1 * float64(4.503599627370496e+15) + v15 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) ix &= uint64(0x7fffffffffffffff) ix = Tuint64_t(ix - Uint64FromUint64(52)<<Int32FromInt32(52)) } } hi = _log_inline(tls, ix, bp) - ehi = y1 * hi - elo = y1**(*Tdouble_t)(unsafe.Pointer(bp)) + float64(X__builtin_fma(tls, y1, hi, -ehi)) + ehi = Tdouble_t(y1 * hi) + elo = float64(y1**(*Tdouble_t)(unsafe.Pointer(bp))) + float64(X__builtin_fma(tls, y1, hi, -ehi)) return _exp_inline(tls, ehi, elo, sign_bias) } @@ -110878,16 +110878,16 @@ func _log2_inline(tls *TLS, ix Tuint32_t) (r1 Tdouble_t) { })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ - r = z*invc - Float64FromInt32(1) + r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ - r2 = r * r - y = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) - r4 = r2 * r2 - q = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r + y0 - q = p*r2 + q - y = y*r4 + q + r2 = Tdouble_t(r * r) + y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + r4 = Tdouble_t(r2 * r2) + q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = Tdouble_t(p*r2) + q + y = Tdouble_t(y*r4) + q return y } @@ -110917,11 +110917,11 @@ _2: ski = ki + uint64(sign_bias) t += ski << (Int32FromInt32(52) - Int32FromInt32(EXP2F_TABLE_BITS)) s = *(*float64)(unsafe.Pointer(&t)) - z = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) - r2 = r * r - y2 = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r + Float64FromInt32(1) - y2 = z*r2 + y2 - y2 = y2 * s + z = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 1*8)) + r2 = Tdouble_t(r * r) + y2 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + 264 + 2*8))*r) + Float64FromInt32(1) + y2 = Tdouble_t(z*r2) + y2 + y2 = Tdouble_t(y2 * s) y = float32(y2) v4 = y goto _5 @@ -110989,10 +110989,10 @@ func Xpowf(tls *TLS, x1 float32, y1 float32) (r float32) { if BoolInt32(uint32(2)*ix < Uint32FromInt32(Int32FromInt32(2)*Int32FromInt32(0x3f800000))) == BoolInt32(!(iy&Uint32FromUint32(0x80000000) != 0)) { return Float32FromFloat32(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ - return y1 * y1 + return float32(y1 * y1) } if _zeroinfnan1(tls, ix) != 0 { - x2 = x1 * x1 + x2 = Tfloat_t(x1 * x1) if ix&uint32(0x80000000) != 0 && _checkint1(tls, iy) == int32(1) { x2 = -x2 } @@ -111023,22 +111023,22 @@ func Xpowf(tls *TLS, x1 float32, y1 float32) (r float32) { } if ix < uint32(0x00800000) { /* Normalize subnormal x so exponent becomes negative. */ - v4 = x1 * Float32FromFloat32(8.388608e+06) + v4 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v4)) ix &= uint32(0x7fffffff) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } } logx = _log2_inline(tls, ix) - ylogx = float64(y1) * logx /* cannot overflow, y is single prec. */ + ylogx = Tdouble_t(float64(y1) * logx) /* cannot overflow, y is single prec. */ v5 = ylogx - v6 = float64(126) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)) + v6 = float64(float64(126) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))) if *(*Tuint64_t)(unsafe.Pointer(&v5))>>int32(47)&uint64(0xffff) >= *(*Tuint64_t)(unsafe.Pointer(&v6))>>int32(47) { /* |y*log(x)| >= 126. */ - if ylogx > float64(127.99999995700433)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)) { + if ylogx > Tdouble_t(float64(127.99999995700433)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))) { return X__math_oflowf(tls, sign_bias) } - if ylogx <= -Float64FromFloat64(150)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)) { + if ylogx <= Tdouble_t(-Float64FromFloat64(150)*float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))) { return X__math_uflowf(tls, sign_bias) } } @@ -111163,7 +111163,7 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { _2: } if v3 || BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 || ex == int32(0x7ff) { - return x * y / (x * y) + return float64(x*y) / float64(x*y) } if *(*Tuint64_t)(unsafe.Pointer(bp + 8))<<int32(1) == uint64(0) { return x @@ -111263,7 +111263,7 @@ end: if sy != 0 { y = -y } - if ex == ey || ex+int32(1) == ey && (Float64FromInt32(2)*x > y || Float64FromInt32(2)*x == y && q%uint32(2) != 0) { + if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { x -= y q++ } @@ -111336,7 +111336,7 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { _2: } if v3 || BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 || ex == int32(0xff) { - return x * y / (x * y) + return float32(x*y) / float32(x*y) } if *(*Tuint32_t)(unsafe.Pointer(bp + 4))<<int32(1) == uint32(0) { return x @@ -111434,7 +111434,7 @@ end: if sy != 0 { y = -y } - if ex == ey || ex+int32(1) == ey && (Float32FromInt32(2)*x > y || Float32FromInt32(2)*x == y && q%uint32(2) != 0) { + if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { x -= y q++ } @@ -111614,7 +111614,7 @@ func Xround(tls *TLS, x3 float64) (r float64) { y2 = float64(x3 + _toint6) } } - return Float64FromInt32(0) * *(*float64)(unsafe.Pointer(bp)) + return float64(Float64FromInt32(0) * *(*float64)(unsafe.Pointer(bp))) } y3 = x3 + _toint6 - _toint6 - x3 if y3 > float64(0.5) { @@ -111678,7 +111678,7 @@ func Xroundf(tls *TLS, x3 float32) (r float32) { y2 = float64(x3 + _toint7) } } - return Float32FromInt32(0) * *(*float32)(unsafe.Pointer(bp)) + return float32(Float32FromInt32(0) * *(*float32)(unsafe.Pointer(bp))) } y3 = x3 + _toint7 - _toint7 - x3 if y3 > Float32FromFloat32(0.5) { @@ -111732,7 +111732,7 @@ _2: _4: } if v5 || BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 { - return x * fn + return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn v6 = *(*uint64)(unsafe.Pointer(bp)) @@ -111740,7 +111740,7 @@ _2: _7: if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0) { if fn > float64(0) { - return x * fn + return float64(x * fn) } else { return x / -fn } @@ -111783,7 +111783,7 @@ _2: _4: } if v5 || BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { - return x * fn + return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn v6 = *(*uint32)(unsafe.Pointer(bp)) @@ -111791,7 +111791,7 @@ _2: _7: if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { - return x * fn + return float32(x * fn) } else { return x / -fn } @@ -111874,10 +111874,10 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15) + y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) n += Int32FromInt32(1022) - Int32FromInt32(53) if n < -int32(1022) { - y *= Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15) + y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) n += Int32FromInt32(1022) - Int32FromInt32(53) if n < -int32(1022) { n = -int32(1022) @@ -111886,7 +111886,7 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { } } *(*Tuint64_t)(unsafe.Pointer(bp)) = Uint64FromInt32(Int32FromInt32(0x3ff)+n) << int32(52) - x = y * *(*float64)(unsafe.Pointer(bp)) + x = float64(y * *(*float64)(unsafe.Pointer(bp))) return x } @@ -111916,10 +111916,10 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { } } else { if n < -int32(126) { - y *= Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07) + y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) n += Int32FromInt32(126) - Int32FromInt32(24) if n < -int32(126) { - y *= Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07) + y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) n += Int32FromInt32(126) - Int32FromInt32(24) if n < -int32(126) { n = -int32(126) @@ -111928,7 +111928,7 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { } } *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32(Int32FromInt32(0x7f)+n) << int32(23) - x = y * *(*float32)(unsafe.Pointer(bp)) + x = float32(y * *(*float32)(unsafe.Pointer(bp))) return x } @@ -112110,10 +112110,10 @@ const M_PI_25 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _s1pio2 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _s2pio2 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _s3pio2 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _s4pio2 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _s1pio2 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _s2pio2 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _s3pio2 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _s4pio2 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { if __ccgo_strace { @@ -112272,10 +112272,10 @@ const M_PI_27 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _s1pio21 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _s2pio21 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _s3pio21 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _s4pio21 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _s1pio21 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _s2pio21 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _s3pio21 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _s4pio21 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xsinf(tls *TLS, x3 float32) (r float32) { if __ccgo_strace { @@ -112420,14 +112420,14 @@ func Xsinh(tls *TLS, x float64) (r float64) { /* note: this branch avoids spurious underflow */ return x } - return h * (Float64FromInt32(2)*t - t*t/(t+Float64FromInt32(1))) + return float64(h * (float64(Float64FromInt32(2)*t) - float64(t*t)/(t+Float64FromInt32(1)))) } /* note: |x|>log(0x1p26)+eps could be just h*exp(x) */ - return h * (t + t/(t+Float64FromInt32(1))) + return float64(h * (t + t/(t+Float64FromInt32(1)))) } /* |x| > log(DBL_MAX) or nan */ /* note: the result is stored to handle overflow */ - t = X__expo2(tls, absx, Float64FromInt32(2)*h) + t = X__expo2(tls, absx, float64(Float64FromInt32(2)*h)) return t } @@ -112468,12 +112468,12 @@ func Xsinhf(tls *TLS, x float32) (r float32) { if w < Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(12)<<Int32FromInt32(23)) { return x } - return h * (Float32FromInt32(2)*t - t*t/(t+Float32FromInt32(1))) + return float32(h * (float32(Float32FromInt32(2)*t) - float32(t*t)/(t+Float32FromInt32(1)))) } - return h * (t + t/(t+Float32FromInt32(1))) + return float32(h * (t + t/(t+Float32FromInt32(1)))) } /* |x| > logf(FLT_MAX) or nan */ - t = X__expo2f(tls, absx, Float32FromInt32(2)*h) + t = X__expo2f(tls, absx, float32(Float32FromInt32(2)*h)) return t } @@ -112540,7 +112540,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * float64(4.503599627370496e+15) + v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) top -= uint64(52) @@ -112690,7 +112690,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { return X__math_invalidf(tls, x1) } /* x is subnormal, normalize it. */ - v1 = x1 * Float32FromFloat32(8.388608e+06) + v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) } @@ -112823,10 +112823,10 @@ const M_PI_29 = 1.5707963267948966 // // /* Small multiples of pi/2 rounded to double precision. */ -var _t1pio2 = Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966) /* 0x3FF921FB, 0x54442D18 */ -var _t2pio2 = Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966) /* 0x400921FB, 0x54442D18 */ -var _t3pio2 = Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966) /* 0x4012D97C, 0x7F3321D2 */ -var _t4pio2 = Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966) /* 0x401921FB, 0x54442D18 */ +var _t1pio2 = float64(Float64FromInt32(1) * Float64FromFloat64(1.5707963267948966)) /* 0x3FF921FB, 0x54442D18 */ +var _t2pio2 = float64(Float64FromInt32(2) * Float64FromFloat64(1.5707963267948966)) /* 0x400921FB, 0x54442D18 */ +var _t3pio2 = float64(Float64FromInt32(3) * Float64FromFloat64(1.5707963267948966)) /* 0x4012D97C, 0x7F3321D2 */ +var _t4pio2 = float64(Float64FromInt32(4) * Float64FromFloat64(1.5707963267948966)) /* 0x401921FB, 0x54442D18 */ func Xtanf(tls *TLS, x3 float32) (r float32) { if __ccgo_strace { @@ -112963,18 +112963,18 @@ func Xtanh(tls *TLS, x3 float64) (r float64) { /* note: this branch avoids raising overflow */ t = Float64FromInt32(1) - Float64FromInt32(0)/x3 } else { - t = Xexpm1(tls, Float64FromInt32(2)*x3) + t = Xexpm1(tls, float64(Float64FromInt32(2)*x3)) t = Float64FromInt32(1) - Float64FromInt32(2)/(t+Float64FromInt32(2)) } } else { if w > uint32(0x3fd058ae) { /* |x| > log(5/3)/2 ~= 0.2554 */ - t = Xexpm1(tls, Float64FromInt32(2)*x3) + t = Xexpm1(tls, float64(Float64FromInt32(2)*x3)) t = t / (t + Float64FromInt32(2)) } else { if w >= uint32(0x00100000) { /* |x| >= 0x1p-1022, up to 2ulp error in [0.1,0.2554] */ - t = Xexpm1(tls, float64(-Int32FromInt32(2))*x3) + t = Xexpm1(tls, float64(float64(-Int32FromInt32(2))*x3)) t = -t / (t + Float64FromInt32(2)) } else { /* |x| is subnormal */ @@ -113035,23 +113035,23 @@ func Xtanhf(tls *TLS, x3 float32) (r float32) { /* |x| > 10 */ t = Float32FromInt32(1) + Float32FromInt32(0)/x3 } else { - t = Xexpm1f(tls, Float32FromInt32(2)*x3) + t = Xexpm1f(tls, float32(Float32FromInt32(2)*x3)) t = Float32FromInt32(1) - Float32FromInt32(2)/(t+Float32FromInt32(2)) } } else { if w > uint32(0x3e82c578) { /* |x| > log(5/3)/2 ~= 0.2554 */ - t = Xexpm1f(tls, Float32FromInt32(2)*x3) + t = Xexpm1f(tls, float32(Float32FromInt32(2)*x3)) t = t / (t + Float32FromInt32(2)) } else { if w >= uint32(0x00800000) { /* |x| >= 0x1p-126 */ - t = Xexpm1f(tls, float32(-Int32FromInt32(2))*x3) + t = Xexpm1f(tls, float32(float32(-Int32FromInt32(2))*x3)) t = -t / (t + Float32FromInt32(2)) } else { /* |x| is subnormal */ if uint64(4) == uint64(4) { - y = x3 * x3 + y = float32(x3 * x3) } else { if uint64(4) == uint64(8) { y1 = float64(x3 * x3) @@ -113099,12 +113099,12 @@ func _sinpi(tls *TLS, x float64) (r float64) { _ = n /* argument reduction: x = |x| mod 2 */ /* spurious inexact when x is odd int */ - x = x * float64(0.5) - x = Float64FromInt32(2) * (x - Xfloor(tls, x)) + x = float64(x * float64(0.5)) + x = float64(Float64FromInt32(2) * (x - Xfloor(tls, x))) /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(n) * float64(0.5) + x -= float64(float64(n) * float64(0.5)) x *= _pi4 switch n { default: /* case 4 */ @@ -113200,8 +113200,8 @@ func _S(tls *TLS, x float64) (r float64) { if !(i >= 0) { break } - num = num*x + _Snum[i] - den = den*x + _Sden[i] + num = Tdouble_t(num*x) + _Snum[i] + den = Tdouble_t(den*x) + _Sden[i] goto _1 _1: ; @@ -113283,7 +113283,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y2 = float64(float32(Float64FromFloat64(1.1754943508222875e-38) / x3)) } } - if Xfloor(tls, x3)*float64(0.5) == Xfloor(tls, x3*float64(0.5)) { + if float64(Xfloor(tls, x3)*float64(0.5)) == Xfloor(tls, float64(x3*float64(0.5))) { return Float64FromInt32(0) } return -Float64FromFloat64(0) @@ -113307,17 +113307,17 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy -= absx } z = absx - float64(0.5) - r = _S(tls, absx) * Xexp(tls, -y3) + r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) if x3 < Float64FromInt32(0) { /* reflection formula for negative x */ /* sinpi(absx) is not 0, integers are already handled */ - r = -_pi4 / (_sinpi(tls, absx) * absx * r) + r = -_pi4 / float64(float64(_sinpi(tls, absx)*absx)*r) dy = -dy z = -z } - r += dy * (_gmhalf + Float64FromFloat64(0.5)) * r / y3 - z = Xpow(tls, y3, float64(0.5)*z) - y3 = r * z * z + r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + z = Xpow(tls, y3, float64(float64(0.5)*z)) + y3 = float64(Tdouble_t(r*z) * z) return y3 } @@ -140285,7 +140285,7 @@ _4: } return v7 } - y = Xfrexpl(tls, y, bp+512) * Float64FromInt32(2) + y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { *(*int32)(unsafe.Pointer(bp + 512))-- } @@ -140348,7 +140348,7 @@ _4: v14 = s s++ *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) - y = Float64FromInt32(16) * (y - float64(x)) + y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v15 = s s++ @@ -140401,7 +140401,7 @@ _4: *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) v21 = z z += 4 - y = Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21)))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) @@ -151797,7 +151797,7 @@ var X__exp2f_data = Texp2f_data{ 2: float64(0.6931471806916203), }, Fshift: float64(6.755399441055744e+15), - Finvln2_scaled: Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)), + Finvln2_scaled: float64(Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS))), Fpoly_scaled: [3]float64{ 0: Float64FromFloat64(0.05550361559341535) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)), 1: Float64FromFloat64(0.2402284522445722) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)) / float64(Int32FromInt32(1)<<Int32FromInt32(EXP2F_TABLE_BITS)), @@ -151806,7 +151806,7 @@ var X__exp2f_data = Texp2f_data{ } var X__exp_data = Texp_data{ - Finvln2N: Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP_TABLE_BITS)), + Finvln2N: float64(Float64FromFloat64(1.4426950408889634) * float64(Int32FromInt32(1)<<Int32FromInt32(EXP_TABLE_BITS))), Fshift: float64(6.755399441055744e+15), Fnegln2hiN: -Float64FromFloat64(0.005415212348111709), Fnegln2loN: -Float64FromFloat64(1.2864023111638346e-14), @@ -153140,12 +153140,12 @@ var X__pow_log_data = Tpow_log_data{ Fln2lo: float64(5.497923018708371e-14), Fpoly: [7]float64{ 0: -Float64FromFloat64(0.5), - 1: Float64FromFloat64(0.3333333333333339) * float64(-Int32FromInt32(2)), - 2: -Float64FromFloat64(0.25000000000000033) * float64(-Int32FromInt32(2)), - 3: Float64FromFloat64(0.1999999998830994) * Float64FromInt32(4), - 4: -Float64FromFloat64(0.16666666658719348) * Float64FromInt32(4), - 5: Float64FromFloat64(0.14286370355743763) * float64(-Int32FromInt32(8)), - 6: -Float64FromFloat64(0.12500519079594427) * float64(-Int32FromInt32(8)), + 1: float64(Float64FromFloat64(0.3333333333333339) * float64(-Int32FromInt32(2))), + 2: float64(-Float64FromFloat64(0.25000000000000033) * float64(-Int32FromInt32(2))), + 3: float64(Float64FromFloat64(0.1999999998830994) * Float64FromInt32(4)), + 4: float64(-Float64FromFloat64(0.16666666658719348) * Float64FromInt32(4)), + 5: float64(Float64FromFloat64(0.14286370355743763) * float64(-Int32FromInt32(8))), + 6: float64(-Float64FromFloat64(0.12500519079594427) * float64(-Int32FromInt32(8))), }, Ftab: [128]struct { Finvc float64 @@ -153799,75 +153799,75 @@ var X__powf_log2_data = Tpowf_log2_data{ }{ 0: { Finvc: float64(1.398907162146528), - Flogc: -Float64FromFloat64(0.48430022186289673) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.48430022186289673) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 1: { Finvc: float64(1.3403141896637998), - Flogc: -Float64FromFloat64(0.42257122959194704) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.42257122959194704) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 2: { Finvc: float64(1.286432210124115), - Flogc: -Float64FromFloat64(0.3633754347673556) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.3633754347673556) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 3: { Finvc: float64(1.2367150214269895), - Flogc: -Float64FromFloat64(0.30651309567405577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.30651309567405577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 4: { Finvc: float64(1.1906977166711752), - Flogc: -Float64FromFloat64(0.25180720160537634) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.25180720160537634) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 5: { Finvc: float64(1.1479821020556429), - Flogc: -Float64FromFloat64(0.19910014943794563) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.19910014943794563) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 6: { Finvc: float64(1.1082251448272158), - Flogc: -Float64FromFloat64(0.14825100623281615) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.14825100623281615) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 7: { Finvc: float64(1.0711297413057381), - Flogc: -Float64FromFloat64(0.09913323807318392) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.09913323807318392) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 8: { Finvc: float64(1.036437278977283), - Flogc: -Float64FromFloat64(0.051632812977629436) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(-Float64FromFloat64(0.051632812977629436) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 9: { Finvc: float64(1), - Flogc: float64(0) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 10: { Finvc: float64(0.9492859795739057), - Flogc: float64(0.07508531937943004) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.07508531937943004) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 11: { Finvc: float64(0.8951049428609004), - Flogc: float64(0.15987125980713107) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.15987125980713107) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 12: { Finvc: float64(0.8476821620351103), - Flogc: float64(0.2384046664317681) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.2384046664317681) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 13: { Finvc: float64(0.8050314851692001), - Flogc: float64(0.31288288605863257) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.31288288605863257) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 14: { Finvc: float64(0.7664671008843108), - Flogc: float64(0.38370422656453185) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.38370422656453185) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, 15: { Finvc: float64(0.731428603316328), - Flogc: float64(0.451211048935815) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + Flogc: float64(float64(0.451211048935815) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, }, Fpoly: [5]float64{ - 0: float64(0.288457581109214) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 1: -Float64FromFloat64(0.36092606229713164) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 2: float64(0.480898481472577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 3: -Float64FromFloat64(0.7213474675006291) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), - 4: float64(1.4426950408774342) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS)), + 0: float64(float64(0.288457581109214) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 1: float64(-Float64FromFloat64(0.36092606229713164) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 2: float64(float64(0.480898481472577) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 3: float64(-Float64FromFloat64(0.7213474675006291) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), + 4: float64(float64(1.4426950408774342) * float64(Int32FromInt32(1)<<Int32FromInt32(POWF_SCALE_BITS))), }, } |