Commit 1d998d5dce73d8d500dee5e41a3dca92a7f9b03e | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-04-24 21:14:12-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-04-24 21:14:12-04:00
log	1d998d5dce73d8d500dee5e41a3dca92a7f9b03e
tree	4fac84336118ea7cdc221f76be5c7ff3797d0cd9
parent	d5e99cc05ea05d701adffce55defc512d75e10d1

clean up complex math tests

16 files changed, 46 insertions(+), 112 deletions(-)

std
- math
  - complex
    acos.zig
    acosh.zig
    asin.zig
    asinh.zig
    atan.zig
    atanh.zig
    cos.zig
    cosh.zig
    exp.zig
    log.zig
    pow.zig
    sin.zig
    sinh.zig
    sqrt.zig
    tan.zig
    tanh.zig

std/math/complex/acos.zig+2-5

...	...	@@ -16,9 +16,6 @@ test "complex.cacos" {
16	16	const a = Complex(f32).new(5, 3);
17	17	const c = acos(a);
18	18
19		const re = c.re;
20		const im = c.im;
21
22		debug.assert(math.approxEq(f32, re, 0.546975, epsilon));
23		debug.assert(math.approxEq(f32, im, -2.452914, epsilon));
	19	debug.assert(math.approxEq(f32, c.re, 0.546975, epsilon));
	20	debug.assert(math.approxEq(f32, c.im, -2.452914, epsilon));
24	21	}

std/math/complex/acosh.zig+2-5

...	...	@@ -16,9 +16,6 @@ test "complex.cacosh" {
16	16	const a = Complex(f32).new(5, 3);
17	17	const c = acosh(a);
18	18
19		const re = c.re;
20		const im = c.im;
21
22		debug.assert(math.approxEq(f32, re, 2.452914, epsilon));
23		debug.assert(math.approxEq(f32, im, 0.546975, epsilon));
	19	debug.assert(math.approxEq(f32, c.re, 2.452914, epsilon));
	20	debug.assert(math.approxEq(f32, c.im, 0.546975, epsilon));
24	21	}

std/math/complex/asin.zig+2-5

...	...	@@ -22,9 +22,6 @@ test "complex.casin" {
22	22	const a = Complex(f32).new(5, 3);
23	23	const c = asin(a);
24	24
25		const re = c.re;
26		const im = c.im;
27
28		debug.assert(math.approxEq(f32, re, 1.023822, epsilon));
29		debug.assert(math.approxEq(f32, im, 2.452914, epsilon));
	25	debug.assert(math.approxEq(f32, c.re, 1.023822, epsilon));
	26	debug.assert(math.approxEq(f32, c.im, 2.452914, epsilon));
30	27	}

std/math/complex/asinh.zig+2-5

...	...	@@ -17,9 +17,6 @@ test "complex.casinh" {
17	17	const a = Complex(f32).new(5, 3);
18	18	const c = asinh(a);
19	19
20		const re = c.re;
21		const im = c.im;
22
23		debug.assert(math.approxEq(f32, re, 2.459831, epsilon));
24		debug.assert(math.approxEq(f32, im, 0.533999, epsilon));
	20	debug.assert(math.approxEq(f32, c.re, 2.459831, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 0.533999, epsilon));
25	22	}

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

...	...	@@ -113,24 +113,18 @@ fn atan64(z: &const Complex(f64)) Complex(f64) {
113	113
114	114	const epsilon = 0.0001;
115	115
116		test "complex.ctan32" {
	116	test "complex.catan32" {
117	117	const a = Complex(f32).new(5, 3);
118	118	const c = atan(a);
119	119
120		const re = c.re;
121		const im = c.im;
122
123		debug.assert(math.approxEq(f32, re, 1.423679, epsilon));
124		debug.assert(math.approxEq(f32, im, 0.086569, epsilon));
	120	debug.assert(math.approxEq(f32, c.re, 1.423679, epsilon));
	121	debug.assert(math.approxEq(f32, c.im, 0.086569, epsilon));
125	122	}
126	123
127		test "complex.ctan64" {
	124	test "complex.catan64" {
128	125	const a = Complex(f64).new(5, 3);
129	126	const c = atan(a);
130	127
131		const re = c.re;
132		const im = c.im;
133
134		debug.assert(math.approxEq(f64, re, 1.423679, epsilon));
135		debug.assert(math.approxEq(f64, im, 0.086569, epsilon));
	128	debug.assert(math.approxEq(f64, c.re, 1.423679, epsilon));
	129	debug.assert(math.approxEq(f64, c.im, 0.086569, epsilon));
136	130	}

std/math/complex/atanh.zig+2-5

...	...	@@ -17,9 +17,6 @@ test "complex.catanh" {
17	17	const a = Complex(f32).new(5, 3);
18	18	const c = atanh(a);
19	19
20		const re = c.re;
21		const im = c.im;
22
23		debug.assert(math.approxEq(f32, re, 0.146947, epsilon));
24		debug.assert(math.approxEq(f32, im, 1.480870, epsilon));
	20	debug.assert(math.approxEq(f32, c.re, 0.146947, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 1.480870, epsilon));
25	22	}

std/math/complex/cos.zig+2-5

...	...	@@ -16,9 +16,6 @@ test "complex.ccos" {
16	16	const a = Complex(f32).new(5, 3);
17	17	const c = cos(a);
18	18
19		const re = c.re;
20		const im = c.im;
21
22		debug.assert(math.approxEq(f32, re, 2.855815, epsilon));
23		debug.assert(math.approxEq(f32, im, 9.606383, epsilon));
	19	debug.assert(math.approxEq(f32, c.re, 2.855815, epsilon));
	20	debug.assert(math.approxEq(f32, c.im, 9.606383, epsilon));
24	21	}

std/math/complex/cosh.zig+4-10

...	...	@@ -152,20 +152,14 @@ test "complex.ccosh32" {
152	152	const a = Complex(f32).new(5, 3);
153	153	const c = cosh(a);
154	154
155		const re = c.re;
156		const im = c.im;
157
158		debug.assert(math.approxEq(f32, re, -73.467300, epsilon));
159		debug.assert(math.approxEq(f32, im, 10.471557, epsilon));
	155	debug.assert(math.approxEq(f32, c.re, -73.467300, epsilon));
	156	debug.assert(math.approxEq(f32, c.im, 10.471557, epsilon));
160	157	}
161	158
162	159	test "complex.ccosh64" {
163	160	const a = Complex(f64).new(5, 3);
164	161	const c = cosh(a);
165	162
166		const re = c.re;
167		const im = c.im;
168
169		debug.assert(math.approxEq(f64, re, -73.467300, epsilon));
170		debug.assert(math.approxEq(f64, im, 10.471557, epsilon));
	163	debug.assert(math.approxEq(f64, c.re, -73.467300, epsilon));
	164	debug.assert(math.approxEq(f64, c.im, 10.471557, epsilon));
171	165	}

std/math/complex/exp.zig+4-10

...	...	@@ -127,20 +127,14 @@ test "complex.cexp32" {
127	127	const a = Complex(f32).new(5, 3);
128	128	const c = exp(a);
129	129
130		const re = c.re;
131		const im = c.im;
132
133		debug.assert(math.approxEq(f32, re, -146.927917, epsilon));
134		debug.assert(math.approxEq(f32, im, 20.944065, epsilon));
	130	debug.assert(math.approxEq(f32, c.re, -146.927917, epsilon));
	131	debug.assert(math.approxEq(f32, c.im, 20.944065, epsilon));
135	132	}
136	133
137	134	test "complex.cexp64" {
138	135	const a = Complex(f32).new(5, 3);
139	136	const c = exp(a);
140	137
141		const re = c.re;
142		const im = c.im;
143
144		debug.assert(math.approxEq(f64, re, -146.927917, epsilon));
145		debug.assert(math.approxEq(f64, im, 20.944065, epsilon));
	138	debug.assert(math.approxEq(f64, c.re, -146.927917, epsilon));
	139	debug.assert(math.approxEq(f64, c.im, 20.944065, epsilon));
146	140	}

std/math/complex/log.zig+2-5

...	...	@@ -18,9 +18,6 @@ test "complex.clog" {
18	18	const a = Complex(f32).new(5, 3);
19	19	const c = log(a);
20	20
21		const re = c.re;
22		const im = c.im;
23
24		debug.assert(math.approxEq(f32, re, 1.763180, epsilon));
25		debug.assert(math.approxEq(f32, im, 0.540419, epsilon));
	21	debug.assert(math.approxEq(f32, c.re, 1.763180, epsilon));
	22	debug.assert(math.approxEq(f32, c.im, 0.540419, epsilon));
26	23	}

std/math/complex/pow.zig+2-5

...	...	@@ -17,9 +17,6 @@ test "complex.cpow" {
17	17	const b = Complex(f32).new(2.3, -1.3);
18	18	const c = pow(Complex(f32), a, b);
19	19
20		const re = c.re;
21		const im = c.im;
22
23		debug.assert(math.approxEq(f32, re, 58.049110, epsilon));
24		debug.assert(math.approxEq(f32, im, -101.003433, epsilon));
	20	debug.assert(math.approxEq(f32, c.re, 58.049110, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, -101.003433, epsilon));
25	22	}

std/math/complex/sin.zig+2-5

...	...	@@ -17,9 +17,6 @@ test "complex.csin" {
17	17	const a = Complex(f32).new(5, 3);
18	18	const c = sin(a);
19	19
20		const re = c.re;
21		const im = c.im;
22
23		debug.assert(math.approxEq(f32, re, -9.654126, epsilon));
24		debug.assert(math.approxEq(f32, im, 2.841692, epsilon));
	20	debug.assert(math.approxEq(f32, c.re, -9.654126, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 2.841692, epsilon));
25	22	}

std/math/complex/sinh.zig+4-10

...	...	@@ -151,20 +151,14 @@ test "complex.csinh32" {
151	151	const a = Complex(f32).new(5, 3);
152	152	const c = sinh(a);
153	153
154		const re = c.re;
155		const im = c.im;
156
157		debug.assert(math.approxEq(f32, re, -73.460617, epsilon));
158		debug.assert(math.approxEq(f32, im, 10.472508, epsilon));
	154	debug.assert(math.approxEq(f32, c.re, -73.460617, epsilon));
	155	debug.assert(math.approxEq(f32, c.im, 10.472508, epsilon));
159	156	}
160	157
161	158	test "complex.csinh64" {
162	159	const a = Complex(f64).new(5, 3);
163	160	const c = sinh(a);
164	161
165		const re = c.re;
166		const im = c.im;
167
168		debug.assert(math.approxEq(f64, re, -73.460617, epsilon));
169		debug.assert(math.approxEq(f64, im, 10.472508, epsilon));
	162	debug.assert(math.approxEq(f64, c.re, -73.460617, epsilon));
	163	debug.assert(math.approxEq(f64, c.im, 10.472508, epsilon));
170	164	}

std/math/complex/sqrt.zig+4-10

...	...	@@ -121,20 +121,14 @@ test "complex.csqrt32" {
121	121	const a = Complex(f32).new(5, 3);
122	122	const c = sqrt(a);
123	123
124		const re = c.re;
125		const im = c.im;
126
127		debug.assert(math.approxEq(f32, re, 2.327117, epsilon));
128		debug.assert(math.approxEq(f32, im, 0.644574, epsilon));
	124	debug.assert(math.approxEq(f32, c.re, 2.327117, epsilon));
	125	debug.assert(math.approxEq(f32, c.im, 0.644574, epsilon));
129	126	}
130	127
131	128	test "complex.csqrt64" {
132	129	const a = Complex(f64).new(5, 3);
133	130	const c = sqrt(a);
134	131
135		const re = c.re;
136		const im = c.im;
137
138		debug.assert(math.approxEq(f64, re, 2.3271175190399496, epsilon));
139		debug.assert(math.approxEq(f64, im, 0.6445742373246469, epsilon));
	132	debug.assert(math.approxEq(f64, c.re, 2.3271175190399496, epsilon));
	133	debug.assert(math.approxEq(f64, c.im, 0.6445742373246469, epsilon));
140	134	}

std/math/complex/tan.zig+2-5

...	...	@@ -17,9 +17,6 @@ test "complex.ctan" {
17	17	const a = Complex(f32).new(5, 3);
18	18	const c = tan(a);
19	19
20		const re = c.re;
21		const im = c.im;
22
23		debug.assert(math.approxEq(f32, re, -0.002708233, epsilon));
24		debug.assert(math.approxEq(f32, im, 1.004165, epsilon));
	20	debug.assert(math.approxEq(f32, c.re, -0.002708233, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 1.004165, epsilon));
25	22	}

std/math/complex/tanh.zig+4-10

...	...	@@ -98,20 +98,14 @@ test "complex.ctanh32" {
98	98	const a = Complex(f32).new(5, 3);
99	99	const c = tanh(a);
100	100
101		const re = c.re;
102		const im = c.im;
103
104		debug.assert(math.approxEq(f32, re, 0.999913, epsilon));
105		debug.assert(math.approxEq(f32, im, -0.000025, epsilon));
	101	debug.assert(math.approxEq(f32, c.re, 0.999913, epsilon));
	102	debug.assert(math.approxEq(f32, c.im, -0.000025, epsilon));
106	103	}
107	104
108	105	test "complex.ctanh64" {
109	106	const a = Complex(f64).new(5, 3);
110	107	const c = tanh(a);
111	108
112		const re = c.re;
113		const im = c.im;
114
115		debug.assert(math.approxEq(f64, re, 0.999913, epsilon));
116		debug.assert(math.approxEq(f64, im, -0.000025, epsilon));
	109	debug.assert(math.approxEq(f64, c.re, 0.999913, epsilon));
	110	debug.assert(math.approxEq(f64, c.im, -0.000025, epsilon));
117	111	}