summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/lib/math/asin.go18
-rw-r--r--src/lib/math/atan.go31
-rw-r--r--src/lib/math/atan2.go10
-rw-r--r--src/lib/math/exp.go21
-rw-r--r--src/lib/math/fabs.go6
-rw-r--r--src/lib/math/floor.go19
-rw-r--r--src/lib/math/fmod.go17
-rw-r--r--src/lib/math/hypot.go16
-rw-r--r--src/lib/math/log.go26
-rw-r--r--src/lib/math/pow.go29
-rw-r--r--src/lib/math/pow10.go12
-rw-r--r--src/lib/math/sin.go35
-rw-r--r--src/lib/math/sinh.go26
-rw-r--r--src/lib/math/sqrt.go13
-rw-r--r--src/lib/math/tan.go23
-rw-r--r--src/lib/math/tanh.go10
-rw-r--r--src/lib/math/test.go273
17 files changed, 385 insertions, 200 deletions
diff --git a/src/lib/math/asin.go b/src/lib/math/asin.go
index a4a7e67ca..91875d35f 100644
--- a/src/lib/math/asin.go
+++ b/src/lib/math/asin.go
@@ -4,7 +4,7 @@
package math
-import math "math"
+import "math"
/*
* asin(arg) and acos(arg) return the arcsin, arccos,
@@ -18,9 +18,7 @@ const
pio2 = .15707963267948966192313216e1
)
-export func
-asin(arg float64)float64
-{
+export func Asin(arg float64) float64 {
var temp, x float64;
var sign bool;
@@ -34,11 +32,11 @@ asin(arg float64)float64
return sys.NaN();
}
- temp = sqrt(1 - x*x);
+ temp = Sqrt(1 - x*x);
if x > 0.7 {
- temp = pio2 - atan(temp/x);
+ temp = pio2 - Atan(temp/x);
} else {
- temp = atan(x/temp);
+ temp = Atan(x/temp);
}
if sign {
@@ -47,11 +45,9 @@ asin(arg float64)float64
return temp;
}
-export func
-acos(arg float64)float64
-{
+export func Acos(arg float64) float64 {
if(arg > 1 || arg < -1) {
return sys.NaN();
}
- return pio2 - asin(arg);
+ return pio2 - Asin(arg);
}
diff --git a/src/lib/math/atan.go b/src/lib/math/atan.go
index aa4c29234..43990fe40 100644
--- a/src/lib/math/atan.go
+++ b/src/lib/math/atan.go
@@ -13,7 +13,6 @@ package math
* coefficients are #5077 from Hart & Cheney. (19.56D)
*/
-
const
(
p4 = .161536412982230228262e2;
@@ -36,13 +35,9 @@ const
* xatan evaluates a series valid in the
* range [-0.414...,+0.414...]. (tan(pi/8))
*/
-func
-xatan(arg float64) float64
-{
- var argsq, value float64;
-
- argsq = arg*arg;
- value = ((((p4*argsq + p3)*argsq + p2)*argsq + p1)*argsq + p0);
+func Xatan(arg float64) float64 {
+ argsq := arg*arg;
+ value := ((((p4*argsq + p3)*argsq + p2)*argsq + p1)*argsq + p0);
value = value/(((((argsq + q4)*argsq + q3)*argsq + q2)*argsq + q1)*argsq + q0);
return value*arg;
}
@@ -51,29 +46,23 @@ xatan(arg float64) float64
* satan reduces its argument (known to be positive)
* to the range [0,0.414...] and calls xatan.
*/
-func
-satan(arg float64) float64
-{
-
+func Satan(arg float64) float64 {
if arg < sq2m1 {
- return xatan(arg);
+ return Xatan(arg);
}
if arg > sq2p1 {
- return pio2 - xatan(1/arg);
+ return pio2 - Xatan(1/arg);
}
- return pio4 + xatan((arg-1)/(arg+1));
+ return pio4 + Xatan((arg-1)/(arg+1));
}
/*
* atan makes its argument positive and
* calls the inner routine satan.
*/
-export func
-atan(arg float64) float64
-{
-
+export func Atan(arg float64) float64 {
if arg > 0 {
- return satan(arg);
+ return Satan(arg);
}
- return -satan(-arg);
+ return -Satan(-arg);
}
diff --git a/src/lib/math/atan2.go b/src/lib/math/atan2.go
index 64bf21a9e..f0b384258 100644
--- a/src/lib/math/atan2.go
+++ b/src/lib/math/atan2.go
@@ -4,7 +4,7 @@
package math
-import math "math"
+import "math"
/*
* atan2 discovers what quadrant the angle
@@ -17,18 +17,14 @@ const
pi = .3141592653589793238462643383276e1;
)
-export func
-atan2(arg1, arg2 float64) float64
-{
- var x float64;
-
+export func Atan2(arg1, arg2 float64) float64 {
if arg1+arg2 == arg1 {
if arg1 >= 0 {
return pio2;
}
return -pio2;
}
- x = atan(arg1/arg2);
+ x := Atan(arg1/arg2);
if arg2 < 0 {
if x <= 0 {
return x + pi;
diff --git a/src/lib/math/exp.go b/src/lib/math/exp.go
index 243460b2b..9bc26d2b6 100644
--- a/src/lib/math/exp.go
+++ b/src/lib/math/exp.go
@@ -4,7 +4,7 @@
package math
-import math "math"
+import "math"
/*
* exp returns the exponential func of its
@@ -26,12 +26,7 @@ const
maxf = 10000;
)
-export func
-exp(arg float64) float64
-{
- var x, fract, temp1, temp2, xsq float64;
- var ent int;
-
+export func Exp(arg float64) float64 {
if arg == 0. {
return 1;
}
@@ -42,11 +37,11 @@ exp(arg float64) float64
return sys.Inf(1)
}
- x = arg*log2e;
- ent = int(floor(x));
- fract = (x-float64(ent)) - 0.5;
- xsq = fract*fract;
- temp1 = ((p2*xsq+p1)*xsq+p0)*fract;
- temp2 = ((xsq+q2)*xsq+q1)*xsq + q0;
+ x := arg*log2e;
+ ent := int(Floor(x));
+ fract := (x-float64(ent)) - 0.5;
+ xsq := fract*fract;
+ temp1 := ((p2*xsq+p1)*xsq+p0)*fract;
+ temp2 := ((xsq+q2)*xsq+q1)*xsq + q0;
return sys.ldexp(sqrt2*(temp2+temp1)/(temp2-temp1), ent);
}
diff --git a/src/lib/math/fabs.go b/src/lib/math/fabs.go
index c0baa8956..7117db0b7 100644
--- a/src/lib/math/fabs.go
+++ b/src/lib/math/fabs.go
@@ -4,12 +4,10 @@
package math
-export func
-fabs(arg float64) float64
-{
-
+export func Fabs(arg float64) float64 {
if arg < 0 {
return -arg;
}
return arg;
}
+
diff --git a/src/lib/math/floor.go b/src/lib/math/floor.go
index 1ca0d05ad..421c29299 100644
--- a/src/lib/math/floor.go
+++ b/src/lib/math/floor.go
@@ -9,25 +9,18 @@ package math
* (resp least >=)
*/
-export func
-floor(arg float64) float64
-{
- var fract, d float64;
-
- d = arg;
- if d < 0 {
- d,fract = sys.modf(-d);
+export func Floor(arg float64) float64 {
+ if arg < 0 {
+ d, fract := sys.modf(-arg);
if fract != 0.0 {
d = d+1;
}
return -d;
}
- d,fract = sys.modf(d);
+ d, fract := sys.modf(arg);
return d;
}
-export func
-ceil(arg float64) float64
-{
- return -floor(-arg);
+export func Ceil(arg float64) float64 {
+ return -Floor(-arg);
}
diff --git a/src/lib/math/fmod.go b/src/lib/math/fmod.go
index 11ede447d..488ee4321 100644
--- a/src/lib/math/fmod.go
+++ b/src/lib/math/fmod.go
@@ -8,13 +8,7 @@ package math
* floating-point mod func without infinity or NaN checking
*/
-export func
-fmod(x, y float64) float64
-{
- var yexp, rexp int;
- var r, yfr, rfr float64;
- var sign bool;
-
+export func Fmod(x, y float64) float64 {
if y == 0 {
return x;
}
@@ -22,17 +16,16 @@ fmod(x, y float64) float64
y = -y;
}
- yfr,yexp = sys.frexp(y);
- sign = false;
+ yfr, yexp := sys.frexp(y);
+ sign := false;
+ r := x;
if x < 0 {
r = -x;
sign = true;
- } else {
- r = x;
}
for r >= y {
- rfr,rexp = sys.frexp(r);
+ rfr, rexp := sys.frexp(r);
if rfr < yfr {
rexp = rexp - 1;
}
diff --git a/src/lib/math/hypot.go b/src/lib/math/hypot.go
index d1afac9e3..6295c124a 100644
--- a/src/lib/math/hypot.go
+++ b/src/lib/math/hypot.go
@@ -12,11 +12,7 @@ package math
* Vol. 27, Number 6, pp. 577-581, Nov. 1983
*/
-export func
-hypot(p, q float64) float64
-{
- var r, s, pfac float64;
-
+export func Hypot(p, q float64) float64 {
if p < 0 {
p = -p;
}
@@ -25,22 +21,20 @@ hypot(p, q float64) float64
}
if p < q {
- r = p;
- p = q;
- q = r;
+ p, q = q, p;
}
if p == 0 {
return 0;
}
- pfac = p;
+ pfac := p;
q = q/p;
- r = q;
+ r := q;
p = 1;
for {
r = r*r;
- s = r+4;
+ s := r+4;
if s == 4 {
return p*pfac;
}
diff --git a/src/lib/math/log.go b/src/lib/math/log.go
index 5cd73bf89..e51c72980 100644
--- a/src/lib/math/log.go
+++ b/src/lib/math/log.go
@@ -5,7 +5,7 @@
package math
/*
- * log returns the natural logarithm of its floating
+ * Log returns the natural logarithm of its floating
* point argument.
*
* The coefficients are #2705 from Hart & Cheney. (19.38D)
@@ -16,7 +16,7 @@ package math
const
(
log2 = .693147180559945309e0;
- ln10o1 = .4342944819032518276511;
+ ln10u1 = .4342944819032518276511;
sqrto2 = .707106781186547524e0;
p0 = -.240139179559210510e2;
p1 = .309572928215376501e2;
@@ -27,17 +27,12 @@ const
q2 = -.891110902798312337e1;
)
-export func
-log(arg float64) float64
-{
- var x, z, zsq, temp float64;
- var exp int;
-
+export func Log(arg float64) float64 {
if arg <= 0 {
return sys.NaN();
}
- x,exp = sys.frexp(arg);
+ x, exp := sys.frexp(arg);
for x < 0.5 {
x = x*2;
exp = exp-1;
@@ -47,21 +42,18 @@ log(arg float64) float64
exp = exp-1;
}
- z = (x-1) / (x+1);
- zsq = z*z;
+ z := (x-1) / (x+1);
+ zsq := z*z;
- temp = ((p3*zsq + p2)*zsq + p1)*zsq + p0;
+ temp := ((p3*zsq + p2)*zsq + p1)*zsq + p0;
temp = temp/(((zsq + q2)*zsq + q1)*zsq + q0);
temp = temp*z + float64(exp)*log2;
return temp;
}
-export func
-log10(arg float64) float64
-{
-
+export func Log10(arg float64) float64 {
if arg <= 0 {
return sys.NaN();
}
- return log(arg) * ln10o1;
+ return Log(arg) * ln10u1;
}
diff --git a/src/lib/math/pow.go b/src/lib/math/pow.go
index 2a6b19023..9e63db74b 100644
--- a/src/lib/math/pow.go
+++ b/src/lib/math/pow.go
@@ -4,20 +4,15 @@
package math
-import math "math"
+import "math"
/*
arg1 ^ arg2 (exponentiation)
*/
-export func
-pow(arg1,arg2 float64) float64
-{
- var temp float64;
- var l int32;
-
+export func Pow(arg1,arg2 float64) float64 {
if arg2 < 0 {
- return 1/pow(arg1, -arg2);
+ return 1/Pow(arg1, -arg2);
}
if arg1 <= 0 {
if(arg1 == 0) {
@@ -27,30 +22,30 @@ pow(arg1,arg2 float64) float64
return 0;
}
- temp = floor(arg2);
+ temp := Floor(arg2);
if temp != arg2 {
panic(sys.NaN());
}
- l = int32(temp);
+ l := int32(temp);
if l&1 != 0 {
- return -pow(-arg1, arg2);
+ return -Pow(-arg1, arg2);
}
- return pow(-arg1, arg2);
+ return Pow(-arg1, arg2);
}
- temp = floor(arg2);
+ temp := Floor(arg2);
if temp != arg2 {
if arg2-temp == .5 {
if temp == 0 {
- return sqrt(arg1);
+ return Sqrt(arg1);
}
- return pow(arg1, temp) * sqrt(arg1);
+ return Pow(arg1, temp) * Sqrt(arg1);
}
- return exp(arg2 * log(arg1));
+ return Exp(arg2 * Log(arg1));
}
- l = int32(temp);
+ l := int32(temp);
temp = 1;
for {
if l&1 != 0 {
diff --git a/src/lib/math/pow10.go b/src/lib/math/pow10.go
index 6c02655db..e1e9c2e05 100644
--- a/src/lib/math/pow10.go
+++ b/src/lib/math/pow10.go
@@ -16,22 +16,18 @@ package math
const tabsize = 70;
var tab[tabsize] float64;
-export func
-pow10(e int) float64
-{
+export func Pow10(e int) float64 {
if e < 0 {
- return 1/pow10(-e);
+ return 1/Pow10(-e);
}
if e < tabsize {
return tab[e];
}
m := e/2;
- return pow10(m) * pow10(e-m);
+ return Pow10(m) * Pow10(e-m);
}
-func
-init()
-{
+func init() {
tab[0] = 1.0e0;
tab[1] = 1.0e1;
for i:=2; i<tabsize; i++ {
diff --git a/src/lib/math/sin.go b/src/lib/math/sin.go
index cc8e39fbc..635e60d21 100644
--- a/src/lib/math/sin.go
+++ b/src/lib/math/sin.go
@@ -18,25 +18,22 @@ const
piu2 = .6366197723675813430755350e0; // 2/pi
)
-func
-sinus(arg float64, quad int) float64
-{
- var e, f, ysq, x, y, temp1, temp2 float64;
- var k int32;
-
- x = arg;
+func Sinus(arg float64, quad int) float64 {
+ x := arg;
if(x < 0) {
x = -x;
quad = quad+2;
}
x = x * piu2; /* underflow? */
+ var y float64;
if x > 32764 {
- e,y = sys.modf(x);
+ var e float64;
+ e, y = sys.modf(x);
e = e + float64(quad);
- temp1,f = sys.modf(0.25*e);
+ temp1, f := sys.modf(0.25*e);
quad = int(e - 4*f);
} else {
- k = int32(x);
+ k := int32(x);
y = x - float64(k);
quad = (quad + int(k)) & 3;
}
@@ -48,23 +45,19 @@ sinus(arg float64, quad int) float64
y = -y;
}
- ysq = y*y;
- temp1 = ((((p4*ysq+p3)*ysq+p2)*ysq+p1)*ysq+p0)*y;
- temp2 = ((((ysq+q3)*ysq+q2)*ysq+q1)*ysq+q0);
+ ysq := y*y;
+ temp1 := ((((p4*ysq+p3)*ysq+p2)*ysq+p1)*ysq+p0)*y;
+ temp2 := ((((ysq+q3)*ysq+q2)*ysq+q1)*ysq+q0);
return temp1/temp2;
}
-export func
-cos(arg float64) float64
-{
+export func Cos(arg float64) float64 {
if arg < 0 {
arg = -arg;
}
- return sinus(arg, 1);
+ return Sinus(arg, 1);
}
-export func
-sin(arg float64) float64
-{
- return sinus(arg, 0);
+export func Sin(arg float64) float64 {
+ return Sinus(arg, 0);
}
diff --git a/src/lib/math/sinh.go b/src/lib/math/sinh.go
index a3684c46a..e1fde0ac2 100644
--- a/src/lib/math/sinh.go
+++ b/src/lib/math/sinh.go
@@ -4,7 +4,7 @@
package math
-import math "math"
+import "math"
/*
* sinh(arg) returns the hyperbolic sine of its floating-
@@ -31,27 +31,23 @@ const
q2 = -0.173678953558233699533450911e+3;
)
-export func
-sinh(arg float64) float64
-{
- var temp, argsq float64;
- var sign bool;
-
- sign = false;
+export func Sinh(arg float64) float64 {
+ sign := false;
if arg < 0 {
arg = -arg;
sign = true;
}
+ var temp float64;
switch true {
case arg > 21:
- temp = exp(arg)/2;
+ temp = Exp(arg)/2;
case arg > 0.5:
- temp = (exp(arg) - exp(-arg))/2;
+ temp = (Exp(arg) - Exp(-arg))/2;
default:
- argsq = arg*arg;
+ argsq := arg*arg;
temp = (((p3*argsq+p2)*argsq+p1)*argsq+p0)*arg;
temp = temp/(((argsq+q2)*argsq+q1)*argsq+q0);
}
@@ -62,14 +58,12 @@ sinh(arg float64) float64
return temp;
}
-export func
-cosh(arg float64) float64
-{
+export func Cosh(arg float64) float64 {
if arg < 0 {
arg = - arg;
}
if arg > 21 {
- return exp(arg)/2;
+ return Exp(arg)/2;
}
- return (exp(arg) + exp(-arg))/2;
+ return (Exp(arg) + Exp(-arg))/2;
}
diff --git a/src/lib/math/sqrt.go b/src/lib/math/sqrt.go
index 76b499e88..6459b31ac 100644
--- a/src/lib/math/sqrt.go
+++ b/src/lib/math/sqrt.go
@@ -11,12 +11,7 @@ package math
* calls frexp
*/
-export func
-sqrt(arg float64) float64
-{
- var x, temp float64;
- var exp, i int;
-
+export func Sqrt(arg float64) float64 {
if sys.isInf(arg, 1) {
return arg;
}
@@ -28,7 +23,7 @@ sqrt(arg float64) float64
return 0;
}
- x,exp = sys.frexp(arg);
+ x,exp := sys.frexp(arg);
for x < 0.5 {
x = x*2;
exp = exp-1;
@@ -38,7 +33,7 @@ sqrt(arg float64) float64
x = x*2;
exp = exp-1;
}
- temp = 0.5 * (1+x);
+ temp := 0.5 * (1+x);
for exp > 60 {
temp = temp * float64(1<<30);
@@ -56,7 +51,7 @@ sqrt(arg float64) float64
temp = temp / float64(exp);
}
- for i=0; i<=4; i=i+1 {
+ for i:=0; i<=4; i++ {
temp = 0.5*(temp + arg/temp);
}
return temp;
diff --git a/src/lib/math/tan.go b/src/lib/math/tan.go
index ffcf7f661..fff36c67b 100644
--- a/src/lib/math/tan.go
+++ b/src/lib/math/tan.go
@@ -22,23 +22,18 @@ const
piu4 = .1273239544735162686151070107e+1; // 4/pi
)
-export func
-tan(arg float64) float64
-{
- var temp, e, x, xsq float64;
- var i int32;
- var flag, sign bool;
-
- flag = false;
- sign = false;
- x = arg;
+export func Tan(arg float64) float64 {
+ flag := false;
+ sign := false;
+ x := arg;
if(x < 0) {
x = -x;
sign = true;
}
x = x * piu4; /* overflow? */
- e,x = sys.modf(x);
- i = int32(e);
+ var e float64;
+ e, x = sys.modf(x);
+ i := int32(e);
switch i & 3 {
case 1:
@@ -54,8 +49,8 @@ tan(arg float64) float64
sign = !sign;
}
- xsq = x*x;
- temp = ((((p4*xsq+p3)*xsq+p2)*xsq+p1)*xsq+p0)*x;
+ xsq := x*x;
+ temp := ((((p4*xsq+p3)*xsq+p2)*xsq+p1)*xsq+p0)*x;
temp = temp/(((xsq+q2)*xsq+q1)*xsq+q0);
if flag {
diff --git a/src/lib/math/tanh.go b/src/lib/math/tanh.go
index dc6a0dd4a..45f7723ee 100644
--- a/src/lib/math/tanh.go
+++ b/src/lib/math/tanh.go
@@ -4,7 +4,7 @@
package math
-import math "math"
+import "math"
/*
* tanh(arg) computes the hyperbolic tangent of its floating
@@ -14,18 +14,16 @@ import math "math"
* would cause overflow improperly.
*/
-export func
-tanh(arg float64) float64
-{
+export func Tanh(arg float64) float64 {
if arg < 0 {
arg = -arg;
if arg > 21 {
return -1;
}
- return -sinh(arg)/cosh(arg);
+ return -Sinh(arg)/Cosh(arg);
}
if arg > 21 {
return 1;
}
- return sinh(arg)/cosh(arg);
+ return Sinh(arg)/Cosh(arg);
}
diff --git a/src/lib/math/test.go b/src/lib/math/test.go
new file mode 100644
index 000000000..b4eb8bb0e
--- /dev/null
+++ b/src/lib/math/test.go
@@ -0,0 +1,273 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// $G $F.go && $L $F.$A && (./$A.out || echo BUG: math fails)
+
+package math
+
+import (
+ "math";
+ "testing";
+)
+
+var vf = []float64 {
+ 4.9790119248836735e+00,
+ 7.7388724745781045e+00,
+ -2.7688005719200159e-01,
+ -5.0106036182710749e+00,
+ 9.6362937071984173e+00,
+ 2.9263772392439646e+00,
+ 5.2290834314593066e+00,
+ 2.7279399104360102e+00,
+ 1.8253080916808550e+00,
+ -8.6859247685756013e+00,
+}
+var asin = []float64 {
+ 5.2117697218417440e-01,
+ 8.8495619865825236e-01,
+ -2.7691544662819413e-02,
+ -5.2482360935268932e-01,
+ 1.3002662421166553e+00,
+ 2.9698415875871901e-01,
+ 5.5025938468083364e-01,
+ 2.7629597861677200e-01,
+ 1.8355989225745148e-01,
+ -1.0523547536021498e+00,
+}
+var atan = []float64 {
+ 1.3725902621296217e+00,
+ 1.4422906096452980e+00,
+ -2.7011324359471755e-01,
+ -1.3738077684543379e+00,
+ 1.4673921193587666e+00,
+ 1.2415173565870167e+00,
+ 1.3818396865615167e+00,
+ 1.2194305844639670e+00,
+ 1.0696031952318783e+00,
+ -1.4561721938838085e+00,
+}
+var exp = []float64 {
+ 1.4533071302642137e+02,
+ 2.2958822575694450e+03,
+ 7.5814542574851664e-01,
+ 6.6668778421791010e-03,
+ 1.5310493273896035e+04,
+ 1.8659907517999329e+01,
+ 1.8662167355098713e+02,
+ 1.5301332413189379e+01,
+ 6.2047063430646876e+00,
+ 1.6894712385826522e-04,
+}
+var floor = []float64 {
+ 4.0000000000000000e+00,
+ 7.0000000000000000e+00,
+ -1.0000000000000000e+00,
+ -6.0000000000000000e+00,
+ 9.0000000000000000e+00,
+ 2.0000000000000000e+00,
+ 5.0000000000000000e+00,
+ 2.0000000000000000e+00,
+ 1.0000000000000000e+00,
+ -9.0000000000000000e+00,
+}
+var log = []float64 {
+ 1.6052314626930630e+00,
+ 2.0462560018708768e+00,
+ -1.2841708730962657e+00,
+ 1.6115563905281544e+00,
+ 2.2655365644872018e+00,
+ 1.0737652208918380e+00,
+ 1.6542360106073545e+00,
+ 1.0035467127723465e+00,
+ 6.0174879014578053e-01,
+ 2.1617038728473527e+00,
+}
+var pow = []float64 {
+ 9.5282232631648415e+04,
+ 5.4811599352999900e+07,
+ 5.2859121715894400e-01,
+ 9.7587991957286472e-06,
+ 4.3280643293460450e+09,
+ 8.4406761805034551e+02,
+ 1.6946633276191194e+05,
+ 5.3449040147551940e+02,
+ 6.6881821384514159e+01,
+ 2.0609869004248744e-09,
+}
+var sin = []float64 {
+ -9.6466616586009283e-01,
+ 9.9338225271646543e-01,
+ -2.7335587039794395e-01,
+ 9.5586257685042800e-01,
+ -2.0994210667799692e-01,
+ 2.1355787807998605e-01,
+ -8.6945689711673619e-01,
+ 4.0195666811555783e-01,
+ 9.6778633541688000e-01,
+ -6.7344058690503452e-01,
+}
+var sinh = []float64 {
+ 7.2661916084208533e+01,
+ 1.1479409110035194e+03,
+ -2.8043136512812520e-01,
+ -7.4994290911815868e+01,
+ 7.6552466042906761e+03,
+ 9.3031583421672010e+00,
+ 9.3308157558281088e+01,
+ 7.6179893137269143e+00,
+ 3.0217691805496156e+00,
+ -2.9595057572444951e+03,
+}
+var sqrt = []float64 {
+ 2.2313699659365484e+00,
+ 2.7818829009464263e+00,
+ 5.2619393496314792e-01,
+ 2.2384377628763938e+00,
+ 3.1042380236055380e+00,
+ 1.7106657298385224e+00,
+ 2.2867189227054791e+00,
+ 1.6516476350711160e+00,
+ 1.3510396336454586e+00,
+ 2.9471892997524950e+00,
+}
+var tan = []float64 {
+ -3.6613165650402277e+00,
+ 8.6490023264859754e+00,
+ -2.8417941955033615e-01,
+ 3.2532901859747287e+00,
+ 2.1472756403802937e-01,
+ -2.1860091071106700e-01,
+ -1.7600028178723679e+00,
+ -4.3898089147528178e-01,
+ -3.8438855602011305e+00,
+ 9.1098879337768517e-01,
+}
+var tanh = []float64 {
+ 9.9990531206936328e-01,
+ 9.9999962057085307e-01,
+ -2.7001505097318680e-01,
+ -9.9991110943061700e-01,
+ 9.9999999146798441e-01,
+ 9.9427249436125233e-01,
+ 9.9994257600983156e-01,
+ 9.9149409509772863e-01,
+ 9.4936501296239700e-01,
+ -9.9999994291374019e-01,
+}
+
+func Close(a,b float64) bool {
+ d := a-b;
+ if d < 0 {
+ d = -d;
+ }
+
+ e := float64(1e-14);
+ if a != 0 {
+ e = e*a;
+ if e < 0 {
+ e = -e;
+ }
+ }
+ return d < e;
+}
+
+export func TestAsin(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Asin(vf[i]/10); !Close(asin[i], f) {
+ t.Errorf("math.Asin(%g) = %g, want %g\n", vf[i]/10, f, asin[i]);
+ }
+ }
+}
+
+export func TestAtan(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Atan(vf[i]); !Close(atan[i], f) {
+ t.Errorf("math.Atan(%g) = %g, want %g\n", vf[i], f, atan[i]);
+ }
+ }
+}
+
+export func TestExp(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Exp(vf[i]); !Close(exp[i], f) {
+ t.Errorf("math.Exp(%g) = %g, want %g\n", vf[i], f, exp[i]);
+ }
+ }
+}
+
+export func TestFloor(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Floor(vf[i]); !Close(floor[i], f) {
+ t.Errorf("math.Floor(%g) = %g, want %g\n", vf[i], f, floor[i]);
+ }
+ }
+}
+
+export func TestLog(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ a := math.Fabs(vf[i]);
+ if f := math.Log(a); !Close(log[i], f) {
+ t.Errorf("math.Log(%g) = %g, want %g\n", a, f, floor[i]);
+ }
+ }
+}
+
+export func TestPow(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Pow(10, vf[i]); !Close(pow[i], f) {
+ t.Errorf("math.Pow(10, %.17g) = %.17g, want %.17g\n", vf[i], f, pow[i]);
+ }
+ }
+}
+
+export func TestSin(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Sin(vf[i]); !Close(sin[i], f) {
+ t.Errorf("math.Sin(%g) = %g, want %g\n", vf[i], f, sin[i]);
+ }
+ }
+}
+
+export func TestSinh(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Sinh(vf[i]); !Close(sinh[i], f) {
+ t.Errorf("math.Sinh(%g) = %g, want %g\n", vf[i], f, sinh[i]);
+ }
+ }
+}
+
+export func TestSqrt(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ a := math.Fabs(vf[i]);
+ if f := math.Sqrt(a); !Close(sqrt[i], f) {
+ t.Errorf("math.Sqrt(%g) = %g, want %g\n", a, f, floor[i]);
+ }
+ }
+}
+
+export func TestTan(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Tan(vf[i]); !Close(tan[i], f) {
+ t.Errorf("math.Tan(%g) = %g, want %g\n", vf[i], f, tan[i]);
+ }
+ }
+}
+
+export func TestTanh(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ if f := math.Tanh(vf[i]); !Close(tanh[i], f) {
+ t.Errorf("math.Tanh(%g) = %g, want %g\n", vf[i], f, tanh[i]);
+ }
+ }
+}
+
+export func TestHypot(t *testing.T) {
+ for i := 0; i < len(vf); i++ {
+ a := math.Fabs(tanh[i]*math.Sqrt(2));
+ if f := math.Hypot(tanh[i], tanh[i]); !Close(a, f) {
+ t.Errorf("math.Hypot(%g, %g) = %g, want %g\n", tanh[i], tanh[i], f, a);
+ }
+ }
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-05 07:37:02 +0000