Commit ff14451b4a328ca6862637a88912000d11aa2bf3 | zig

author	LemonBoy <thatlemon@gmail.com> 2020-11-02 13:25:50+01:00
committer	LemonBoy <thatlemon@gmail.com> 2020-11-05 16:08:49+01:00
log	ff14451b4a328ca6862637a88912000d11aa2bf3
tree	a4a0ea4799d4765b7b15d1b55d20235cb87f9ef4
parent	17837affd22a6055c65a14252fa38610fdeabc3a

std: Implement more useful approxEq semantics

Comparisons with absolute epsilons are usually useful when comparing
numbers to zero, for non-zero numbers it's advised to switch to relative
epsilons instead to obtain meaningful results (check [1] for more
details).

The new API introduces approxEqAbs and approxEqRel, where the former
aliases and deprecated the old `approxEq`, allowing the user to pick the
right tool for the job.

The documentation is meant to guide the user in the choice of the
correct alternative.

[1] https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

51 files changed, 574 insertions(+), 470 deletions(-)

lib
- std
  - fmt
    parse_float.zig
  - math.zig
  - math
    acos.zig
    acosh.zig
    asin.zig
    asinh.zig
    atan.zig
    atan2.zig
    atanh.zig
    cbrt.zig
    complex.zig
    complex
    abs.zig
    acos.zig
    acosh.zig
    arg.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
    cos.zig
    cosh.zig
    epsilon.zig
    exp.zig
    exp2.zig
    expm1.zig
    fma.zig
    frexp.zig
    hypot.zig
    ln.zig
    log.zig
    log10.zig
    log1p.zig
    log2.zig
    modf.zig
    pow.zig
    sin.zig
    sinh.zig
    tan.zig
    tanh.zig
  - special
    c.zig
test
- stage1
  - behavior
    floatop.zig

lib/std/fmt/parse_float.zig+9-9

...	...	@@ -370,7 +370,7 @@ test "fmt.parseFloat" {
370	370	const testing = std.testing;
371	371	const expect = testing.expect;
372	372	const expectEqual = testing.expectEqual;
373		const approxEq = std.math.approxEq;
	373	const approxEqAbs = std.math.approxEqAbs;
374	374	const epsilon = 1e-7;
375	375
376	376	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
...	...	@@ -392,8 +392,8 @@ test "fmt.parseFloat" {
392	392	expectEqual(try parseFloat(T, "-1e0"), -1.0);
393	393	expectEqual(try parseFloat(T, "1.234e3"), 1234);
394	394
395		expect(approxEq(T, try parseFloat(T, "3.141"), 3.141, epsilon));
396		expect(approxEq(T, try parseFloat(T, "-3.141"), -3.141, epsilon));
	395	expect(approxEqAbs(T, try parseFloat(T, "3.141"), 3.141, epsilon));
	396	expect(approxEqAbs(T, try parseFloat(T, "-3.141"), -3.141, epsilon));
397	397
398	398	expectEqual(try parseFloat(T, "1e-700"), 0);
399	399	expectEqual(try parseFloat(T, "1e+700"), std.math.inf(T));
...	...	@@ -405,13 +405,13 @@ test "fmt.parseFloat" {
405	405	expectEqual(try parseFloat(T, "0.4e0066999999999999999999999999999999999999999999999999999"), std.math.inf(T));
406	406
407	407	if (T != f16) {
408		expect(approxEq(T, try parseFloat(T, "1e-2"), 0.01, epsilon));
409		expect(approxEq(T, try parseFloat(T, "1234e-2"), 12.34, epsilon));
	408	expect(approxEqAbs(T, try parseFloat(T, "1e-2"), 0.01, epsilon));
	409	expect(approxEqAbs(T, try parseFloat(T, "1234e-2"), 12.34, epsilon));
410	410
411		expect(approxEq(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));
412		expect(approxEq(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));
413		expect(approxEq(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));
414		expect(approxEq(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));
	411	expect(approxEqAbs(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));
	412	expect(approxEqAbs(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));
	413	expect(approxEqAbs(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));
	414	expect(approxEqAbs(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));
415	415	}
416	416	}
417	417	}

lib/std/math.zig+87-2

...	...	@@ -64,6 +64,8 @@ pub const f16_max = 65504;
64	64	pub const f16_epsilon = 0.0009765625; // 2**-10
65	65	pub const f16_toint = 1.0 / f16_epsilon;
66	66
	67	pub const epsilon = @import("math/epsilon.zig").epsilon;
	68
67	69	pub const nan_u16 = @as(u16, 0x7C01);
68	70	pub const nan_f16 = @bitCast(f16, nan_u16);
69	71
...	...	@@ -104,9 +106,92 @@ pub const nan = @import("math/nan.zig").nan;
104	106	pub const snan = @import("math/nan.zig").snan;
105	107	pub const inf = @import("math/inf.zig").inf;
106	108
107		pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool {
	109	/// Performs an approximate comparison of two floating point values `x` and `y`.
	110	/// Returns true if the absolute difference between them is less or equal than
	111	/// the specified tolerance.
	112	///
	113	/// The `tolerance` parameter is the absolute tolerance used when determining if
	114	/// the two numbers are close enough, a good value for this parameter is a small
	115	/// multiple of `epsilon(T)`.
	116	///
	117	/// Note that this function is recommended for for comparing small numbers
	118	/// around zero, using `approxEqRel` is suggested otherwise.
	119	///
	120	/// NaN values are never considered equal to any value.
	121	pub fn approxEqAbs(comptime T: type, x: T, y: T, tolerance: T) bool {
	122	assert(@typeInfo(T) == .Float);
	123	assert(tolerance >= 0);
	124
	125	// Fast path for equal values (and signed zeros and infinites).
	126	if (x == y)
	127	return true;
	128
	129	if (isNan(x) or isNan(y))
	130	return false;
	131
	132	return fabs(x - y) <= tolerance;
	133	}
	134
	135	/// Performs an approximate comparison of two floating point values `x` and `y`.
	136	/// Returns true if the absolute difference between them is less or equal than
	137	/// `max(\|x\|, \|y\|) * tolerance`, where `tolerance` is a positive number greater
	138	/// than zero.
	139	///
	140	/// The `tolerance` parameter is the relative tolerance used when determining if
	141	/// the two numbers are close enough, a good value for this parameter is usually
	142	/// `sqrt(epsilon(T))`, meaning that the two numbers are considered equal if at
	143	/// least half of the digits are equal.
	144	///
	145	/// Note that for comparisons of small numbers around zero this function won't
	146	/// give meaningful results, use `approxEqAbs` instead.
	147	///
	148	/// NaN values are never considered equal to any value.
	149	pub fn approxEqRel(comptime T: type, x: T, y: T, tolerance: T) bool {
108	150	assert(@typeInfo(T) == .Float);
109		return fabs(x - y) < epsilon;
	151	assert(tolerance > 0);
	152
	153	// Fast path for equal values (and signed zeros and infinites).
	154	if (x == y)
	155	return true;
	156
	157	if (isNan(x) or isNan(y))
	158	return false;
	159
	160	return fabs(x - y) <= max(fabs(x), fabs(y)) * tolerance;
	161	}
	162
	163	/// Deprecated, use `approxEqAbs` or `approxEqRel`.
	164	pub const approxEq = approxEqAbs;
	165
	166	test "approxEqAbs and approxEqRel" {
	167	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
	168	const eps_value = comptime epsilon(T);
	169	const sqrt_eps_value = comptime sqrt(eps_value);
	170	const nan_value = comptime nan(T);
	171	const inf_value = comptime inf(T);
	172	const min_value: T = switch (T) {
	173	f16 => f16_min,
	174	f32 => f32_min,
	175	f64 => f64_min,
	176	f128 => f128_min,
	177	else => unreachable,
	178	};
	179
	180	testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value));
	181	testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value));
	182	testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value));
	183	testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value));
	184	testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value));
	185	testing.expect(!approxEqAbs(T, 1.0 + 2 * epsilon(T), 1.0, eps_value));
	186	testing.expect(approxEqAbs(T, 1.0 + 1 * epsilon(T), 1.0, eps_value));
	187	testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value));
	188	testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value));
	189	testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value));
	190	testing.expect(approxEqRel(T, min_value, min_value, sqrt_eps_value));
	191	testing.expect(approxEqRel(T, -min_value, -min_value, sqrt_eps_value));
	192	testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2));
	193	testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2));
	194	}
110	195	}
111	196
112	197	pub fn doNotOptimizeAway(value: anytype) void {

lib/std/math/acos.zig+12-12

...	...	@@ -161,23 +161,23 @@ test "math.acos" {
161	161	test "math.acos32" {
162	162	const epsilon = 0.000001;
163	163
164		expect(math.approxEq(f32, acos32(0.0), 1.570796, epsilon));
165		expect(math.approxEq(f32, acos32(0.2), 1.369438, epsilon));
166		expect(math.approxEq(f32, acos32(0.3434), 1.220262, epsilon));
167		expect(math.approxEq(f32, acos32(0.5), 1.047198, epsilon));
168		expect(math.approxEq(f32, acos32(0.8923), 0.468382, epsilon));
169		expect(math.approxEq(f32, acos32(-0.2), 1.772154, epsilon));
	164	expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon));
	165	expect(math.approxEqAbs(f32, acos32(0.2), 1.369438, epsilon));
	166	expect(math.approxEqAbs(f32, acos32(0.3434), 1.220262, epsilon));
	167	expect(math.approxEqAbs(f32, acos32(0.5), 1.047198, epsilon));
	168	expect(math.approxEqAbs(f32, acos32(0.8923), 0.468382, epsilon));
	169	expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon));
170	170	}
171	171
172	172	test "math.acos64" {
173	173	const epsilon = 0.000001;
174	174
175		expect(math.approxEq(f64, acos64(0.0), 1.570796, epsilon));
176		expect(math.approxEq(f64, acos64(0.2), 1.369438, epsilon));
177		expect(math.approxEq(f64, acos64(0.3434), 1.220262, epsilon));
178		expect(math.approxEq(f64, acos64(0.5), 1.047198, epsilon));
179		expect(math.approxEq(f64, acos64(0.8923), 0.468382, epsilon));
180		expect(math.approxEq(f64, acos64(-0.2), 1.772154, epsilon));
	175	expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon));
	176	expect(math.approxEqAbs(f64, acos64(0.2), 1.369438, epsilon));
	177	expect(math.approxEqAbs(f64, acos64(0.3434), 1.220262, epsilon));
	178	expect(math.approxEqAbs(f64, acos64(0.5), 1.047198, epsilon));
	179	expect(math.approxEqAbs(f64, acos64(0.8923), 0.468382, epsilon));
	180	expect(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon));
181	181	}
182	182
183	183	test "math.acos32.special" {

lib/std/math/acosh.zig+8-8

...	...	@@ -73,19 +73,19 @@ test "math.acosh" {
73	73	test "math.acosh32" {
74	74	const epsilon = 0.000001;
75	75
76		expect(math.approxEq(f32, acosh32(1.5), 0.962424, epsilon));
77		expect(math.approxEq(f32, acosh32(37.45), 4.315976, epsilon));
78		expect(math.approxEq(f32, acosh32(89.123), 5.183133, epsilon));
79		expect(math.approxEq(f32, acosh32(123123.234375), 12.414088, epsilon));
	76	expect(math.approxEqAbs(f32, acosh32(1.5), 0.962424, epsilon));
	77	expect(math.approxEqAbs(f32, acosh32(37.45), 4.315976, epsilon));
	78	expect(math.approxEqAbs(f32, acosh32(89.123), 5.183133, epsilon));
	79	expect(math.approxEqAbs(f32, acosh32(123123.234375), 12.414088, epsilon));
80	80	}
81	81
82	82	test "math.acosh64" {
83	83	const epsilon = 0.000001;
84	84
85		expect(math.approxEq(f64, acosh64(1.5), 0.962424, epsilon));
86		expect(math.approxEq(f64, acosh64(37.45), 4.315976, epsilon));
87		expect(math.approxEq(f64, acosh64(89.123), 5.183133, epsilon));
88		expect(math.approxEq(f64, acosh64(123123.234375), 12.414088, epsilon));
	85	expect(math.approxEqAbs(f64, acosh64(1.5), 0.962424, epsilon));
	86	expect(math.approxEqAbs(f64, acosh64(37.45), 4.315976, epsilon));
	87	expect(math.approxEqAbs(f64, acosh64(89.123), 5.183133, epsilon));
	88	expect(math.approxEqAbs(f64, acosh64(123123.234375), 12.414088, epsilon));
89	89	}
90	90
91	91	test "math.acosh32.special" {

lib/std/math/asin.zig+12-12

...	...	@@ -154,23 +154,23 @@ test "math.asin" {
154	154	test "math.asin32" {
155	155	const epsilon = 0.000001;
156	156
157		expect(math.approxEq(f32, asin32(0.0), 0.0, epsilon));
158		expect(math.approxEq(f32, asin32(0.2), 0.201358, epsilon));
159		expect(math.approxEq(f32, asin32(-0.2), -0.201358, epsilon));
160		expect(math.approxEq(f32, asin32(0.3434), 0.350535, epsilon));
161		expect(math.approxEq(f32, asin32(0.5), 0.523599, epsilon));
162		expect(math.approxEq(f32, asin32(0.8923), 1.102415, epsilon));
	157	expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon));
	158	expect(math.approxEqAbs(f32, asin32(0.2), 0.201358, epsilon));
	159	expect(math.approxEqAbs(f32, asin32(-0.2), -0.201358, epsilon));
	160	expect(math.approxEqAbs(f32, asin32(0.3434), 0.350535, epsilon));
	161	expect(math.approxEqAbs(f32, asin32(0.5), 0.523599, epsilon));
	162	expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon));
163	163	}
164	164
165	165	test "math.asin64" {
166	166	const epsilon = 0.000001;
167	167
168		expect(math.approxEq(f64, asin64(0.0), 0.0, epsilon));
169		expect(math.approxEq(f64, asin64(0.2), 0.201358, epsilon));
170		expect(math.approxEq(f64, asin64(-0.2), -0.201358, epsilon));
171		expect(math.approxEq(f64, asin64(0.3434), 0.350535, epsilon));
172		expect(math.approxEq(f64, asin64(0.5), 0.523599, epsilon));
173		expect(math.approxEq(f64, asin64(0.8923), 1.102415, epsilon));
	168	expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon));
	169	expect(math.approxEqAbs(f64, asin64(0.2), 0.201358, epsilon));
	170	expect(math.approxEqAbs(f64, asin64(-0.2), -0.201358, epsilon));
	171	expect(math.approxEqAbs(f64, asin64(0.3434), 0.350535, epsilon));
	172	expect(math.approxEqAbs(f64, asin64(0.5), 0.523599, epsilon));
	173	expect(math.approxEqAbs(f64, asin64(0.8923), 1.102415, epsilon));
174	174	}
175	175
176	176	test "math.asin32.special" {

lib/std/math/asinh.zig+14-14

...	...	@@ -101,25 +101,25 @@ test "math.asinh" {
101	101	test "math.asinh32" {
102	102	const epsilon = 0.000001;
103	103
104		expect(math.approxEq(f32, asinh32(0.0), 0.0, epsilon));
105		expect(math.approxEq(f32, asinh32(0.2), 0.198690, epsilon));
106		expect(math.approxEq(f32, asinh32(0.8923), 0.803133, epsilon));
107		expect(math.approxEq(f32, asinh32(1.5), 1.194763, epsilon));
108		expect(math.approxEq(f32, asinh32(37.45), 4.316332, epsilon));
109		expect(math.approxEq(f32, asinh32(89.123), 5.183196, epsilon));
110		expect(math.approxEq(f32, asinh32(123123.234375), 12.414088, epsilon));
	104	expect(math.approxEqAbs(f32, asinh32(0.0), 0.0, epsilon));
	105	expect(math.approxEqAbs(f32, asinh32(0.2), 0.198690, epsilon));
	106	expect(math.approxEqAbs(f32, asinh32(0.8923), 0.803133, epsilon));
	107	expect(math.approxEqAbs(f32, asinh32(1.5), 1.194763, epsilon));
	108	expect(math.approxEqAbs(f32, asinh32(37.45), 4.316332, epsilon));
	109	expect(math.approxEqAbs(f32, asinh32(89.123), 5.183196, epsilon));
	110	expect(math.approxEqAbs(f32, asinh32(123123.234375), 12.414088, epsilon));
111	111	}
112	112
113	113	test "math.asinh64" {
114	114	const epsilon = 0.000001;
115	115
116		expect(math.approxEq(f64, asinh64(0.0), 0.0, epsilon));
117		expect(math.approxEq(f64, asinh64(0.2), 0.198690, epsilon));
118		expect(math.approxEq(f64, asinh64(0.8923), 0.803133, epsilon));
119		expect(math.approxEq(f64, asinh64(1.5), 1.194763, epsilon));
120		expect(math.approxEq(f64, asinh64(37.45), 4.316332, epsilon));
121		expect(math.approxEq(f64, asinh64(89.123), 5.183196, epsilon));
122		expect(math.approxEq(f64, asinh64(123123.234375), 12.414088, epsilon));
	116	expect(math.approxEqAbs(f64, asinh64(0.0), 0.0, epsilon));
	117	expect(math.approxEqAbs(f64, asinh64(0.2), 0.198690, epsilon));
	118	expect(math.approxEqAbs(f64, asinh64(0.8923), 0.803133, epsilon));
	119	expect(math.approxEqAbs(f64, asinh64(1.5), 1.194763, epsilon));
	120	expect(math.approxEqAbs(f64, asinh64(37.45), 4.316332, epsilon));
	121	expect(math.approxEqAbs(f64, asinh64(89.123), 5.183196, epsilon));
	122	expect(math.approxEqAbs(f64, asinh64(123123.234375), 12.414088, epsilon));
123	123	}
124	124
125	125	test "math.asinh32.special" {

lib/std/math/atan.zig+14-14

...	...	@@ -224,21 +224,21 @@ test "math.atan" {
224	224	test "math.atan32" {
225	225	const epsilon = 0.000001;
226	226
227		expect(math.approxEq(f32, atan32(0.2), 0.197396, epsilon));
228		expect(math.approxEq(f32, atan32(-0.2), -0.197396, epsilon));
229		expect(math.approxEq(f32, atan32(0.3434), 0.330783, epsilon));
230		expect(math.approxEq(f32, atan32(0.8923), 0.728545, epsilon));
231		expect(math.approxEq(f32, atan32(1.5), 0.982794, epsilon));
	227	expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));
	228	expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon));
	229	expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon));
	230	expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon));
	231	expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));
232	232	}
233	233
234	234	test "math.atan64" {
235	235	const epsilon = 0.000001;
236	236
237		expect(math.approxEq(f64, atan64(0.2), 0.197396, epsilon));
238		expect(math.approxEq(f64, atan64(-0.2), -0.197396, epsilon));
239		expect(math.approxEq(f64, atan64(0.3434), 0.330783, epsilon));
240		expect(math.approxEq(f64, atan64(0.8923), 0.728545, epsilon));
241		expect(math.approxEq(f64, atan64(1.5), 0.982794, epsilon));
	237	expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));
	238	expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon));
	239	expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon));
	240	expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon));
	241	expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));
242	242	}
243	243
244	244	test "math.atan32.special" {
...	...	@@ -246,8 +246,8 @@ test "math.atan32.special" {
246	246
247	247	expect(atan32(0.0) == 0.0);
248	248	expect(atan32(-0.0) == -0.0);
249		expect(math.approxEq(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
250		expect(math.approxEq(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
	249	expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
	250	expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
251	251	}
252	252
253	253	test "math.atan64.special" {
...	...	@@ -255,6 +255,6 @@ test "math.atan64.special" {
255	255
256	256	expect(atan64(0.0) == 0.0);
257	257	expect(atan64(-0.0) == -0.0);
258		expect(math.approxEq(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
259		expect(math.approxEq(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
	258	expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
	259	expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
260	260	}

lib/std/math/atan2.zig+42-42

...	...	@@ -224,25 +224,25 @@ test "math.atan2" {
224	224	test "math.atan2_32" {
225	225	const epsilon = 0.000001;
226	226
227		expect(math.approxEq(f32, atan2_32(0.0, 0.0), 0.0, epsilon));
228		expect(math.approxEq(f32, atan2_32(0.2, 0.2), 0.785398, epsilon));
229		expect(math.approxEq(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon));
230		expect(math.approxEq(f32, atan2_32(0.2, -0.2), 2.356194, epsilon));
231		expect(math.approxEq(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon));
232		expect(math.approxEq(f32, atan2_32(0.34, -0.4), 2.437099, epsilon));
233		expect(math.approxEq(f32, atan2_32(0.34, 1.243), 0.267001, epsilon));
	227	expect(math.approxEqAbs(f32, atan2_32(0.0, 0.0), 0.0, epsilon));
	228	expect(math.approxEqAbs(f32, atan2_32(0.2, 0.2), 0.785398, epsilon));
	229	expect(math.approxEqAbs(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon));
	230	expect(math.approxEqAbs(f32, atan2_32(0.2, -0.2), 2.356194, epsilon));
	231	expect(math.approxEqAbs(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon));
	232	expect(math.approxEqAbs(f32, atan2_32(0.34, -0.4), 2.437099, epsilon));
	233	expect(math.approxEqAbs(f32, atan2_32(0.34, 1.243), 0.267001, epsilon));
234	234	}
235	235
236	236	test "math.atan2_64" {
237	237	const epsilon = 0.000001;
238	238
239		expect(math.approxEq(f64, atan2_64(0.0, 0.0), 0.0, epsilon));
240		expect(math.approxEq(f64, atan2_64(0.2, 0.2), 0.785398, epsilon));
241		expect(math.approxEq(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon));
242		expect(math.approxEq(f64, atan2_64(0.2, -0.2), 2.356194, epsilon));
243		expect(math.approxEq(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon));
244		expect(math.approxEq(f64, atan2_64(0.34, -0.4), 2.437099, epsilon));
245		expect(math.approxEq(f64, atan2_64(0.34, 1.243), 0.267001, epsilon));
	239	expect(math.approxEqAbs(f64, atan2_64(0.0, 0.0), 0.0, epsilon));
	240	expect(math.approxEqAbs(f64, atan2_64(0.2, 0.2), 0.785398, epsilon));
	241	expect(math.approxEqAbs(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon));
	242	expect(math.approxEqAbs(f64, atan2_64(0.2, -0.2), 2.356194, epsilon));
	243	expect(math.approxEqAbs(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon));
	244	expect(math.approxEqAbs(f64, atan2_64(0.34, -0.4), 2.437099, epsilon));
	245	expect(math.approxEqAbs(f64, atan2_64(0.34, 1.243), 0.267001, epsilon));
246	246	}
247	247
248	248	test "math.atan2_32.special" {
...	...	@@ -252,21 +252,21 @@ test "math.atan2_32.special" {
252	252	expect(math.isNan(atan2_32(math.nan(f32), 1.0)));
253	253	expect(atan2_32(0.0, 5.0) == 0.0);
254	254	expect(atan2_32(-0.0, 5.0) == -0.0);
255		expect(math.approxEq(f32, atan2_32(0.0, -5.0), math.pi, epsilon));
256		//expect(math.approxEq(f32, atan2_32(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero?
257		expect(math.approxEq(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon));
258		expect(math.approxEq(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon));
259		expect(math.approxEq(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon));
260		expect(math.approxEq(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon));
261		expect(math.approxEq(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon));
262		expect(math.approxEq(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon));
263		expect(math.approxEq(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon));
264		expect(math.approxEq(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon));
	255	expect(math.approxEqAbs(f32, atan2_32(0.0, -5.0), math.pi, epsilon));
	256	//expect(math.approxEqAbs(f32, atan2_32(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero?
	257	expect(math.approxEqAbs(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon));
	258	expect(math.approxEqAbs(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon));
	259	expect(math.approxEqAbs(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon));
	260	expect(math.approxEqAbs(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon));
	261	expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon));
	262	expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon));
	263	expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon));
	264	expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon));
265	265	expect(atan2_32(1.0, math.inf(f32)) == 0.0);
266		expect(math.approxEq(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon));
267		expect(math.approxEq(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon));
268		expect(math.approxEq(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon));
269		expect(math.approxEq(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon));
	266	expect(math.approxEqAbs(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon));
	267	expect(math.approxEqAbs(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon));
	268	expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon));
	269	expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon));
270	270	}
271	271
272	272	test "math.atan2_64.special" {
...	...	@@ -276,19 +276,19 @@ test "math.atan2_64.special" {
276	276	expect(math.isNan(atan2_64(math.nan(f64), 1.0)));
277	277	expect(atan2_64(0.0, 5.0) == 0.0);
278	278	expect(atan2_64(-0.0, 5.0) == -0.0);
279		expect(math.approxEq(f64, atan2_64(0.0, -5.0), math.pi, epsilon));
280		//expect(math.approxEq(f64, atan2_64(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero?
281		expect(math.approxEq(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon));
282		expect(math.approxEq(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon));
283		expect(math.approxEq(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon));
284		expect(math.approxEq(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon));
285		expect(math.approxEq(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon));
286		expect(math.approxEq(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon));
287		expect(math.approxEq(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon));
288		expect(math.approxEq(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon));
	279	expect(math.approxEqAbs(f64, atan2_64(0.0, -5.0), math.pi, epsilon));
	280	//expect(math.approxEqAbs(f64, atan2_64(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero?
	281	expect(math.approxEqAbs(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon));
	282	expect(math.approxEqAbs(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon));
	283	expect(math.approxEqAbs(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon));
	284	expect(math.approxEqAbs(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon));
	285	expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon));
	286	expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon));
	287	expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon));
	288	expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon));
289	289	expect(atan2_64(1.0, math.inf(f64)) == 0.0);
290		expect(math.approxEq(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon));
291		expect(math.approxEq(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon));
292		expect(math.approxEq(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon));
293		expect(math.approxEq(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon));
	290	expect(math.approxEqAbs(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon));
	291	expect(math.approxEqAbs(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon));
	292	expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon));
	293	expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon));
294	294	}

lib/std/math/atanh.zig+6-6

...	...	@@ -96,17 +96,17 @@ test "math.atanh" {
96	96	test "math.atanh_32" {
97	97	const epsilon = 0.000001;
98	98
99		expect(math.approxEq(f32, atanh_32(0.0), 0.0, epsilon));
100		expect(math.approxEq(f32, atanh_32(0.2), 0.202733, epsilon));
101		expect(math.approxEq(f32, atanh_32(0.8923), 1.433099, epsilon));
	99	expect(math.approxEqAbs(f32, atanh_32(0.0), 0.0, epsilon));
	100	expect(math.approxEqAbs(f32, atanh_32(0.2), 0.202733, epsilon));
	101	expect(math.approxEqAbs(f32, atanh_32(0.8923), 1.433099, epsilon));
102	102	}
103	103
104	104	test "math.atanh_64" {
105	105	const epsilon = 0.000001;
106	106
107		expect(math.approxEq(f64, atanh_64(0.0), 0.0, epsilon));
108		expect(math.approxEq(f64, atanh_64(0.2), 0.202733, epsilon));
109		expect(math.approxEq(f64, atanh_64(0.8923), 1.433099, epsilon));
	107	expect(math.approxEqAbs(f64, atanh_64(0.0), 0.0, epsilon));
	108	expect(math.approxEqAbs(f64, atanh_64(0.2), 0.202733, epsilon));
	109	expect(math.approxEqAbs(f64, atanh_64(0.8923), 1.433099, epsilon));
110	110	}
111	111
112	112	test "math.atanh32.special" {

lib/std/math/cbrt.zig+10-10

...	...	@@ -133,22 +133,22 @@ test "math.cbrt32" {
133	133	const epsilon = 0.000001;
134	134
135	135	expect(cbrt32(0.0) == 0.0);
136		expect(math.approxEq(f32, cbrt32(0.2), 0.584804, epsilon));
137		expect(math.approxEq(f32, cbrt32(0.8923), 0.962728, epsilon));
138		expect(math.approxEq(f32, cbrt32(1.5), 1.144714, epsilon));
139		expect(math.approxEq(f32, cbrt32(37.45), 3.345676, epsilon));
140		expect(math.approxEq(f32, cbrt32(123123.234375), 49.748501, epsilon));
	136	expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon));
	137	expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon));
	138	expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon));
	139	expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon));
	140	expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon));
141	141	}
142	142
143	143	test "math.cbrt64" {
144	144	const epsilon = 0.000001;
145	145
146	146	expect(cbrt64(0.0) == 0.0);
147		expect(math.approxEq(f64, cbrt64(0.2), 0.584804, epsilon));
148		expect(math.approxEq(f64, cbrt64(0.8923), 0.962728, epsilon));
149		expect(math.approxEq(f64, cbrt64(1.5), 1.144714, epsilon));
150		expect(math.approxEq(f64, cbrt64(37.45), 3.345676, epsilon));
151		expect(math.approxEq(f64, cbrt64(123123.234375), 49.748501, epsilon));
	147	expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon));
	148	expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon));
	149	expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon));
	150	expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon));
	151	expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon));
152	152	}
153	153
154	154	test "math.cbrt.special" {

lib/std/math/complex.zig+5-5

...	...	@@ -138,8 +138,8 @@ test "complex.div" {
138	138	const b = Complex(f32).new(2, 7);
139	139	const c = a.div(b);
140	140
141		testing.expect(math.approxEq(f32, c.re, @as(f32, 31) / 53, epsilon) and
142		math.approxEq(f32, c.im, @as(f32, -29) / 53, epsilon));
	141	testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 31) / 53, epsilon) and
	142	math.approxEqAbs(f32, c.im, @as(f32, -29) / 53, epsilon));
143	143	}
144	144
145	145	test "complex.conjugate" {
...	...	@@ -153,15 +153,15 @@ test "complex.reciprocal" {
153	153	const a = Complex(f32).new(5, 3);
154	154	const c = a.reciprocal();
155	155
156		testing.expect(math.approxEq(f32, c.re, @as(f32, 5) / 34, epsilon) and
157		math.approxEq(f32, c.im, @as(f32, -3) / 34, epsilon));
	156	testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 5) / 34, epsilon) and
	157	math.approxEqAbs(f32, c.im, @as(f32, -3) / 34, epsilon));
158	158	}
159	159
160	160	test "complex.magnitude" {
161	161	const a = Complex(f32).new(5, 3);
162	162	const c = a.magnitude();
163	163
164		testing.expect(math.approxEq(f32, c, 5.83095, epsilon));
	164	testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
165	165	}
166	166
167	167	test "complex.cmath" {

lib/std/math/complex/abs.zig+1-1

...	...	@@ -20,5 +20,5 @@ const epsilon = 0.0001;
20	20	test "complex.cabs" {
21	21	const a = Complex(f32).new(5, 3);
22	22	const c = abs(a);
23		testing.expect(math.approxEq(f32, c, 5.83095, epsilon));
	23	testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
24	24	}

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

...	...	@@ -22,6 +22,6 @@ test "complex.cacos" {
22	22	const a = Complex(f32).new(5, 3);
23	23	const c = acos(a);
24	24
25		testing.expect(math.approxEq(f32, c.re, 0.546975, epsilon));
26		testing.expect(math.approxEq(f32, c.im, -2.452914, epsilon));
	25	testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon));
27	27	}

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

...	...	@@ -22,6 +22,6 @@ test "complex.cacosh" {
22	22	const a = Complex(f32).new(5, 3);
23	23	const c = acosh(a);
24	24
25		testing.expect(math.approxEq(f32, c.re, 2.452914, epsilon));
26		testing.expect(math.approxEq(f32, c.im, 0.546975, epsilon));
	25	testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon));
27	27	}

lib/std/math/complex/arg.zig+1-1

...	...	@@ -20,5 +20,5 @@ const epsilon = 0.0001;
20	20	test "complex.carg" {
21	21	const a = Complex(f32).new(5, 3);
22	22	const c = arg(a);
23		testing.expect(math.approxEq(f32, c, 0.540420, epsilon));
	23	testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon));
24	24	}

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

...	...	@@ -28,6 +28,6 @@ test "complex.casin" {
28	28	const a = Complex(f32).new(5, 3);
29	29	const c = asin(a);
30	30
31		testing.expect(math.approxEq(f32, c.re, 1.023822, epsilon));
32		testing.expect(math.approxEq(f32, c.im, 2.452914, epsilon));
	31	testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon));
	32	testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon));
33	33	}

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

...	...	@@ -23,6 +23,6 @@ test "complex.casinh" {
23	23	const a = Complex(f32).new(5, 3);
24	24	const c = asinh(a);
25	25
26		testing.expect(math.approxEq(f32, c.re, 2.459831, epsilon));
27		testing.expect(math.approxEq(f32, c.im, 0.533999, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon));
	27	testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon));
28	28	}

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

...	...	@@ -130,14 +130,14 @@ test "complex.catan32" {
130	130	const a = Complex(f32).new(5, 3);
131	131	const c = atan(a);
132	132
133		testing.expect(math.approxEq(f32, c.re, 1.423679, epsilon));
134		testing.expect(math.approxEq(f32, c.im, 0.086569, epsilon));
	133	testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon));
	134	testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon));
135	135	}
136	136
137	137	test "complex.catan64" {
138	138	const a = Complex(f64).new(5, 3);
139	139	const c = atan(a);
140	140
141		testing.expect(math.approxEq(f64, c.re, 1.423679, epsilon));
142		testing.expect(math.approxEq(f64, c.im, 0.086569, epsilon));
	141	testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon));
	142	testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon));
143	143	}

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

...	...	@@ -23,6 +23,6 @@ test "complex.catanh" {
23	23	const a = Complex(f32).new(5, 3);
24	24	const c = atanh(a);
25	25
26		testing.expect(math.approxEq(f32, c.re, 0.146947, epsilon));
27		testing.expect(math.approxEq(f32, c.im, 1.480870, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon));
	27	testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon));
28	28	}

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

...	...	@@ -22,6 +22,6 @@ test "complex.ccos" {
22	22	const a = Complex(f32).new(5, 3);
23	23	const c = cos(a);
24	24
25		testing.expect(math.approxEq(f32, c.re, 2.855815, epsilon));
26		testing.expect(math.approxEq(f32, c.im, 9.606383, epsilon));
	25	testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon));
27	27	}

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

...	...	@@ -165,14 +165,14 @@ test "complex.ccosh32" {
165	165	const a = Complex(f32).new(5, 3);
166	166	const c = cosh(a);
167	167
168		testing.expect(math.approxEq(f32, c.re, -73.467300, epsilon));
169		testing.expect(math.approxEq(f32, c.im, 10.471557, epsilon));
	168	testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon));
	169	testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon));
170	170	}
171	171
172	172	test "complex.ccosh64" {
173	173	const a = Complex(f64).new(5, 3);
174	174	const c = cosh(a);
175	175
176		testing.expect(math.approxEq(f64, c.re, -73.467300, epsilon));
177		testing.expect(math.approxEq(f64, c.im, 10.471557, epsilon));
	176	testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon));
	177	testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon));
178	178	}

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

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

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

...	...	@@ -24,6 +24,6 @@ test "complex.clog" {
24	24	const a = Complex(f32).new(5, 3);
25	25	const c = log(a);
26	26
27		testing.expect(math.approxEq(f32, c.re, 1.763180, epsilon));
28		testing.expect(math.approxEq(f32, c.im, 0.540419, epsilon));
	27	testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon));
	28	testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon));
29	29	}

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

...	...	@@ -23,6 +23,6 @@ test "complex.cpow" {
23	23	const b = Complex(f32).new(2.3, -1.3);
24	24	const c = pow(Complex(f32), a, b);
25	25
26		testing.expect(math.approxEq(f32, c.re, 58.049110, epsilon));
27		testing.expect(math.approxEq(f32, c.im, -101.003433, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon));
	27	testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon));
28	28	}

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

...	...	@@ -23,6 +23,6 @@ test "complex.csin" {
23	23	const a = Complex(f32).new(5, 3);
24	24	const c = sin(a);
25	25
26		testing.expect(math.approxEq(f32, c.re, -9.654126, epsilon));
27		testing.expect(math.approxEq(f32, c.im, 2.841692, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon));
	27	testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon));
28	28	}

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

...	...	@@ -164,14 +164,14 @@ test "complex.csinh32" {
164	164	const a = Complex(f32).new(5, 3);
165	165	const c = sinh(a);
166	166
167		testing.expect(math.approxEq(f32, c.re, -73.460617, epsilon));
168		testing.expect(math.approxEq(f32, c.im, 10.472508, epsilon));
	167	testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon));
	168	testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon));
169	169	}
170	170
171	171	test "complex.csinh64" {
172	172	const a = Complex(f64).new(5, 3);
173	173	const c = sinh(a);
174	174
175		testing.expect(math.approxEq(f64, c.re, -73.460617, epsilon));
176		testing.expect(math.approxEq(f64, c.im, 10.472508, epsilon));
	175	testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon));
	176	testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon));
177	177	}

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

...	...	@@ -138,14 +138,14 @@ test "complex.csqrt32" {
138	138	const a = Complex(f32).new(5, 3);
139	139	const c = sqrt(a);
140	140
141		testing.expect(math.approxEq(f32, c.re, 2.327117, epsilon));
142		testing.expect(math.approxEq(f32, c.im, 0.644574, epsilon));
	141	testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon));
	142	testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon));
143	143	}
144	144
145	145	test "complex.csqrt64" {
146	146	const a = Complex(f64).new(5, 3);
147	147	const c = sqrt(a);
148	148
149		testing.expect(math.approxEq(f64, c.re, 2.3271175190399496, epsilon));
150		testing.expect(math.approxEq(f64, c.im, 0.6445742373246469, epsilon));
	149	testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon));
	150	testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon));
151	151	}

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

...	...	@@ -23,6 +23,6 @@ test "complex.ctan" {
23	23	const a = Complex(f32).new(5, 3);
24	24	const c = tan(a);
25	25
26		testing.expect(math.approxEq(f32, c.re, -0.002708233, epsilon));
27		testing.expect(math.approxEq(f32, c.im, 1.004165, epsilon));
	26	testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon));
	27	testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon));
28	28	}

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

...	...	@@ -113,14 +113,14 @@ test "complex.ctanh32" {
113	113	const a = Complex(f32).new(5, 3);
114	114	const c = tanh(a);
115	115
116		testing.expect(math.approxEq(f32, c.re, 0.999913, epsilon));
117		testing.expect(math.approxEq(f32, c.im, -0.000025, epsilon));
	116	testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon));
	117	testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon));
118	118	}
119	119
120	120	test "complex.ctanh64" {
121	121	const a = Complex(f64).new(5, 3);
122	122	const c = tanh(a);
123	123
124		testing.expect(math.approxEq(f64, c.re, 0.999913, epsilon));
125		testing.expect(math.approxEq(f64, c.im, -0.000025, epsilon));
	124	testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon));
	125	testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon));
126	126	}

lib/std/math/cos.zig+14-14

...	...	@@ -95,25 +95,25 @@ test "math.cos" {
95	95	test "math.cos32" {
96	96	const epsilon = 0.000001;
97	97
98		expect(math.approxEq(f32, cos_(f32, 0.0), 1.0, epsilon));
99		expect(math.approxEq(f32, cos_(f32, 0.2), 0.980067, epsilon));
100		expect(math.approxEq(f32, cos_(f32, 0.8923), 0.627623, epsilon));
101		expect(math.approxEq(f32, cos_(f32, 1.5), 0.070737, epsilon));
102		expect(math.approxEq(f32, cos_(f32, -1.5), 0.070737, epsilon));
103		expect(math.approxEq(f32, cos_(f32, 37.45), 0.969132, epsilon));
104		expect(math.approxEq(f32, cos_(f32, 89.123), 0.400798, epsilon));
	98	expect(math.approxEqAbs(f32, cos_(f32, 0.0), 1.0, epsilon));
	99	expect(math.approxEqAbs(f32, cos_(f32, 0.2), 0.980067, epsilon));
	100	expect(math.approxEqAbs(f32, cos_(f32, 0.8923), 0.627623, epsilon));
	101	expect(math.approxEqAbs(f32, cos_(f32, 1.5), 0.070737, epsilon));
	102	expect(math.approxEqAbs(f32, cos_(f32, -1.5), 0.070737, epsilon));
	103	expect(math.approxEqAbs(f32, cos_(f32, 37.45), 0.969132, epsilon));
	104	expect(math.approxEqAbs(f32, cos_(f32, 89.123), 0.400798, epsilon));
105	105	}
106	106
107	107	test "math.cos64" {
108	108	const epsilon = 0.000001;
109	109
110		expect(math.approxEq(f64, cos_(f64, 0.0), 1.0, epsilon));
111		expect(math.approxEq(f64, cos_(f64, 0.2), 0.980067, epsilon));
112		expect(math.approxEq(f64, cos_(f64, 0.8923), 0.627623, epsilon));
113		expect(math.approxEq(f64, cos_(f64, 1.5), 0.070737, epsilon));
114		expect(math.approxEq(f64, cos_(f64, -1.5), 0.070737, epsilon));
115		expect(math.approxEq(f64, cos_(f64, 37.45), 0.969132, epsilon));
116		expect(math.approxEq(f64, cos_(f64, 89.123), 0.40080, epsilon));
	110	expect(math.approxEqAbs(f64, cos_(f64, 0.0), 1.0, epsilon));
	111	expect(math.approxEqAbs(f64, cos_(f64, 0.2), 0.980067, epsilon));
	112	expect(math.approxEqAbs(f64, cos_(f64, 0.8923), 0.627623, epsilon));
	113	expect(math.approxEqAbs(f64, cos_(f64, 1.5), 0.070737, epsilon));
	114	expect(math.approxEqAbs(f64, cos_(f64, -1.5), 0.070737, epsilon));
	115	expect(math.approxEqAbs(f64, cos_(f64, 37.45), 0.969132, epsilon));
	116	expect(math.approxEqAbs(f64, cos_(f64, 89.123), 0.40080, epsilon));
117	117	}
118	118
119	119	test "math.cos32.special" {

lib/std/math/cosh.zig+16-16

...	...	@@ -100,27 +100,27 @@ test "math.cosh" {
100	100	test "math.cosh32" {
101	101	const epsilon = 0.000001;
102	102
103		expect(math.approxEq(f32, cosh32(0.0), 1.0, epsilon));
104		expect(math.approxEq(f32, cosh32(0.2), 1.020067, epsilon));
105		expect(math.approxEq(f32, cosh32(0.8923), 1.425225, epsilon));
106		expect(math.approxEq(f32, cosh32(1.5), 2.352410, epsilon));
107		expect(math.approxEq(f32, cosh32(-0.0), 1.0, epsilon));
108		expect(math.approxEq(f32, cosh32(-0.2), 1.020067, epsilon));
109		expect(math.approxEq(f32, cosh32(-0.8923), 1.425225, epsilon));
110		expect(math.approxEq(f32, cosh32(-1.5), 2.352410, epsilon));
	103	expect(math.approxEqAbs(f32, cosh32(0.0), 1.0, epsilon));
	104	expect(math.approxEqAbs(f32, cosh32(0.2), 1.020067, epsilon));
	105	expect(math.approxEqAbs(f32, cosh32(0.8923), 1.425225, epsilon));
	106	expect(math.approxEqAbs(f32, cosh32(1.5), 2.352410, epsilon));
	107	expect(math.approxEqAbs(f32, cosh32(-0.0), 1.0, epsilon));
	108	expect(math.approxEqAbs(f32, cosh32(-0.2), 1.020067, epsilon));
	109	expect(math.approxEqAbs(f32, cosh32(-0.8923), 1.425225, epsilon));
	110	expect(math.approxEqAbs(f32, cosh32(-1.5), 2.352410, epsilon));
111	111	}
112	112
113	113	test "math.cosh64" {
114	114	const epsilon = 0.000001;
115	115
116		expect(math.approxEq(f64, cosh64(0.0), 1.0, epsilon));
117		expect(math.approxEq(f64, cosh64(0.2), 1.020067, epsilon));
118		expect(math.approxEq(f64, cosh64(0.8923), 1.425225, epsilon));
119		expect(math.approxEq(f64, cosh64(1.5), 2.352410, epsilon));
120		expect(math.approxEq(f64, cosh64(-0.0), 1.0, epsilon));
121		expect(math.approxEq(f64, cosh64(-0.2), 1.020067, epsilon));
122		expect(math.approxEq(f64, cosh64(-0.8923), 1.425225, epsilon));
123		expect(math.approxEq(f64, cosh64(-1.5), 2.352410, epsilon));
	116	expect(math.approxEqAbs(f64, cosh64(0.0), 1.0, epsilon));
	117	expect(math.approxEqAbs(f64, cosh64(0.2), 1.020067, epsilon));
	118	expect(math.approxEqAbs(f64, cosh64(0.8923), 1.425225, epsilon));
	119	expect(math.approxEqAbs(f64, cosh64(1.5), 2.352410, epsilon));
	120	expect(math.approxEqAbs(f64, cosh64(-0.0), 1.0, epsilon));
	121	expect(math.approxEqAbs(f64, cosh64(-0.2), 1.020067, epsilon));
	122	expect(math.approxEqAbs(f64, cosh64(-0.8923), 1.425225, epsilon));
	123	expect(math.approxEqAbs(f64, cosh64(-1.5), 2.352410, epsilon));
124	124	}
125	125
126	126	test "math.cosh32.special" {

lib/std/math/epsilon.zig created+19

...	...	@@ -0,0 +1,19 @@
	1	// SPDX-License-Identifier: MIT
	2	// Copyright (c) 2015-2020 Zig Contributors
	3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
	4	// The MIT license requires this copyright notice to be included in all copies
	5	// and substantial portions of the software.
	6	const math = @import("../math.zig");
	7
	8	/// Returns the machine epsilon for type T.
	9	/// This is the smallest value of type T that satisfies the inequality 1.0 +
	10	/// epsilon != 1.0.
	11	pub fn epsilon(comptime T: type) T {
	12	return switch (T) {
	13	f16 => math.f16_epsilon,
	14	f32 => math.f32_epsilon,
	15	f64 => math.f64_epsilon,
	16	f128 => math.f128_epsilon,
	17	else => @compileError("epsilon not implemented for " ++ @typeName(T)),
	18	};
	19	}

lib/std/math/exp.zig+8-8

...	...	@@ -196,20 +196,20 @@ test "math.exp32" {
196	196	const epsilon = 0.000001;
197	197
198	198	assert(exp32(0.0) == 1.0);
199		assert(math.approxEq(f32, exp32(0.0), 1.0, epsilon));
200		assert(math.approxEq(f32, exp32(0.2), 1.221403, epsilon));
201		assert(math.approxEq(f32, exp32(0.8923), 2.440737, epsilon));
202		assert(math.approxEq(f32, exp32(1.5), 4.481689, epsilon));
	199	assert(math.approxEqAbs(f32, exp32(0.0), 1.0, epsilon));
	200	assert(math.approxEqAbs(f32, exp32(0.2), 1.221403, epsilon));
	201	assert(math.approxEqAbs(f32, exp32(0.8923), 2.440737, epsilon));
	202	assert(math.approxEqAbs(f32, exp32(1.5), 4.481689, epsilon));
203	203	}
204	204
205	205	test "math.exp64" {
206	206	const epsilon = 0.000001;
207	207
208	208	assert(exp64(0.0) == 1.0);
209		assert(math.approxEq(f64, exp64(0.0), 1.0, epsilon));
210		assert(math.approxEq(f64, exp64(0.2), 1.221403, epsilon));
211		assert(math.approxEq(f64, exp64(0.8923), 2.440737, epsilon));
212		assert(math.approxEq(f64, exp64(1.5), 4.481689, epsilon));
	209	assert(math.approxEqAbs(f64, exp64(0.0), 1.0, epsilon));
	210	assert(math.approxEqAbs(f64, exp64(0.2), 1.221403, epsilon));
	211	assert(math.approxEqAbs(f64, exp64(0.8923), 2.440737, epsilon));
	212	assert(math.approxEqAbs(f64, exp64(1.5), 4.481689, epsilon));
213	213	}
214	214
215	215	test "math.exp32.special" {

lib/std/math/exp2.zig+7-7

...	...	@@ -434,19 +434,19 @@ test "math.exp2_32" {
434	434	const epsilon = 0.000001;
435	435
436	436	expect(exp2_32(0.0) == 1.0);
437		expect(math.approxEq(f32, exp2_32(0.2), 1.148698, epsilon));
438		expect(math.approxEq(f32, exp2_32(0.8923), 1.856133, epsilon));
439		expect(math.approxEq(f32, exp2_32(1.5), 2.828427, epsilon));
440		expect(math.approxEq(f32, exp2_32(37.45), 187747237888, epsilon));
	437	expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon));
	438	expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon));
	439	expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon));
	440	expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon));
441	441	}
442	442
443	443	test "math.exp2_64" {
444	444	const epsilon = 0.000001;
445	445
446	446	expect(exp2_64(0.0) == 1.0);
447		expect(math.approxEq(f64, exp2_64(0.2), 1.148698, epsilon));
448		expect(math.approxEq(f64, exp2_64(0.8923), 1.856133, epsilon));
449		expect(math.approxEq(f64, exp2_64(1.5), 2.828427, epsilon));
	447	expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon));
	448	expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon));
	449	expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon));
450	450	}
451	451
452	452	test "math.exp2_32.special" {

lib/std/math/expm1.zig+8-8

...	...	@@ -300,20 +300,20 @@ test "math.expm1_32" {
300	300	const epsilon = 0.000001;
301	301
302	302	expect(expm1_32(0.0) == 0.0);
303		expect(math.approxEq(f32, expm1_32(0.0), 0.0, epsilon));
304		expect(math.approxEq(f32, expm1_32(0.2), 0.221403, epsilon));
305		expect(math.approxEq(f32, expm1_32(0.8923), 1.440737, epsilon));
306		expect(math.approxEq(f32, expm1_32(1.5), 3.481689, epsilon));
	303	expect(math.approxEqAbs(f32, expm1_32(0.0), 0.0, epsilon));
	304	expect(math.approxEqAbs(f32, expm1_32(0.2), 0.221403, epsilon));
	305	expect(math.approxEqAbs(f32, expm1_32(0.8923), 1.440737, epsilon));
	306	expect(math.approxEqAbs(f32, expm1_32(1.5), 3.481689, epsilon));
307	307	}
308	308
309	309	test "math.expm1_64" {
310	310	const epsilon = 0.000001;
311	311
312	312	expect(expm1_64(0.0) == 0.0);
313		expect(math.approxEq(f64, expm1_64(0.0), 0.0, epsilon));
314		expect(math.approxEq(f64, expm1_64(0.2), 0.221403, epsilon));
315		expect(math.approxEq(f64, expm1_64(0.8923), 1.440737, epsilon));
316		expect(math.approxEq(f64, expm1_64(1.5), 3.481689, epsilon));
	313	expect(math.approxEqAbs(f64, expm1_64(0.0), 0.0, epsilon));
	314	expect(math.approxEqAbs(f64, expm1_64(0.2), 0.221403, epsilon));
	315	expect(math.approxEqAbs(f64, expm1_64(0.8923), 1.440737, epsilon));
	316	expect(math.approxEqAbs(f64, expm1_64(1.5), 3.481689, epsilon));
317	317	}
318	318
319	319	test "math.expm1_32.special" {

lib/std/math/fma.zig+14-14

...	...	@@ -155,23 +155,23 @@ test "math.fma" {
155	155	test "math.fma32" {
156	156	const epsilon = 0.000001;
157	157
158		expect(math.approxEq(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon));
159		expect(math.approxEq(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon));
160		expect(math.approxEq(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon));
161		expect(math.approxEq(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon));
162		expect(math.approxEq(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon));
163		expect(math.approxEq(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon));
164		expect(math.approxEq(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
	158	expect(math.approxEqAbs(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon));
	159	expect(math.approxEqAbs(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon));
	160	expect(math.approxEqAbs(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon));
	161	expect(math.approxEqAbs(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon));
	162	expect(math.approxEqAbs(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon));
	163	expect(math.approxEqAbs(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon));
	164	expect(math.approxEqAbs(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
165	165	}
166	166
167	167	test "math.fma64" {
168	168	const epsilon = 0.000001;
169	169
170		expect(math.approxEq(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon));
171		expect(math.approxEq(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon));
172		expect(math.approxEq(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon));
173		expect(math.approxEq(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon));
174		expect(math.approxEq(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon));
175		expect(math.approxEq(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon));
176		expect(math.approxEq(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
	170	expect(math.approxEqAbs(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon));
	171	expect(math.approxEqAbs(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon));
	172	expect(math.approxEqAbs(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon));
	173	expect(math.approxEqAbs(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon));
	174	expect(math.approxEqAbs(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon));
	175	expect(math.approxEqAbs(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon));
	176	expect(math.approxEqAbs(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
177	177	}

lib/std/math/frexp.zig+4-4

...	...	@@ -127,10 +127,10 @@ test "math.frexp32" {
127	127	var r: frexp32_result = undefined;
128	128
129	129	r = frexp32(1.3);
130		expect(math.approxEq(f32, r.significand, 0.65, epsilon) and r.exponent == 1);
	130	expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1);
131	131
132	132	r = frexp32(78.0234);
133		expect(math.approxEq(f32, r.significand, 0.609558, epsilon) and r.exponent == 7);
	133	expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7);
134	134	}
135	135
136	136	test "math.frexp64" {
...	...	@@ -138,10 +138,10 @@ test "math.frexp64" {
138	138	var r: frexp64_result = undefined;
139	139
140	140	r = frexp64(1.3);
141		expect(math.approxEq(f64, r.significand, 0.65, epsilon) and r.exponent == 1);
	141	expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1);
142	142
143	143	r = frexp64(78.0234);
144		expect(math.approxEq(f64, r.significand, 0.609558, epsilon) and r.exponent == 7);
	144	expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7);
145	145	}
146	146
147	147	test "math.frexp32.special" {

lib/std/math/hypot.zig+14-14

...	...	@@ -133,25 +133,25 @@ test "math.hypot" {
133	133	test "math.hypot32" {
134	134	const epsilon = 0.000001;
135	135
136		expect(math.approxEq(f32, hypot32(0.0, -1.2), 1.2, epsilon));
137		expect(math.approxEq(f32, hypot32(0.2, -0.34), 0.394462, epsilon));
138		expect(math.approxEq(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon));
139		expect(math.approxEq(f32, hypot32(1.5, 5.25), 5.460083, epsilon));
140		expect(math.approxEq(f32, hypot32(37.45, 159.835), 164.163742, epsilon));
141		expect(math.approxEq(f32, hypot32(89.123, 382.028905), 392.286865, epsilon));
142		expect(math.approxEq(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon));
	136	expect(math.approxEqAbs(f32, hypot32(0.0, -1.2), 1.2, epsilon));
	137	expect(math.approxEqAbs(f32, hypot32(0.2, -0.34), 0.394462, epsilon));
	138	expect(math.approxEqAbs(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon));
	139	expect(math.approxEqAbs(f32, hypot32(1.5, 5.25), 5.460083, epsilon));
	140	expect(math.approxEqAbs(f32, hypot32(37.45, 159.835), 164.163742, epsilon));
	141	expect(math.approxEqAbs(f32, hypot32(89.123, 382.028905), 392.286865, epsilon));
	142	expect(math.approxEqAbs(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon));
143	143	}
144	144
145	145	test "math.hypot64" {
146	146	const epsilon = 0.000001;
147	147
148		expect(math.approxEq(f64, hypot64(0.0, -1.2), 1.2, epsilon));
149		expect(math.approxEq(f64, hypot64(0.2, -0.34), 0.394462, epsilon));
150		expect(math.approxEq(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon));
151		expect(math.approxEq(f64, hypot64(1.5, 5.25), 5.460082, epsilon));
152		expect(math.approxEq(f64, hypot64(37.45, 159.835), 164.163728, epsilon));
153		expect(math.approxEq(f64, hypot64(89.123, 382.028905), 392.286876, epsilon));
154		expect(math.approxEq(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon));
	148	expect(math.approxEqAbs(f64, hypot64(0.0, -1.2), 1.2, epsilon));
	149	expect(math.approxEqAbs(f64, hypot64(0.2, -0.34), 0.394462, epsilon));
	150	expect(math.approxEqAbs(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon));
	151	expect(math.approxEqAbs(f64, hypot64(1.5, 5.25), 5.460082, epsilon));
	152	expect(math.approxEqAbs(f64, hypot64(37.45, 159.835), 164.163728, epsilon));
	153	expect(math.approxEqAbs(f64, hypot64(89.123, 382.028905), 392.286876, epsilon));
	154	expect(math.approxEqAbs(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon));
155	155	}
156	156
157	157	test "math.hypot32.special" {

lib/std/math/ln.zig+12-12

...	...	@@ -159,23 +159,23 @@ test "math.ln" {
159	159	test "math.ln32" {
160	160	const epsilon = 0.000001;
161	161
162		expect(math.approxEq(f32, ln_32(0.2), -1.609438, epsilon));
163		expect(math.approxEq(f32, ln_32(0.8923), -0.113953, epsilon));
164		expect(math.approxEq(f32, ln_32(1.5), 0.405465, epsilon));
165		expect(math.approxEq(f32, ln_32(37.45), 3.623007, epsilon));
166		expect(math.approxEq(f32, ln_32(89.123), 4.490017, epsilon));
167		expect(math.approxEq(f32, ln_32(123123.234375), 11.720941, epsilon));
	162	expect(math.approxEqAbs(f32, ln_32(0.2), -1.609438, epsilon));
	163	expect(math.approxEqAbs(f32, ln_32(0.8923), -0.113953, epsilon));
	164	expect(math.approxEqAbs(f32, ln_32(1.5), 0.405465, epsilon));
	165	expect(math.approxEqAbs(f32, ln_32(37.45), 3.623007, epsilon));
	166	expect(math.approxEqAbs(f32, ln_32(89.123), 4.490017, epsilon));
	167	expect(math.approxEqAbs(f32, ln_32(123123.234375), 11.720941, epsilon));
168	168	}
169	169
170	170	test "math.ln64" {
171	171	const epsilon = 0.000001;
172	172
173		expect(math.approxEq(f64, ln_64(0.2), -1.609438, epsilon));
174		expect(math.approxEq(f64, ln_64(0.8923), -0.113953, epsilon));
175		expect(math.approxEq(f64, ln_64(1.5), 0.405465, epsilon));
176		expect(math.approxEq(f64, ln_64(37.45), 3.623007, epsilon));
177		expect(math.approxEq(f64, ln_64(89.123), 4.490017, epsilon));
178		expect(math.approxEq(f64, ln_64(123123.234375), 11.720941, epsilon));
	173	expect(math.approxEqAbs(f64, ln_64(0.2), -1.609438, epsilon));
	174	expect(math.approxEqAbs(f64, ln_64(0.8923), -0.113953, epsilon));
	175	expect(math.approxEqAbs(f64, ln_64(1.5), 0.405465, epsilon));
	176	expect(math.approxEqAbs(f64, ln_64(37.45), 3.623007, epsilon));
	177	expect(math.approxEqAbs(f64, ln_64(89.123), 4.490017, epsilon));
	178	expect(math.approxEqAbs(f64, ln_64(123123.234375), 11.720941, epsilon));
179	179	}
180	180
181	181	test "math.ln32.special" {

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

...	...	@@ -61,9 +61,9 @@ test "math.log integer" {
61	61	test "math.log float" {
62	62	const epsilon = 0.000001;
63	63
64		expect(math.approxEq(f32, log(f32, 6, 0.23947), -0.797723, epsilon));
65		expect(math.approxEq(f32, log(f32, 89, 0.23947), -0.318432, epsilon));
66		expect(math.approxEq(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon));
	64	expect(math.approxEqAbs(f32, log(f32, 6, 0.23947), -0.797723, epsilon));
	65	expect(math.approxEqAbs(f32, log(f32, 89, 0.23947), -0.318432, epsilon));
	66	expect(math.approxEqAbs(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon));
67	67	}
68	68
69	69	test "math.log float_special" {

lib/std/math/log10.zig+12-12

...	...	@@ -187,23 +187,23 @@ test "math.log10" {
187	187	test "math.log10_32" {
188	188	const epsilon = 0.000001;
189	189
190		testing.expect(math.approxEq(f32, log10_32(0.2), -0.698970, epsilon));
191		testing.expect(math.approxEq(f32, log10_32(0.8923), -0.049489, epsilon));
192		testing.expect(math.approxEq(f32, log10_32(1.5), 0.176091, epsilon));
193		testing.expect(math.approxEq(f32, log10_32(37.45), 1.573452, epsilon));
194		testing.expect(math.approxEq(f32, log10_32(89.123), 1.94999, epsilon));
195		testing.expect(math.approxEq(f32, log10_32(123123.234375), 5.09034, epsilon));
	190	testing.expect(math.approxEqAbs(f32, log10_32(0.2), -0.698970, epsilon));
	191	testing.expect(math.approxEqAbs(f32, log10_32(0.8923), -0.049489, epsilon));
	192	testing.expect(math.approxEqAbs(f32, log10_32(1.5), 0.176091, epsilon));
	193	testing.expect(math.approxEqAbs(f32, log10_32(37.45), 1.573452, epsilon));
	194	testing.expect(math.approxEqAbs(f32, log10_32(89.123), 1.94999, epsilon));
	195	testing.expect(math.approxEqAbs(f32, log10_32(123123.234375), 5.09034, epsilon));
196	196	}
197	197
198	198	test "math.log10_64" {
199	199	const epsilon = 0.000001;
200	200
201		testing.expect(math.approxEq(f64, log10_64(0.2), -0.698970, epsilon));
202		testing.expect(math.approxEq(f64, log10_64(0.8923), -0.049489, epsilon));
203		testing.expect(math.approxEq(f64, log10_64(1.5), 0.176091, epsilon));
204		testing.expect(math.approxEq(f64, log10_64(37.45), 1.573452, epsilon));
205		testing.expect(math.approxEq(f64, log10_64(89.123), 1.94999, epsilon));
206		testing.expect(math.approxEq(f64, log10_64(123123.234375), 5.09034, epsilon));
	201	testing.expect(math.approxEqAbs(f64, log10_64(0.2), -0.698970, epsilon));
	202	testing.expect(math.approxEqAbs(f64, log10_64(0.8923), -0.049489, epsilon));
	203	testing.expect(math.approxEqAbs(f64, log10_64(1.5), 0.176091, epsilon));
	204	testing.expect(math.approxEqAbs(f64, log10_64(37.45), 1.573452, epsilon));
	205	testing.expect(math.approxEqAbs(f64, log10_64(89.123), 1.94999, epsilon));
	206	testing.expect(math.approxEqAbs(f64, log10_64(123123.234375), 5.09034, epsilon));
207	207	}
208	208
209	209	test "math.log10_32.special" {

lib/std/math/log1p.zig+14-14

...	...	@@ -195,25 +195,25 @@ test "math.log1p" {
195	195	test "math.log1p_32" {
196	196	const epsilon = 0.000001;
197	197
198		expect(math.approxEq(f32, log1p_32(0.0), 0.0, epsilon));
199		expect(math.approxEq(f32, log1p_32(0.2), 0.182322, epsilon));
200		expect(math.approxEq(f32, log1p_32(0.8923), 0.637793, epsilon));
201		expect(math.approxEq(f32, log1p_32(1.5), 0.916291, epsilon));
202		expect(math.approxEq(f32, log1p_32(37.45), 3.649359, epsilon));
203		expect(math.approxEq(f32, log1p_32(89.123), 4.501175, epsilon));
204		expect(math.approxEq(f32, log1p_32(123123.234375), 11.720949, epsilon));
	198	expect(math.approxEqAbs(f32, log1p_32(0.0), 0.0, epsilon));
	199	expect(math.approxEqAbs(f32, log1p_32(0.2), 0.182322, epsilon));
	200	expect(math.approxEqAbs(f32, log1p_32(0.8923), 0.637793, epsilon));
	201	expect(math.approxEqAbs(f32, log1p_32(1.5), 0.916291, epsilon));
	202	expect(math.approxEqAbs(f32, log1p_32(37.45), 3.649359, epsilon));
	203	expect(math.approxEqAbs(f32, log1p_32(89.123), 4.501175, epsilon));
	204	expect(math.approxEqAbs(f32, log1p_32(123123.234375), 11.720949, epsilon));
205	205	}
206	206
207	207	test "math.log1p_64" {
208	208	const epsilon = 0.000001;
209	209
210		expect(math.approxEq(f64, log1p_64(0.0), 0.0, epsilon));
211		expect(math.approxEq(f64, log1p_64(0.2), 0.182322, epsilon));
212		expect(math.approxEq(f64, log1p_64(0.8923), 0.637793, epsilon));
213		expect(math.approxEq(f64, log1p_64(1.5), 0.916291, epsilon));
214		expect(math.approxEq(f64, log1p_64(37.45), 3.649359, epsilon));
215		expect(math.approxEq(f64, log1p_64(89.123), 4.501175, epsilon));
216		expect(math.approxEq(f64, log1p_64(123123.234375), 11.720949, epsilon));
	210	expect(math.approxEqAbs(f64, log1p_64(0.0), 0.0, epsilon));
	211	expect(math.approxEqAbs(f64, log1p_64(0.2), 0.182322, epsilon));
	212	expect(math.approxEqAbs(f64, log1p_64(0.8923), 0.637793, epsilon));
	213	expect(math.approxEqAbs(f64, log1p_64(1.5), 0.916291, epsilon));
	214	expect(math.approxEqAbs(f64, log1p_64(37.45), 3.649359, epsilon));
	215	expect(math.approxEqAbs(f64, log1p_64(89.123), 4.501175, epsilon));
	216	expect(math.approxEqAbs(f64, log1p_64(123123.234375), 11.720949, epsilon));
217	217	}
218	218
219	219	test "math.log1p_32.special" {

lib/std/math/log2.zig+10-10

...	...	@@ -185,21 +185,21 @@ test "math.log2" {
185	185	test "math.log2_32" {
186	186	const epsilon = 0.000001;
187	187
188		expect(math.approxEq(f32, log2_32(0.2), -2.321928, epsilon));
189		expect(math.approxEq(f32, log2_32(0.8923), -0.164399, epsilon));
190		expect(math.approxEq(f32, log2_32(1.5), 0.584962, epsilon));
191		expect(math.approxEq(f32, log2_32(37.45), 5.226894, epsilon));
192		expect(math.approxEq(f32, log2_32(123123.234375), 16.909744, epsilon));
	188	expect(math.approxEqAbs(f32, log2_32(0.2), -2.321928, epsilon));
	189	expect(math.approxEqAbs(f32, log2_32(0.8923), -0.164399, epsilon));
	190	expect(math.approxEqAbs(f32, log2_32(1.5), 0.584962, epsilon));
	191	expect(math.approxEqAbs(f32, log2_32(37.45), 5.226894, epsilon));
	192	expect(math.approxEqAbs(f32, log2_32(123123.234375), 16.909744, epsilon));
193	193	}
194	194
195	195	test "math.log2_64" {
196	196	const epsilon = 0.000001;
197	197
198		expect(math.approxEq(f64, log2_64(0.2), -2.321928, epsilon));
199		expect(math.approxEq(f64, log2_64(0.8923), -0.164399, epsilon));
200		expect(math.approxEq(f64, log2_64(1.5), 0.584962, epsilon));
201		expect(math.approxEq(f64, log2_64(37.45), 5.226894, epsilon));
202		expect(math.approxEq(f64, log2_64(123123.234375), 16.909744, epsilon));
	198	expect(math.approxEqAbs(f64, log2_64(0.2), -2.321928, epsilon));
	199	expect(math.approxEqAbs(f64, log2_64(0.8923), -0.164399, epsilon));
	200	expect(math.approxEqAbs(f64, log2_64(1.5), 0.584962, epsilon));
	201	expect(math.approxEqAbs(f64, log2_64(37.45), 5.226894, epsilon));
	202	expect(math.approxEqAbs(f64, log2_64(123123.234375), 16.909744, epsilon));
203	203	}
204	204
205	205	test "math.log2_32.special" {

lib/std/math/modf.zig+20-20

...	...	@@ -143,24 +143,24 @@ test "math.modf32" {
143	143	var r: modf32_result = undefined;
144	144
145	145	r = modf32(1.0);
146		expect(math.approxEq(f32, r.ipart, 1.0, epsilon));
147		expect(math.approxEq(f32, r.fpart, 0.0, epsilon));
	146	expect(math.approxEqAbs(f32, r.ipart, 1.0, epsilon));
	147	expect(math.approxEqAbs(f32, r.fpart, 0.0, epsilon));
148	148
149	149	r = modf32(2.545);
150		expect(math.approxEq(f32, r.ipart, 2.0, epsilon));
151		expect(math.approxEq(f32, r.fpart, 0.545, epsilon));
	150	expect(math.approxEqAbs(f32, r.ipart, 2.0, epsilon));
	151	expect(math.approxEqAbs(f32, r.fpart, 0.545, epsilon));
152	152
153	153	r = modf32(3.978123);
154		expect(math.approxEq(f32, r.ipart, 3.0, epsilon));
155		expect(math.approxEq(f32, r.fpart, 0.978123, epsilon));
	154	expect(math.approxEqAbs(f32, r.ipart, 3.0, epsilon));
	155	expect(math.approxEqAbs(f32, r.fpart, 0.978123, epsilon));
156	156
157	157	r = modf32(43874.3);
158		expect(math.approxEq(f32, r.ipart, 43874, epsilon));
159		expect(math.approxEq(f32, r.fpart, 0.300781, epsilon));
	158	expect(math.approxEqAbs(f32, r.ipart, 43874, epsilon));
	159	expect(math.approxEqAbs(f32, r.fpart, 0.300781, epsilon));
160	160
161	161	r = modf32(1234.340780);
162		expect(math.approxEq(f32, r.ipart, 1234, epsilon));
163		expect(math.approxEq(f32, r.fpart, 0.340820, epsilon));
	162	expect(math.approxEqAbs(f32, r.ipart, 1234, epsilon));
	163	expect(math.approxEqAbs(f32, r.fpart, 0.340820, epsilon));
164	164	}
165	165
166	166	test "math.modf64" {
...	...	@@ -168,24 +168,24 @@ test "math.modf64" {
168	168	var r: modf64_result = undefined;
169	169
170	170	r = modf64(1.0);
171		expect(math.approxEq(f64, r.ipart, 1.0, epsilon));
172		expect(math.approxEq(f64, r.fpart, 0.0, epsilon));
	171	expect(math.approxEqAbs(f64, r.ipart, 1.0, epsilon));
	172	expect(math.approxEqAbs(f64, r.fpart, 0.0, epsilon));
173	173
174	174	r = modf64(2.545);
175		expect(math.approxEq(f64, r.ipart, 2.0, epsilon));
176		expect(math.approxEq(f64, r.fpart, 0.545, epsilon));
	175	expect(math.approxEqAbs(f64, r.ipart, 2.0, epsilon));
	176	expect(math.approxEqAbs(f64, r.fpart, 0.545, epsilon));
177	177
178	178	r = modf64(3.978123);
179		expect(math.approxEq(f64, r.ipart, 3.0, epsilon));
180		expect(math.approxEq(f64, r.fpart, 0.978123, epsilon));
	179	expect(math.approxEqAbs(f64, r.ipart, 3.0, epsilon));
	180	expect(math.approxEqAbs(f64, r.fpart, 0.978123, epsilon));
181	181
182	182	r = modf64(43874.3);
183		expect(math.approxEq(f64, r.ipart, 43874, epsilon));
184		expect(math.approxEq(f64, r.fpart, 0.3, epsilon));
	183	expect(math.approxEqAbs(f64, r.ipart, 43874, epsilon));
	184	expect(math.approxEqAbs(f64, r.fpart, 0.3, epsilon));
185	185
186	186	r = modf64(1234.340780);
187		expect(math.approxEq(f64, r.ipart, 1234, epsilon));
188		expect(math.approxEq(f64, r.fpart, 0.340780, epsilon));
	187	expect(math.approxEqAbs(f64, r.ipart, 1234, epsilon));
	188	expect(math.approxEqAbs(f64, r.fpart, 0.340780, epsilon));
189	189	}
190	190
191	191	test "math.modf32.special" {

lib/std/math/pow.zig+14-14

...	...	@@ -191,19 +191,19 @@ fn isOddInteger(x: f64) bool {
191	191	test "math.pow" {
192	192	const epsilon = 0.000001;
193	193
194		expect(math.approxEq(f32, pow(f32, 0.0, 3.3), 0.0, epsilon));
195		expect(math.approxEq(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon));
196		expect(math.approxEq(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon));
197		expect(math.approxEq(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon));
198		expect(math.approxEq(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon));
199		expect(math.approxEq(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon));
	194	expect(math.approxEqAbs(f32, pow(f32, 0.0, 3.3), 0.0, epsilon));
	195	expect(math.approxEqAbs(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon));
	196	expect(math.approxEqAbs(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon));
	197	expect(math.approxEqAbs(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon));
	198	expect(math.approxEqAbs(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon));
	199	expect(math.approxEqAbs(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon));
200	200
201		expect(math.approxEq(f64, pow(f64, 0.0, 3.3), 0.0, epsilon));
202		expect(math.approxEq(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon));
203		expect(math.approxEq(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon));
204		expect(math.approxEq(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon));
205		expect(math.approxEq(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon));
206		expect(math.approxEq(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon));
	201	expect(math.approxEqAbs(f64, pow(f64, 0.0, 3.3), 0.0, epsilon));
	202	expect(math.approxEqAbs(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon));
	203	expect(math.approxEqAbs(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon));
	204	expect(math.approxEqAbs(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon));
	205	expect(math.approxEqAbs(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon));
	206	expect(math.approxEqAbs(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon));
207	207	}
208	208
209	209	test "math.pow.special" {
...	...	@@ -230,8 +230,8 @@ test "math.pow.special" {
230	230	expect(pow(f32, -0.0, 1.0) == -0.0);
231	231	expect(pow(f32, 0.0, 2.0) == 0.0);
232	232	expect(pow(f32, -0.0, 2.0) == 0.0);
233		expect(math.approxEq(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon));
234		expect(math.approxEq(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon));
	233	expect(math.approxEqAbs(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon));
	234	expect(math.approxEqAbs(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon));
235	235	expect(math.isPositiveInf(pow(f32, 1.2, math.inf(f32))));
236	236	expect(math.isPositiveInf(pow(f32, -1.2, math.inf(f32))));
237	237	expect(pow(f32, 1.2, -math.inf(f32)) == 0.0);

lib/std/math/sin.zig+14-14

...	...	@@ -97,25 +97,25 @@ test "math.sin" {
97	97	test "math.sin32" {
98	98	const epsilon = 0.000001;
99	99
100		expect(math.approxEq(f32, sin_(f32, 0.0), 0.0, epsilon));
101		expect(math.approxEq(f32, sin_(f32, 0.2), 0.198669, epsilon));
102		expect(math.approxEq(f32, sin_(f32, 0.8923), 0.778517, epsilon));
103		expect(math.approxEq(f32, sin_(f32, 1.5), 0.997495, epsilon));
104		expect(math.approxEq(f32, sin_(f32, -1.5), -0.997495, epsilon));
105		expect(math.approxEq(f32, sin_(f32, 37.45), -0.246544, epsilon));
106		expect(math.approxEq(f32, sin_(f32, 89.123), 0.916166, epsilon));
	100	expect(math.approxEqAbs(f32, sin_(f32, 0.0), 0.0, epsilon));
	101	expect(math.approxEqAbs(f32, sin_(f32, 0.2), 0.198669, epsilon));
	102	expect(math.approxEqAbs(f32, sin_(f32, 0.8923), 0.778517, epsilon));
	103	expect(math.approxEqAbs(f32, sin_(f32, 1.5), 0.997495, epsilon));
	104	expect(math.approxEqAbs(f32, sin_(f32, -1.5), -0.997495, epsilon));
	105	expect(math.approxEqAbs(f32, sin_(f32, 37.45), -0.246544, epsilon));
	106	expect(math.approxEqAbs(f32, sin_(f32, 89.123), 0.916166, epsilon));
107	107	}
108	108
109	109	test "math.sin64" {
110	110	const epsilon = 0.000001;
111	111
112		expect(math.approxEq(f64, sin_(f64, 0.0), 0.0, epsilon));
113		expect(math.approxEq(f64, sin_(f64, 0.2), 0.198669, epsilon));
114		expect(math.approxEq(f64, sin_(f64, 0.8923), 0.778517, epsilon));
115		expect(math.approxEq(f64, sin_(f64, 1.5), 0.997495, epsilon));
116		expect(math.approxEq(f64, sin_(f64, -1.5), -0.997495, epsilon));
117		expect(math.approxEq(f64, sin_(f64, 37.45), -0.246543, epsilon));
118		expect(math.approxEq(f64, sin_(f64, 89.123), 0.916166, epsilon));
	112	expect(math.approxEqAbs(f64, sin_(f64, 0.0), 0.0, epsilon));
	113	expect(math.approxEqAbs(f64, sin_(f64, 0.2), 0.198669, epsilon));
	114	expect(math.approxEqAbs(f64, sin_(f64, 0.8923), 0.778517, epsilon));
	115	expect(math.approxEqAbs(f64, sin_(f64, 1.5), 0.997495, epsilon));
	116	expect(math.approxEqAbs(f64, sin_(f64, -1.5), -0.997495, epsilon));
	117	expect(math.approxEqAbs(f64, sin_(f64, 37.45), -0.246543, epsilon));
	118	expect(math.approxEqAbs(f64, sin_(f64, 89.123), 0.916166, epsilon));
119	119	}
120	120
121	121	test "math.sin32.special" {

lib/std/math/sinh.zig+16-16

...	...	@@ -105,27 +105,27 @@ test "math.sinh" {
105	105	test "math.sinh32" {
106	106	const epsilon = 0.000001;
107	107
108		expect(math.approxEq(f32, sinh32(0.0), 0.0, epsilon));
109		expect(math.approxEq(f32, sinh32(0.2), 0.201336, epsilon));
110		expect(math.approxEq(f32, sinh32(0.8923), 1.015512, epsilon));
111		expect(math.approxEq(f32, sinh32(1.5), 2.129279, epsilon));
112		expect(math.approxEq(f32, sinh32(-0.0), -0.0, epsilon));
113		expect(math.approxEq(f32, sinh32(-0.2), -0.201336, epsilon));
114		expect(math.approxEq(f32, sinh32(-0.8923), -1.015512, epsilon));
115		expect(math.approxEq(f32, sinh32(-1.5), -2.129279, epsilon));
	108	expect(math.approxEqAbs(f32, sinh32(0.0), 0.0, epsilon));
	109	expect(math.approxEqAbs(f32, sinh32(0.2), 0.201336, epsilon));
	110	expect(math.approxEqAbs(f32, sinh32(0.8923), 1.015512, epsilon));
	111	expect(math.approxEqAbs(f32, sinh32(1.5), 2.129279, epsilon));
	112	expect(math.approxEqAbs(f32, sinh32(-0.0), -0.0, epsilon));
	113	expect(math.approxEqAbs(f32, sinh32(-0.2), -0.201336, epsilon));
	114	expect(math.approxEqAbs(f32, sinh32(-0.8923), -1.015512, epsilon));
	115	expect(math.approxEqAbs(f32, sinh32(-1.5), -2.129279, epsilon));
116	116	}
117	117
118	118	test "math.sinh64" {
119	119	const epsilon = 0.000001;
120	120
121		expect(math.approxEq(f64, sinh64(0.0), 0.0, epsilon));
122		expect(math.approxEq(f64, sinh64(0.2), 0.201336, epsilon));
123		expect(math.approxEq(f64, sinh64(0.8923), 1.015512, epsilon));
124		expect(math.approxEq(f64, sinh64(1.5), 2.129279, epsilon));
125		expect(math.approxEq(f64, sinh64(-0.0), -0.0, epsilon));
126		expect(math.approxEq(f64, sinh64(-0.2), -0.201336, epsilon));
127		expect(math.approxEq(f64, sinh64(-0.8923), -1.015512, epsilon));
128		expect(math.approxEq(f64, sinh64(-1.5), -2.129279, epsilon));
	121	expect(math.approxEqAbs(f64, sinh64(0.0), 0.0, epsilon));
	122	expect(math.approxEqAbs(f64, sinh64(0.2), 0.201336, epsilon));
	123	expect(math.approxEqAbs(f64, sinh64(0.8923), 1.015512, epsilon));
	124	expect(math.approxEqAbs(f64, sinh64(1.5), 2.129279, epsilon));
	125	expect(math.approxEqAbs(f64, sinh64(-0.0), -0.0, epsilon));
	126	expect(math.approxEqAbs(f64, sinh64(-0.2), -0.201336, epsilon));
	127	expect(math.approxEqAbs(f64, sinh64(-0.8923), -1.015512, epsilon));
	128	expect(math.approxEqAbs(f64, sinh64(-1.5), -2.129279, epsilon));
129	129	}
130	130
131	131	test "math.sinh32.special" {

lib/std/math/tan.zig+12-12

...	...	@@ -87,23 +87,23 @@ test "math.tan" {
87	87	test "math.tan32" {
88	88	const epsilon = 0.000001;
89	89
90		expect(math.approxEq(f32, tan_(f32, 0.0), 0.0, epsilon));
91		expect(math.approxEq(f32, tan_(f32, 0.2), 0.202710, epsilon));
92		expect(math.approxEq(f32, tan_(f32, 0.8923), 1.240422, epsilon));
93		expect(math.approxEq(f32, tan_(f32, 1.5), 14.101420, epsilon));
94		expect(math.approxEq(f32, tan_(f32, 37.45), -0.254397, epsilon));
95		expect(math.approxEq(f32, tan_(f32, 89.123), 2.285852, epsilon));
	90	expect(math.approxEqAbs(f32, tan_(f32, 0.0), 0.0, epsilon));
	91	expect(math.approxEqAbs(f32, tan_(f32, 0.2), 0.202710, epsilon));
	92	expect(math.approxEqAbs(f32, tan_(f32, 0.8923), 1.240422, epsilon));
	93	expect(math.approxEqAbs(f32, tan_(f32, 1.5), 14.101420, epsilon));
	94	expect(math.approxEqAbs(f32, tan_(f32, 37.45), -0.254397, epsilon));
	95	expect(math.approxEqAbs(f32, tan_(f32, 89.123), 2.285852, epsilon));
96	96	}
97	97
98	98	test "math.tan64" {
99	99	const epsilon = 0.000001;
100	100
101		expect(math.approxEq(f64, tan_(f64, 0.0), 0.0, epsilon));
102		expect(math.approxEq(f64, tan_(f64, 0.2), 0.202710, epsilon));
103		expect(math.approxEq(f64, tan_(f64, 0.8923), 1.240422, epsilon));
104		expect(math.approxEq(f64, tan_(f64, 1.5), 14.101420, epsilon));
105		expect(math.approxEq(f64, tan_(f64, 37.45), -0.254397, epsilon));
106		expect(math.approxEq(f64, tan_(f64, 89.123), 2.2858376, epsilon));
	101	expect(math.approxEqAbs(f64, tan_(f64, 0.0), 0.0, epsilon));
	102	expect(math.approxEqAbs(f64, tan_(f64, 0.2), 0.202710, epsilon));
	103	expect(math.approxEqAbs(f64, tan_(f64, 0.8923), 1.240422, epsilon));
	104	expect(math.approxEqAbs(f64, tan_(f64, 1.5), 14.101420, epsilon));
	105	expect(math.approxEqAbs(f64, tan_(f64, 37.45), -0.254397, epsilon));
	106	expect(math.approxEqAbs(f64, tan_(f64, 89.123), 2.2858376, epsilon));
107	107	}
108	108
109	109	test "math.tan32.special" {

lib/std/math/tanh.zig+10-10

...	...	@@ -131,21 +131,21 @@ test "math.tanh" {
131	131	test "math.tanh32" {
132	132	const epsilon = 0.000001;
133	133
134		expect(math.approxEq(f32, tanh32(0.0), 0.0, epsilon));
135		expect(math.approxEq(f32, tanh32(0.2), 0.197375, epsilon));
136		expect(math.approxEq(f32, tanh32(0.8923), 0.712528, epsilon));
137		expect(math.approxEq(f32, tanh32(1.5), 0.905148, epsilon));
138		expect(math.approxEq(f32, tanh32(37.45), 1.0, epsilon));
	134	expect(math.approxEqAbs(f32, tanh32(0.0), 0.0, epsilon));
	135	expect(math.approxEqAbs(f32, tanh32(0.2), 0.197375, epsilon));
	136	expect(math.approxEqAbs(f32, tanh32(0.8923), 0.712528, epsilon));
	137	expect(math.approxEqAbs(f32, tanh32(1.5), 0.905148, epsilon));
	138	expect(math.approxEqAbs(f32, tanh32(37.45), 1.0, epsilon));
139	139	}
140	140
141	141	test "math.tanh64" {
142	142	const epsilon = 0.000001;
143	143
144		expect(math.approxEq(f64, tanh64(0.0), 0.0, epsilon));
145		expect(math.approxEq(f64, tanh64(0.2), 0.197375, epsilon));
146		expect(math.approxEq(f64, tanh64(0.8923), 0.712528, epsilon));
147		expect(math.approxEq(f64, tanh64(1.5), 0.905148, epsilon));
148		expect(math.approxEq(f64, tanh64(37.45), 1.0, epsilon));
	144	expect(math.approxEqAbs(f64, tanh64(0.0), 0.0, epsilon));
	145	expect(math.approxEqAbs(f64, tanh64(0.2), 0.197375, epsilon));
	146	expect(math.approxEqAbs(f64, tanh64(0.8923), 0.712528, epsilon));
	147	expect(math.approxEqAbs(f64, tanh64(1.5), 0.905148, epsilon));
	148	expect(math.approxEqAbs(f64, tanh64(37.45), 1.0, epsilon));
149	149	}
150	150
151	151	test "math.tanh32.special" {

lib/std/special/c.zig+12-12

...	...	@@ -912,14 +912,14 @@ test "sqrt" {
912	912	const epsilon = 0.000001;
913	913
914	914	std.testing.expect(sqrt(0.0) == 0.0);
915		std.testing.expect(std.math.approxEq(f64, sqrt(2.0), 1.414214, epsilon));
916		std.testing.expect(std.math.approxEq(f64, sqrt(3.6), 1.897367, epsilon));
	915	std.testing.expect(std.math.approxEqAbs(f64, sqrt(2.0), 1.414214, epsilon));
	916	std.testing.expect(std.math.approxEqAbs(f64, sqrt(3.6), 1.897367, epsilon));
917	917	std.testing.expect(sqrt(4.0) == 2.0);
918		std.testing.expect(std.math.approxEq(f64, sqrt(7.539840), 2.745877, epsilon));
919		std.testing.expect(std.math.approxEq(f64, sqrt(19.230934), 4.385309, epsilon));
	918	std.testing.expect(std.math.approxEqAbs(f64, sqrt(7.539840), 2.745877, epsilon));
	919	std.testing.expect(std.math.approxEqAbs(f64, sqrt(19.230934), 4.385309, epsilon));
920	920	std.testing.expect(sqrt(64.0) == 8.0);
921		std.testing.expect(std.math.approxEq(f64, sqrt(64.1), 8.006248, epsilon));
922		std.testing.expect(std.math.approxEq(f64, sqrt(8942.230469), 94.563367, epsilon));
	921	std.testing.expect(std.math.approxEqAbs(f64, sqrt(64.1), 8.006248, epsilon));
	922	std.testing.expect(std.math.approxEqAbs(f64, sqrt(8942.230469), 94.563367, epsilon));
923	923	}
924	924
925	925	test "sqrt special" {
...	...	@@ -1010,14 +1010,14 @@ test "sqrtf" {
1010	1010	const epsilon = 0.000001;
1011	1011
1012	1012	std.testing.expect(sqrtf(0.0) == 0.0);
1013		std.testing.expect(std.math.approxEq(f32, sqrtf(2.0), 1.414214, epsilon));
1014		std.testing.expect(std.math.approxEq(f32, sqrtf(3.6), 1.897367, epsilon));
	1013	std.testing.expect(std.math.approxEqAbs(f32, sqrtf(2.0), 1.414214, epsilon));
	1014	std.testing.expect(std.math.approxEqAbs(f32, sqrtf(3.6), 1.897367, epsilon));
1015	1015	std.testing.expect(sqrtf(4.0) == 2.0);
1016		std.testing.expect(std.math.approxEq(f32, sqrtf(7.539840), 2.745877, epsilon));
1017		std.testing.expect(std.math.approxEq(f32, sqrtf(19.230934), 4.385309, epsilon));
	1016	std.testing.expect(std.math.approxEqAbs(f32, sqrtf(7.539840), 2.745877, epsilon));
	1017	std.testing.expect(std.math.approxEqAbs(f32, sqrtf(19.230934), 4.385309, epsilon));
1018	1018	std.testing.expect(sqrtf(64.0) == 8.0);
1019		std.testing.expect(std.math.approxEq(f32, sqrtf(64.1), 8.006248, epsilon));
1020		std.testing.expect(std.math.approxEq(f32, sqrtf(8942.230469), 94.563370, epsilon));
	1019	std.testing.expect(std.math.approxEqAbs(f32, sqrtf(64.1), 8.006248, epsilon));
	1020	std.testing.expect(std.math.approxEqAbs(f32, sqrtf(8942.230469), 94.563370, epsilon));
1021	1021	}
1022	1022
1023	1023	test "sqrtf special" {

test/stage1/behavior/floatop.zig+56-56

...	...	@@ -21,7 +21,7 @@ fn testSqrt() void {
21	21	var a: f32 = 9;
22	22	expect(@sqrt(a) == 3);
23	23	var b: f32 = 1.1;
24		expect(math.approxEq(f32, @sqrt(b), 1.0488088481701516, epsilon));
	24	expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon));
25	25	}
26	26	{
27	27	var a: f64 = 25;
...	...	@@ -39,24 +39,24 @@ fn testSqrt() void {
39	39	{
40	40	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
41	41	var result = @sqrt(v);
42		expect(math.approxEq(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
43		expect(math.approxEq(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
44		expect(math.approxEq(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
45		expect(math.approxEq(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
	42	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
	43	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
	44	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
	45	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
46	46	}
47	47	}
48	48
49	49	test "more @sqrt f16 tests" {
50	50	// TODO these are not all passing at comptime
51	51	expect(@sqrt(@as(f16, 0.0)) == 0.0);
52		expect(math.approxEq(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
53		expect(math.approxEq(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
	52	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
	53	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
54	54	expect(@sqrt(@as(f16, 4.0)) == 2.0);
55		expect(math.approxEq(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
56		expect(math.approxEq(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
	55	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
	56	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
57	57	expect(@sqrt(@as(f16, 64.0)) == 8.0);
58		expect(math.approxEq(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
59		expect(math.approxEq(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
	58	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
	59	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
60	60
61	61	// special cases
62	62	expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16)))));
...	...	@@ -89,10 +89,10 @@ fn testSin() void {
89	89	{
90	90	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
91	91	var result = @sin(v);
92		expect(math.approxEq(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
93		expect(math.approxEq(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
94		expect(math.approxEq(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
95		expect(math.approxEq(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
	92	expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
	93	expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
	94	expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
	95	expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
96	96	}
97	97	}
98	98
...	...	@@ -119,10 +119,10 @@ fn testCos() void {
119	119	{
120	120	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
121	121	var result = @cos(v);
122		expect(math.approxEq(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
123		expect(math.approxEq(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
124		expect(math.approxEq(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
125		expect(math.approxEq(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
	122	expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
	123	expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
	124	expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
	125	expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
126	126	}
127	127	}
128	128
...	...	@@ -149,10 +149,10 @@ fn testExp() void {
149	149	{
150	150	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
151	151	var result = @exp(v);
152		expect(math.approxEq(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
153		expect(math.approxEq(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
154		expect(math.approxEq(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
155		expect(math.approxEq(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
	152	expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
	153	expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
	154	expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
	155	expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
156	156	}
157	157	}
158	158
...	...	@@ -179,10 +179,10 @@ fn testExp2() void {
179	179	{
180	180	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
181	181	var result = @exp2(v);
182		expect(math.approxEq(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
183		expect(math.approxEq(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
184		expect(math.approxEq(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
185		expect(math.approxEq(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
	182	expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
	183	expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
	184	expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
	185	expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
186	186	}
187	187	}
188	188
...	...	@@ -198,7 +198,7 @@ fn testLog() void {
198	198	// https://github.com/ziglang/zig/issues/4026
199	199	{
200	200	var a: f16 = e;
201		expect(math.approxEq(f16, @log(a), 1, epsilon));
	201	expect(math.approxEqAbs(f16, @log(a), 1, epsilon));
202	202	}
203	203	{
204	204	var a: f32 = e;
...	...	@@ -211,10 +211,10 @@ fn testLog() void {
211	211	{
212	212	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
213	213	var result = @log(v);
214		expect(math.approxEq(f32, @log(@as(f32, 1.1)), result[0], epsilon));
215		expect(math.approxEq(f32, @log(@as(f32, 2.2)), result[1], epsilon));
216		expect(math.approxEq(f32, @log(@as(f32, 0.3)), result[2], epsilon));
217		expect(math.approxEq(f32, @log(@as(f32, 0.4)), result[3], epsilon));
	214	expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon));
	215	expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon));
	216	expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon));
	217	expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon));
218	218	}
219	219	}
220	220
...	...	@@ -241,10 +241,10 @@ fn testLog2() void {
241	241	{
242	242	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
243	243	var result = @log2(v);
244		expect(math.approxEq(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
245		expect(math.approxEq(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
246		expect(math.approxEq(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
247		expect(math.approxEq(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
	244	expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
	245	expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
	246	expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
	247	expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
248	248	}
249	249	}
250	250
...	...	@@ -271,10 +271,10 @@ fn testLog10() void {
271	271	{
272	272	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
273	273	var result = @log10(v);
274		expect(math.approxEq(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
275		expect(math.approxEq(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
276		expect(math.approxEq(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
277		expect(math.approxEq(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
	274	expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
	275	expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
	276	expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
	277	expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
278	278	}
279	279	}
280	280
...	...	@@ -307,10 +307,10 @@ fn testFabs() void {
307	307	{
308	308	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
309	309	var result = @fabs(v);
310		expect(math.approxEq(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
311		expect(math.approxEq(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
312		expect(math.approxEq(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
313		expect(math.approxEq(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
	310	expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
	311	expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
	312	expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
	313	expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
314	314	}
315	315	}
316	316
...	...	@@ -337,10 +337,10 @@ fn testFloor() void {
337	337	{
338	338	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
339	339	var result = @floor(v);
340		expect(math.approxEq(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
341		expect(math.approxEq(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
342		expect(math.approxEq(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
343		expect(math.approxEq(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
	340	expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
	341	expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
	342	expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
	343	expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
344	344	}
345	345	}
346	346
...	...	@@ -367,10 +367,10 @@ fn testCeil() void {
367	367	{
368	368	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
369	369	var result = @ceil(v);
370		expect(math.approxEq(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
371		expect(math.approxEq(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
372		expect(math.approxEq(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
373		expect(math.approxEq(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
	370	expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
	371	expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
	372	expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
	373	expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
374	374	}
375	375	}
376	376
...	...	@@ -397,10 +397,10 @@ fn testTrunc() void {
397	397	{
398	398	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
399	399	var result = @trunc(v);
400		expect(math.approxEq(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
401		expect(math.approxEq(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
402		expect(math.approxEq(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
403		expect(math.approxEq(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
	400	expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
	401	expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
	402	expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
	403	expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
404	404	}
405	405	}
406	406