Commit 0fda2f31aae2109886c74b352ea4dee23ce6eb74 | zig

author	Marc Tiehuis <marc@tiehu.is> 2024-07-30 16:29:51+12:00
committer	Marc Tiehuis <marc@tiehu.is> 2024-07-30 16:30:20+12:00
log	0fda2f31aae2109886c74b352ea4dee23ce6eb74
tree	c9c5e20831f68b0d38dd95a9a73bd92b10688939
parent	2bd7af63d76d1c61bfd77a5402f94d105c375a1d

std.math.complex: tighten existing test bounds

19 files changed, 68 insertions(+), 78 deletions(-)

lib
- std
  - math
    complex
    abs.zig
    acos.zig
    acosh.zig
    arg.zig
    asin.zig
    asinh.zig
    atan.zig
    atanh.zig
    conj.zig
    cos.zig
    cosh.zig
    log.zig
    pow.zig
    proj.zig
    sin.zig
    sinh.zig
    sqrt.zig
    tan.zig
    tanh.zig

lib/std/math/complex/abs.zig+2-3

...	...	@@ -9,10 +9,9 @@ pub fn abs(z: anytype) @TypeOf(z.re, z.im) {
9	9	return math.hypot(z.re, z.im);
10	10	}
11	11
12		const epsilon = 0.0001;
13
14	12	test abs {
	13	const epsilon = math.floatEps(f32);
15	14	const a = Complex(f32).init(5, 3);
16	15	const c = abs(a);
17		try testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
	16	try testing.expectApproxEqAbs(5.8309517, c, epsilon);
18	17	}

lib/std/math/complex/acos.zig+3-4

...	...	@@ -11,12 +11,11 @@ pub fn acos(z: anytype) Complex(@TypeOf(z.re, z.im)) {
11	11	return Complex(T).init(@as(T, math.pi) / 2 - q.re, -q.im);
12	12	}
13	13
14		const epsilon = 0.0001;
15
16	14	test acos {
	15	const epsilon = math.floatEps(f32);
17	16	const a = Complex(f32).init(5, 3);
18	17	const c = acos(a);
19	18
20		try testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon));
21		try testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon));
	19	try testing.expectApproxEqAbs(0.5469737, c.re, epsilon);
	20	try testing.expectApproxEqAbs(-2.4529128, c.im, epsilon);
22	21	}

lib/std/math/complex/acosh.zig+3-4

...	...	@@ -15,12 +15,11 @@ pub fn acosh(z: anytype) Complex(@TypeOf(z.re, z.im)) {
15	15	Complex(T).init(-q.im, q.re);
16	16	}
17	17
18		const epsilon = 0.0001;
19
20	18	test acosh {
	19	const epsilon = math.floatEps(f32);
21	20	const a = Complex(f32).init(5, 3);
22	21	const c = acosh(a);
23	22
24		try testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon));
25		try testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon));
	23	try testing.expectApproxEqAbs(2.4529128, c.re, epsilon);
	24	try testing.expectApproxEqAbs(0.5469737, c.im, epsilon);
26	25	}

lib/std/math/complex/arg.zig+2-3

...	...	@@ -9,10 +9,9 @@ pub fn arg(z: anytype) @TypeOf(z.re, z.im) {
9	9	return math.atan2(z.im, z.re);
10	10	}
11	11
12		const epsilon = 0.0001;
13
14	12	test arg {
	13	const epsilon = math.floatEps(f32);
15	14	const a = Complex(f32).init(5, 3);
16	15	const c = arg(a);
17		try testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon));
	16	try testing.expectApproxEqAbs(0.5404195, c, epsilon);
18	17	}

lib/std/math/complex/asin.zig+3-4

...	...	@@ -17,12 +17,11 @@ pub fn asin(z: anytype) Complex(@TypeOf(z.re, z.im)) {
17	17	return Complex(T).init(r.im, -r.re);
18	18	}
19	19
20		const epsilon = 0.0001;
21
22	20	test asin {
	21	const epsilon = math.floatEps(f32);
23	22	const a = Complex(f32).init(5, 3);
24	23	const c = asin(a);
25	24
26		try testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon));
27		try testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon));
	25	try testing.expectApproxEqAbs(1.0238227, c.re, epsilon);
	26	try testing.expectApproxEqAbs(2.4529128, c.im, epsilon);
28	27	}

lib/std/math/complex/asinh.zig+3-4

...	...	@@ -12,12 +12,11 @@ pub fn asinh(z: anytype) Complex(@TypeOf(z.re, z.im)) {
12	12	return Complex(T).init(r.im, -r.re);
13	13	}
14	14
15		const epsilon = 0.0001;
16
17	15	test asinh {
	16	const epsilon = math.floatEps(f32);
18	17	const a = Complex(f32).init(5, 3);
19	18	const c = asinh(a);
20	19
21		try testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon));
22		try testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon));
	20	try testing.expectApproxEqAbs(2.4598298, c.re, epsilon);
	21	try testing.expectApproxEqAbs(0.5339993, c.im, epsilon);
23	22	}

lib/std/math/complex/atan.zig+6-6

...	...	@@ -88,20 +88,20 @@ fn atan64(z: Complex(f64)) Complex(f64) {
88	88	return Complex(f64).init(w, 0.25 * @log(a));
89	89	}
90	90
91		const epsilon = 0.0001;
92
93	91	test atan32 {
	92	const epsilon = math.floatEps(f32);
94	93	const a = Complex(f32).init(5, 3);
95	94	const c = atan(a);
96	95
97		try testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon));
98		try testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon));
	96	try testing.expectApproxEqAbs(1.423679, c.re, epsilon);
	97	try testing.expectApproxEqAbs(0.086569, c.im, epsilon);
99	98	}
100	99
101	100	test atan64 {
	101	const epsilon = math.floatEps(f64);
102	102	const a = Complex(f64).init(5, 3);
103	103	const c = atan(a);
104	104
105		try testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon));
106		try testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon));
	105	try testing.expectApproxEqAbs(1.4236790442393028, c.re, epsilon);
	106	try testing.expectApproxEqAbs(0.08656905917945844, c.im, epsilon);
107	107	}

lib/std/math/complex/atanh.zig+3-4

...	...	@@ -12,12 +12,11 @@ pub fn atanh(z: anytype) Complex(@TypeOf(z.re, z.im)) {
12	12	return Complex(T).init(r.im, -r.re);
13	13	}
14	14
15		const epsilon = 0.0001;
16
17	15	test atanh {
	16	const epsilon = math.floatEps(f32);
18	17	const a = Complex(f32).init(5, 3);
19	18	const c = atanh(a);
20	19
21		try testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon));
22		try testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon));
	20	try testing.expectApproxEqAbs(0.14694665, c.re, epsilon);
	21	try testing.expectApproxEqAbs(1.4808695, c.im, epsilon);
23	22	}

lib/std/math/complex/conj.zig+2-1

...	...	@@ -14,5 +14,6 @@ test conj {
14	14	const a = Complex(f32).init(5, 3);
15	15	const c = a.conjugate();
16	16
17		try testing.expect(c.re == 5 and c.im == -3);
	17	try testing.expectEqual(5, c.re);
	18	try testing.expectEqual(-3, c.im);
18	19	}

lib/std/math/complex/cos.zig+3-4

...	...	@@ -11,12 +11,11 @@ pub fn cos(z: anytype) Complex(@TypeOf(z.re, z.im)) {
11	11	return cmath.cosh(p);
12	12	}
13	13
14		const epsilon = 0.0001;
15
16	14	test cos {
	15	const epsilon = math.floatEps(f32);
17	16	const a = Complex(f32).init(5, 3);
18	17	const c = cos(a);
19	18
20		try testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon));
21		try testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon));
	19	try testing.expectApproxEqAbs(2.8558152, c.re, epsilon);
	20	try testing.expectApproxEqAbs(9.606383, c.im, epsilon);
22	21	}

lib/std/math/complex/cosh.zig+6-6

...	...	@@ -153,20 +153,20 @@ fn cosh64(z: Complex(f64)) Complex(f64) {
153	153	return Complex(f64).init((x * x) * (y - y), (x + x) * (y - y));
154	154	}
155	155
156		const epsilon = 0.0001;
157
158	156	test cosh32 {
	157	const epsilon = math.floatEps(f32);
159	158	const a = Complex(f32).init(5, 3);
160	159	const c = cosh(a);
161	160
162		try testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon));
163		try testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon));
	161	try testing.expectApproxEqAbs(-73.467300, c.re, epsilon);
	162	try testing.expectApproxEqAbs(10.471557, c.im, epsilon);
164	163	}
165	164
166	165	test cosh64 {
	166	const epsilon = math.floatEps(f64);
167	167	const a = Complex(f64).init(5, 3);
168	168	const c = cosh(a);
169	169
170		try testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon));
171		try testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon));
	170	try testing.expectApproxEqAbs(-73.46729221264526, c.re, epsilon);
	171	try testing.expectApproxEqAbs(10.471557674805572, c.im, epsilon);
172	172	}

lib/std/math/complex/log.zig+3-4

...	...	@@ -13,12 +13,11 @@ pub fn log(z: anytype) Complex(@TypeOf(z.re, z.im)) {
13	13	return Complex(T).init(@log(r), phi);
14	14	}
15	15
16		const epsilon = 0.0001;
17
18	16	test log {
	17	const epsilon = math.floatEps(f32);
19	18	const a = Complex(f32).init(5, 3);
20	19	const c = log(a);
21	20
22		try testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon));
23		try testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon));
	21	try testing.expectApproxEqAbs(1.7631803, c.re, epsilon);
	22	try testing.expectApproxEqAbs(0.5404195, c.im, epsilon);
24	23	}

lib/std/math/complex/pow.zig+3-4

...	...	@@ -9,13 +9,12 @@ pub fn pow(z: anytype, s: anytype) Complex(@TypeOf(z.re, z.im, s.re, s.im)) {
9	9	return cmath.exp(cmath.log(z).mul(s));
10	10	}
11	11
12		const epsilon = 0.0001;
13
14	12	test pow {
	13	const epsilon = math.floatEps(f32);
15	14	const a = Complex(f32).init(5, 3);
16	15	const b = Complex(f32).init(2.3, -1.3);
17	16	const c = pow(a, b);
18	17
19		try testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon));
20		try testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon));
	18	try testing.expectApproxEqAbs(58.049110, c.re, epsilon);
	19	try testing.expectApproxEqAbs(-101.003433, c.im, epsilon);
21	20	}

lib/std/math/complex/proj.zig+2-1

...	...	@@ -19,5 +19,6 @@ test proj {
19	19	const a = Complex(f32).init(5, 3);
20	20	const c = proj(a);
21	21
22		try testing.expect(c.re == 5 and c.im == 3);
	22	try testing.expectEqual(5, c.re);
	23	try testing.expectEqual(3, c.im);
23	24	}

lib/std/math/complex/sin.zig+3-4

...	...	@@ -12,12 +12,11 @@ pub fn sin(z: anytype) Complex(@TypeOf(z.re, z.im)) {
12	12	return Complex(T).init(q.im, -q.re);
13	13	}
14	14
15		const epsilon = 0.0001;
16
17	15	test sin {
	16	const epsilon = math.floatEps(f32);
18	17	const a = Complex(f32).init(5, 3);
19	18	const c = sin(a);
20	19
21		try testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon));
22		try testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon));
	20	try testing.expectApproxEqAbs(-9.654126, c.re, epsilon);
	21	try testing.expectApproxEqAbs(2.8416924, c.im, epsilon);
23	22	}

lib/std/math/complex/sinh.zig+6-6

...	...	@@ -152,20 +152,20 @@ fn sinh64(z: Complex(f64)) Complex(f64) {
152	152	return Complex(f64).init((x * x) * (y - y), (x + x) * (y - y));
153	153	}
154	154
155		const epsilon = 0.0001;
156
157	155	test sinh32 {
	156	const epsilon = math.floatEps(f32);
158	157	const a = Complex(f32).init(5, 3);
159	158	const c = sinh(a);
160	159
161		try testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon));
162		try testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon));
	160	try testing.expectApproxEqAbs(-73.460617, c.re, epsilon);
	161	try testing.expectApproxEqAbs(10.472508, c.im, epsilon);
163	162	}
164	163
165	164	test sinh64 {
	165	const epsilon = math.floatEps(f64);
166	166	const a = Complex(f64).init(5, 3);
167	167	const c = sinh(a);
168	168
169		try testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon));
170		try testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon));
	169	try testing.expectApproxEqAbs(-73.46062169567367, c.re, epsilon);
	170	try testing.expectApproxEqAbs(10.472508533940392, c.im, epsilon);
171	171	}

lib/std/math/complex/sqrt.zig+6-6

...	...	@@ -127,20 +127,20 @@ fn sqrt64(z: Complex(f64)) Complex(f64) {
127	127	return result;
128	128	}
129	129
130		const epsilon = 0.0001;
131
132	130	test sqrt32 {
	131	const epsilon = math.floatEps(f32);
133	132	const a = Complex(f32).init(5, 3);
134	133	const c = sqrt(a);
135	134
136		try testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon));
137		try testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon));
	135	try testing.expectApproxEqAbs(2.3271174, c.re, epsilon);
	136	try testing.expectApproxEqAbs(0.6445742, c.im, epsilon);
138	137	}
139	138
140	139	test sqrt64 {
	140	const epsilon = math.floatEps(f64);
141	141	const a = Complex(f64).init(5, 3);
142	142	const c = sqrt(a);
143	143
144		try testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon));
145		try testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon));
	144	try testing.expectApproxEqAbs(2.3271175190399496, c.re, epsilon);
	145	try testing.expectApproxEqAbs(0.6445742373246469, c.im, epsilon);
146	146	}

lib/std/math/complex/tan.zig+3-4

...	...	@@ -12,12 +12,11 @@ pub fn tan(z: anytype) Complex(@TypeOf(z.re, z.im)) {
12	12	return Complex(T).init(r.im, -r.re);
13	13	}
14	14
15		const epsilon = 0.0001;
16
17	15	test tan {
	16	const epsilon = math.floatEps(f32);
18	17	const a = Complex(f32).init(5, 3);
19	18	const c = tan(a);
20	19
21		try testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon));
22		try testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon));
	20	try testing.expectApproxEqAbs(-0.002708233, c.re, epsilon);
	21	try testing.expectApproxEqAbs(1.0041647, c.im, epsilon);
23	22	}

lib/std/math/complex/tanh.zig+6-6

...	...	@@ -101,20 +101,20 @@ fn tanh64(z: Complex(f64)) Complex(f64) {
101	101	return Complex(f64).init((beta * rho * s) / den, t / den);
102	102	}
103	103
104		const epsilon = 0.0001;
105
106	104	test tanh32 {
	105	const epsilon = math.floatEps(f32);
107	106	const a = Complex(f32).init(5, 3);
108	107	const c = tanh(a);
109	108
110		try testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon));
111		try testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon));
	109	try testing.expectApproxEqAbs(0.99991274, c.re, epsilon);
	110	try testing.expectApproxEqAbs(-0.00002536878, c.im, epsilon);
112	111	}
113	112
114	113	test tanh64 {
	114	const epsilon = math.floatEps(f64);
115	115	const a = Complex(f64).init(5, 3);
116	116	const c = tanh(a);
117	117
118		try testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon));
119		try testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon));
	118	try testing.expectApproxEqAbs(0.9999128201513536, c.re, epsilon);
	119	try testing.expectApproxEqAbs(-0.00002536867620767604, c.im, epsilon);
120	120	}