diff --git a/lib/std/fmt/parse_float.zig b/lib/std/fmt/parse_float.zig
index e1b76b8405497c855077e509ca21ba337d08d71f..4396676d9e46c4d7bfc15e19c2a1096c027cf0c1 100644
--- a/lib/std/fmt/parse_float.zig
+++ b/lib/std/fmt/parse_float.zig
@@ -370,7 +370,7 @@ test "fmt.parseFloat" {
     const testing = std.testing;
     const expect = testing.expect;
     const expectEqual = testing.expectEqual;
-    const approxEq = std.math.approxEq;
+    const approxEqAbs = std.math.approxEqAbs;
     const epsilon = 1e-7;
 
     inline for ([_]type{ f16, f32, f64, f128 }) |T| {
@@ -392,8 +392,8 @@ test "fmt.parseFloat" {
         expectEqual(try parseFloat(T, "-1e0"), -1.0);
         expectEqual(try parseFloat(T, "1.234e3"), 1234);
 
-        expect(approxEq(T, try parseFloat(T, "3.141"), 3.141, epsilon));
-        expect(approxEq(T, try parseFloat(T, "-3.141"), -3.141, epsilon));
+        expect(approxEqAbs(T, try parseFloat(T, "3.141"), 3.141, epsilon));
+        expect(approxEqAbs(T, try parseFloat(T, "-3.141"), -3.141, epsilon));
 
         expectEqual(try parseFloat(T, "1e-700"), 0);
         expectEqual(try parseFloat(T, "1e+700"), std.math.inf(T));
@@ -405,13 +405,13 @@ test "fmt.parseFloat" {
         expectEqual(try parseFloat(T, "0.4e0066999999999999999999999999999999999999999999999999999"), std.math.inf(T));
 
         if (T != f16) {
-            expect(approxEq(T, try parseFloat(T, "1e-2"), 0.01, epsilon));
-            expect(approxEq(T, try parseFloat(T, "1234e-2"), 12.34, epsilon));
+            expect(approxEqAbs(T, try parseFloat(T, "1e-2"), 0.01, epsilon));
+            expect(approxEqAbs(T, try parseFloat(T, "1234e-2"), 12.34, epsilon));
 
-            expect(approxEq(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));
-            expect(approxEq(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));
-            expect(approxEq(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));
-            expect(approxEq(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));
+            expect(approxEqAbs(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));
+            expect(approxEqAbs(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));
+            expect(approxEqAbs(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));
+            expect(approxEqAbs(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));
         }
     }
 }
diff --git a/lib/std/math.zig b/lib/std/math.zig
index 10c691741d0d4dfeb9816a7690b18212286f6d01..39b1471e7483f25450684cb10a0827c22f87acf9 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -64,6 +64,8 @@ pub const f16_max = 65504;
 pub const f16_epsilon = 0.0009765625; // 2**-10
 pub const f16_toint = 1.0 / f16_epsilon;
 
+pub const epsilon = @import("math/epsilon.zig").epsilon;
+
 pub const nan_u16 = @as(u16, 0x7C01);
 pub const nan_f16 = @bitCast(f16, nan_u16);
 
@@ -104,9 +106,92 @@ pub const nan = @import("math/nan.zig").nan;
 pub const snan = @import("math/nan.zig").snan;
 pub const inf = @import("math/inf.zig").inf;
 
-pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool {
+/// Performs an approximate comparison of two floating point values `x` and `y`.
+/// Returns true if the absolute difference between them is less or equal than
+/// the specified tolerance.
+///
+/// The `tolerance` parameter is the absolute tolerance used when determining if
+/// the two numbers are close enough, a good value for this parameter is a small
+/// multiple of `epsilon(T)`.
+///
+/// Note that this function is recommended for for comparing small numbers
+/// around zero, using `approxEqRel` is suggested otherwise.
+///
+/// NaN values are never considered equal to any value.
+pub fn approxEqAbs(comptime T: type, x: T, y: T, tolerance: T) bool {
     assert(@typeInfo(T) == .Float);
-    return fabs(x - y) < epsilon;
+    assert(tolerance >= 0);
+
+    // Fast path for equal values (and signed zeros and infinites).
+    if (x == y)
+        return true;
+
+    if (isNan(x) or isNan(y))
+        return false;
+
+    return fabs(x - y) <= tolerance;
+}
+
+/// Performs an approximate comparison of two floating point values `x` and `y`.
+/// Returns true if the absolute difference between them is less or equal than
+/// `max(|x|, |y|) * tolerance`, where `tolerance` is a positive number greater
+/// than zero.
+///
+/// The `tolerance` parameter is the relative tolerance used when determining if
+/// the two numbers are close enough, a good value for this parameter is usually
+/// `sqrt(epsilon(T))`, meaning that the two numbers are considered equal if at
+/// least half of the digits are equal.
+///
+/// Note that for comparisons of small numbers around zero this function won't
+/// give meaningful results, use `approxEqAbs` instead.
+///
+/// NaN values are never considered equal to any value.
+pub fn approxEqRel(comptime T: type, x: T, y: T, tolerance: T) bool {
+    assert(@typeInfo(T) == .Float);
+    assert(tolerance > 0);
+
+    // Fast path for equal values (and signed zeros and infinites).
+    if (x == y)
+        return true;
+
+    if (isNan(x) or isNan(y))
+        return false;
+
+    return fabs(x - y) <= max(fabs(x), fabs(y)) * tolerance;
+}
+
+/// Deprecated, use `approxEqAbs` or `approxEqRel`.
+pub const approxEq = approxEqAbs;
+
+test "approxEqAbs and approxEqRel" {
+    inline for ([_]type{ f16, f32, f64, f128 }) |T| {
+        const eps_value = comptime epsilon(T);
+        const sqrt_eps_value = comptime sqrt(eps_value);
+        const nan_value = comptime nan(T);
+        const inf_value = comptime inf(T);
+        const min_value: T = switch (T) {
+            f16 => f16_min,
+            f32 => f32_min,
+            f64 => f64_min,
+            f128 => f128_min,
+            else => unreachable,
+        };
+
+        testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value));
+        testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value));
+        testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value));
+        testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value));
+        testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value));
+        testing.expect(!approxEqAbs(T, 1.0 + 2 * epsilon(T), 1.0, eps_value));
+        testing.expect(approxEqAbs(T, 1.0 + 1 * epsilon(T), 1.0, eps_value));
+        testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value));
+        testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value));
+        testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value));
+        testing.expect(approxEqRel(T, min_value, min_value, sqrt_eps_value));
+        testing.expect(approxEqRel(T, -min_value, -min_value, sqrt_eps_value));
+        testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2));
+        testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2));
+    }
 }
 
 pub fn doNotOptimizeAway(value: anytype) void {
diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig
index f085680176a3494dd87e8fea41021b02be7bc51f..0153fd68357fa32b4c2691989a5155085682e868 100644
--- a/lib/std/math/acos.zig
+++ b/lib/std/math/acos.zig
@@ -161,23 +161,23 @@ test "math.acos" {
 test "math.acos32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, acos32(0.0), 1.570796, epsilon));
-    expect(math.approxEq(f32, acos32(0.2), 1.369438, epsilon));
-    expect(math.approxEq(f32, acos32(0.3434), 1.220262, epsilon));
-    expect(math.approxEq(f32, acos32(0.5), 1.047198, epsilon));
-    expect(math.approxEq(f32, acos32(0.8923), 0.468382, epsilon));
-    expect(math.approxEq(f32, acos32(-0.2), 1.772154, epsilon));
+    expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon));
+    expect(math.approxEqAbs(f32, acos32(0.2), 1.369438, epsilon));
+    expect(math.approxEqAbs(f32, acos32(0.3434), 1.220262, epsilon));
+    expect(math.approxEqAbs(f32, acos32(0.5), 1.047198, epsilon));
+    expect(math.approxEqAbs(f32, acos32(0.8923), 0.468382, epsilon));
+    expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon));
 }
 
 test "math.acos64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, acos64(0.0), 1.570796, epsilon));
-    expect(math.approxEq(f64, acos64(0.2), 1.369438, epsilon));
-    expect(math.approxEq(f64, acos64(0.3434), 1.220262, epsilon));
-    expect(math.approxEq(f64, acos64(0.5), 1.047198, epsilon));
-    expect(math.approxEq(f64, acos64(0.8923), 0.468382, epsilon));
-    expect(math.approxEq(f64, acos64(-0.2), 1.772154, epsilon));
+    expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon));
+    expect(math.approxEqAbs(f64, acos64(0.2), 1.369438, epsilon));
+    expect(math.approxEqAbs(f64, acos64(0.3434), 1.220262, epsilon));
+    expect(math.approxEqAbs(f64, acos64(0.5), 1.047198, epsilon));
+    expect(math.approxEqAbs(f64, acos64(0.8923), 0.468382, epsilon));
+    expect(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon));
 }
 
 test "math.acos32.special" {
diff --git a/lib/std/math/acosh.zig b/lib/std/math/acosh.zig
index 76d6edff3ec120749b6f57e0746f082c62caaa9e..773b125beacce9d9505c07774843f2d7b8c6a007 100644
--- a/lib/std/math/acosh.zig
+++ b/lib/std/math/acosh.zig
@@ -73,19 +73,19 @@ test "math.acosh" {
 test "math.acosh32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, acosh32(1.5), 0.962424, epsilon));
-    expect(math.approxEq(f32, acosh32(37.45), 4.315976, epsilon));
-    expect(math.approxEq(f32, acosh32(89.123), 5.183133, epsilon));
-    expect(math.approxEq(f32, acosh32(123123.234375), 12.414088, epsilon));
+    expect(math.approxEqAbs(f32, acosh32(1.5), 0.962424, epsilon));
+    expect(math.approxEqAbs(f32, acosh32(37.45), 4.315976, epsilon));
+    expect(math.approxEqAbs(f32, acosh32(89.123), 5.183133, epsilon));
+    expect(math.approxEqAbs(f32, acosh32(123123.234375), 12.414088, epsilon));
 }
 
 test "math.acosh64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, acosh64(1.5), 0.962424, epsilon));
-    expect(math.approxEq(f64, acosh64(37.45), 4.315976, epsilon));
-    expect(math.approxEq(f64, acosh64(89.123), 5.183133, epsilon));
-    expect(math.approxEq(f64, acosh64(123123.234375), 12.414088, epsilon));
+    expect(math.approxEqAbs(f64, acosh64(1.5), 0.962424, epsilon));
+    expect(math.approxEqAbs(f64, acosh64(37.45), 4.315976, epsilon));
+    expect(math.approxEqAbs(f64, acosh64(89.123), 5.183133, epsilon));
+    expect(math.approxEqAbs(f64, acosh64(123123.234375), 12.414088, epsilon));
 }
 
 test "math.acosh32.special" {
diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig
index a4a19c74d97b7248b053ddc86d6eb94397f9f434..38602a76d2aa91cc81ec5983c074ba49515897fe 100644
--- a/lib/std/math/asin.zig
+++ b/lib/std/math/asin.zig
@@ -154,23 +154,23 @@ test "math.asin" {
 test "math.asin32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, asin32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, asin32(0.2), 0.201358, epsilon));
-    expect(math.approxEq(f32, asin32(-0.2), -0.201358, epsilon));
-    expect(math.approxEq(f32, asin32(0.3434), 0.350535, epsilon));
-    expect(math.approxEq(f32, asin32(0.5), 0.523599, epsilon));
-    expect(math.approxEq(f32, asin32(0.8923), 1.102415, epsilon));
+    expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, asin32(0.2), 0.201358, epsilon));
+    expect(math.approxEqAbs(f32, asin32(-0.2), -0.201358, epsilon));
+    expect(math.approxEqAbs(f32, asin32(0.3434), 0.350535, epsilon));
+    expect(math.approxEqAbs(f32, asin32(0.5), 0.523599, epsilon));
+    expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon));
 }
 
 test "math.asin64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, asin64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, asin64(0.2), 0.201358, epsilon));
-    expect(math.approxEq(f64, asin64(-0.2), -0.201358, epsilon));
-    expect(math.approxEq(f64, asin64(0.3434), 0.350535, epsilon));
-    expect(math.approxEq(f64, asin64(0.5), 0.523599, epsilon));
-    expect(math.approxEq(f64, asin64(0.8923), 1.102415, epsilon));
+    expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, asin64(0.2), 0.201358, epsilon));
+    expect(math.approxEqAbs(f64, asin64(-0.2), -0.201358, epsilon));
+    expect(math.approxEqAbs(f64, asin64(0.3434), 0.350535, epsilon));
+    expect(math.approxEqAbs(f64, asin64(0.5), 0.523599, epsilon));
+    expect(math.approxEqAbs(f64, asin64(0.8923), 1.102415, epsilon));
 }
 
 test "math.asin32.special" {
diff --git a/lib/std/math/asinh.zig b/lib/std/math/asinh.zig
index 384834fb37a6fcf502aff6e30f43e1adab1707c3..4dc0702a0a6f96fe6fedc95646731a260542ba31 100644
--- a/lib/std/math/asinh.zig
+++ b/lib/std/math/asinh.zig
@@ -101,25 +101,25 @@ test "math.asinh" {
 test "math.asinh32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, asinh32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, asinh32(0.2), 0.198690, epsilon));
-    expect(math.approxEq(f32, asinh32(0.8923), 0.803133, epsilon));
-    expect(math.approxEq(f32, asinh32(1.5), 1.194763, epsilon));
-    expect(math.approxEq(f32, asinh32(37.45), 4.316332, epsilon));
-    expect(math.approxEq(f32, asinh32(89.123), 5.183196, epsilon));
-    expect(math.approxEq(f32, asinh32(123123.234375), 12.414088, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(0.2), 0.198690, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(0.8923), 0.803133, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(1.5), 1.194763, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(37.45), 4.316332, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(89.123), 5.183196, epsilon));
+    expect(math.approxEqAbs(f32, asinh32(123123.234375), 12.414088, epsilon));
 }
 
 test "math.asinh64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, asinh64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, asinh64(0.2), 0.198690, epsilon));
-    expect(math.approxEq(f64, asinh64(0.8923), 0.803133, epsilon));
-    expect(math.approxEq(f64, asinh64(1.5), 1.194763, epsilon));
-    expect(math.approxEq(f64, asinh64(37.45), 4.316332, epsilon));
-    expect(math.approxEq(f64, asinh64(89.123), 5.183196, epsilon));
-    expect(math.approxEq(f64, asinh64(123123.234375), 12.414088, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(0.2), 0.198690, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(0.8923), 0.803133, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(1.5), 1.194763, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(37.45), 4.316332, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(89.123), 5.183196, epsilon));
+    expect(math.approxEqAbs(f64, asinh64(123123.234375), 12.414088, epsilon));
 }
 
 test "math.asinh32.special" {
diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig
index b3ac880a4800506805de0ae0fe2ed9212ba7c2bf..16083285791b16cae7cdbe4cae5918ed82d5cafe 100644
--- a/lib/std/math/atan.zig
+++ b/lib/std/math/atan.zig
@@ -224,21 +224,21 @@ test "math.atan" {
 test "math.atan32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, atan32(0.2), 0.197396, epsilon));
-    expect(math.approxEq(f32, atan32(-0.2), -0.197396, epsilon));
-    expect(math.approxEq(f32, atan32(0.3434), 0.330783, epsilon));
-    expect(math.approxEq(f32, atan32(0.8923), 0.728545, epsilon));
-    expect(math.approxEq(f32, atan32(1.5), 0.982794, epsilon));
+    expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));
+    expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon));
+    expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon));
+    expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon));
+    expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));
 }
 
 test "math.atan64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, atan64(0.2), 0.197396, epsilon));
-    expect(math.approxEq(f64, atan64(-0.2), -0.197396, epsilon));
-    expect(math.approxEq(f64, atan64(0.3434), 0.330783, epsilon));
-    expect(math.approxEq(f64, atan64(0.8923), 0.728545, epsilon));
-    expect(math.approxEq(f64, atan64(1.5), 0.982794, epsilon));
+    expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));
+    expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon));
+    expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon));
+    expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon));
+    expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));
 }
 
 test "math.atan32.special" {
@@ -246,8 +246,8 @@ test "math.atan32.special" {
 
     expect(atan32(0.0) == 0.0);
     expect(atan32(-0.0) == -0.0);
-    expect(math.approxEq(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
 }
 
 test "math.atan64.special" {
@@ -255,6 +255,6 @@ test "math.atan64.special" {
 
     expect(atan64(0.0) == 0.0);
     expect(atan64(-0.0) == -0.0);
-    expect(math.approxEq(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
 }
diff --git a/lib/std/math/atan2.zig b/lib/std/math/atan2.zig
index 6540eced840e2f8f22bfc2defe05a4a1a912b8f3..cb4c28e71392a468e06fd11696bbc5835c18edaa 100644
--- a/lib/std/math/atan2.zig
+++ b/lib/std/math/atan2.zig
@@ -224,25 +224,25 @@ test "math.atan2" {
 test "math.atan2_32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, atan2_32(0.0, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(0.2, 0.2), 0.785398, epsilon));
-    expect(math.approxEq(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon));
-    expect(math.approxEq(f32, atan2_32(0.2, -0.2), 2.356194, epsilon));
-    expect(math.approxEq(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon));
-    expect(math.approxEq(f32, atan2_32(0.34, -0.4), 2.437099, epsilon));
-    expect(math.approxEq(f32, atan2_32(0.34, 1.243), 0.267001, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(0.0, 0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(0.2, 0.2), 0.785398, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(0.2, -0.2), 2.356194, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(0.34, -0.4), 2.437099, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(0.34, 1.243), 0.267001, epsilon));
 }
 
 test "math.atan2_64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, atan2_64(0.0, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(0.2, 0.2), 0.785398, epsilon));
-    expect(math.approxEq(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon));
-    expect(math.approxEq(f64, atan2_64(0.2, -0.2), 2.356194, epsilon));
-    expect(math.approxEq(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon));
-    expect(math.approxEq(f64, atan2_64(0.34, -0.4), 2.437099, epsilon));
-    expect(math.approxEq(f64, atan2_64(0.34, 1.243), 0.267001, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(0.0, 0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(0.2, 0.2), 0.785398, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(0.2, -0.2), 2.356194, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(0.34, -0.4), 2.437099, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(0.34, 1.243), 0.267001, epsilon));
 }
 
 test "math.atan2_32.special" {
@@ -252,21 +252,21 @@ test "math.atan2_32.special" {
     expect(math.isNan(atan2_32(math.nan(f32), 1.0)));
     expect(atan2_32(0.0, 5.0) == 0.0);
     expect(atan2_32(-0.0, 5.0) == -0.0);
-    expect(math.approxEq(f32, atan2_32(0.0, -5.0), math.pi, epsilon));
-    //expect(math.approxEq(f32, atan2_32(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero?
-    expect(math.approxEq(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(0.0, -5.0), math.pi, epsilon));
+    //expect(math.approxEqAbs(f32, atan2_32(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero?
+    expect(math.approxEqAbs(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon));
     expect(atan2_32(1.0, math.inf(f32)) == 0.0);
-    expect(math.approxEq(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon));
-    expect(math.approxEq(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon));
-    expect(math.approxEq(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon));
 }
 
 test "math.atan2_64.special" {
@@ -276,19 +276,19 @@ test "math.atan2_64.special" {
     expect(math.isNan(atan2_64(math.nan(f64), 1.0)));
     expect(atan2_64(0.0, 5.0) == 0.0);
     expect(atan2_64(-0.0, 5.0) == -0.0);
-    expect(math.approxEq(f64, atan2_64(0.0, -5.0), math.pi, epsilon));
-    //expect(math.approxEq(f64, atan2_64(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero?
-    expect(math.approxEq(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(0.0, -5.0), math.pi, epsilon));
+    //expect(math.approxEqAbs(f64, atan2_64(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero?
+    expect(math.approxEqAbs(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon));
     expect(atan2_64(1.0, math.inf(f64)) == 0.0);
-    expect(math.approxEq(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon));
-    expect(math.approxEq(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon));
-    expect(math.approxEq(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon));
-    expect(math.approxEq(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon));
+    expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon));
 }
diff --git a/lib/std/math/atanh.zig b/lib/std/math/atanh.zig
index 9f72a38ab5e376e80535a392b6e8bf7274d8b119..ffebc58ed49e9d7cc3f120d844df5f32bce2a482 100644
--- a/lib/std/math/atanh.zig
+++ b/lib/std/math/atanh.zig
@@ -96,17 +96,17 @@ test "math.atanh" {
 test "math.atanh_32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, atanh_32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, atanh_32(0.2), 0.202733, epsilon));
-    expect(math.approxEq(f32, atanh_32(0.8923), 1.433099, epsilon));
+    expect(math.approxEqAbs(f32, atanh_32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, atanh_32(0.2), 0.202733, epsilon));
+    expect(math.approxEqAbs(f32, atanh_32(0.8923), 1.433099, epsilon));
 }
 
 test "math.atanh_64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, atanh_64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, atanh_64(0.2), 0.202733, epsilon));
-    expect(math.approxEq(f64, atanh_64(0.8923), 1.433099, epsilon));
+    expect(math.approxEqAbs(f64, atanh_64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, atanh_64(0.2), 0.202733, epsilon));
+    expect(math.approxEqAbs(f64, atanh_64(0.8923), 1.433099, epsilon));
 }
 
 test "math.atanh32.special" {
diff --git a/lib/std/math/cbrt.zig b/lib/std/math/cbrt.zig
index 0d097a0c7562c09b4dbd05ce213a674df0c63b60..c516cae73bf4cf98e2f3efea7194fabdd733e770 100644
--- a/lib/std/math/cbrt.zig
+++ b/lib/std/math/cbrt.zig
@@ -133,22 +133,22 @@ test "math.cbrt32" {
     const epsilon = 0.000001;
 
     expect(cbrt32(0.0) == 0.0);
-    expect(math.approxEq(f32, cbrt32(0.2), 0.584804, epsilon));
-    expect(math.approxEq(f32, cbrt32(0.8923), 0.962728, epsilon));
-    expect(math.approxEq(f32, cbrt32(1.5), 1.144714, epsilon));
-    expect(math.approxEq(f32, cbrt32(37.45), 3.345676, epsilon));
-    expect(math.approxEq(f32, cbrt32(123123.234375), 49.748501, epsilon));
+    expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon));
+    expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon));
+    expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon));
+    expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon));
+    expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon));
 }
 
 test "math.cbrt64" {
     const epsilon = 0.000001;
 
     expect(cbrt64(0.0) == 0.0);
-    expect(math.approxEq(f64, cbrt64(0.2), 0.584804, epsilon));
-    expect(math.approxEq(f64, cbrt64(0.8923), 0.962728, epsilon));
-    expect(math.approxEq(f64, cbrt64(1.5), 1.144714, epsilon));
-    expect(math.approxEq(f64, cbrt64(37.45), 3.345676, epsilon));
-    expect(math.approxEq(f64, cbrt64(123123.234375), 49.748501, epsilon));
+    expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon));
+    expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon));
+    expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon));
+    expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon));
+    expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon));
 }
 
 test "math.cbrt.special" {
diff --git a/lib/std/math/complex.zig b/lib/std/math/complex.zig
index ec76f425ebe043c64c5c772876ab687b80b72f27..f9f13a11614a152570565d3fab87d7f082ef3ecc 100644
--- a/lib/std/math/complex.zig
+++ b/lib/std/math/complex.zig
@@ -138,8 +138,8 @@ test "complex.div" {
     const b = Complex(f32).new(2, 7);
     const c = a.div(b);
 
-    testing.expect(math.approxEq(f32, c.re, @as(f32, 31) / 53, epsilon) and
-        math.approxEq(f32, c.im, @as(f32, -29) / 53, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 31) / 53, epsilon) and
+        math.approxEqAbs(f32, c.im, @as(f32, -29) / 53, epsilon));
 }
 
 test "complex.conjugate" {
@@ -153,15 +153,15 @@ test "complex.reciprocal" {
     const a = Complex(f32).new(5, 3);
     const c = a.reciprocal();
 
-    testing.expect(math.approxEq(f32, c.re, @as(f32, 5) / 34, epsilon) and
-        math.approxEq(f32, c.im, @as(f32, -3) / 34, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 5) / 34, epsilon) and
+        math.approxEqAbs(f32, c.im, @as(f32, -3) / 34, epsilon));
 }
 
 test "complex.magnitude" {
     const a = Complex(f32).new(5, 3);
     const c = a.magnitude();
 
-    testing.expect(math.approxEq(f32, c, 5.83095, epsilon));
+    testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
 }
 
 test "complex.cmath" {
diff --git a/lib/std/math/complex/abs.zig b/lib/std/math/complex/abs.zig
index db9c43e89d10310cc5957fc78914d22e8c3ca702..228b56c28668aa513af2bb557444d5510318117c 100644
--- a/lib/std/math/complex/abs.zig
+++ b/lib/std/math/complex/abs.zig
@@ -20,5 +20,5 @@ const epsilon = 0.0001;
 test "complex.cabs" {
     const a = Complex(f32).new(5, 3);
     const c = abs(a);
-    testing.expect(math.approxEq(f32, c, 5.83095, epsilon));
+    testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
 }
diff --git a/lib/std/math/complex/acos.zig b/lib/std/math/complex/acos.zig
index 1372c280e2c4a33ccb57008762583f3871636063..47130c8a983e875619b1351e3123e0712c8013b9 100644
--- a/lib/std/math/complex/acos.zig
+++ b/lib/std/math/complex/acos.zig
@@ -22,6 +22,6 @@ test "complex.cacos" {
     const a = Complex(f32).new(5, 3);
     const c = acos(a);
 
-    testing.expect(math.approxEq(f32, c.re, 0.546975, epsilon));
-    testing.expect(math.approxEq(f32, c.im, -2.452914, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon));
 }
diff --git a/lib/std/math/complex/acosh.zig b/lib/std/math/complex/acosh.zig
index 49d9fd030240559c2aa37c22c4dde5a4db94ed79..51626b10a4ecf918e8b0404bc375d728588385f3 100644
--- a/lib/std/math/complex/acosh.zig
+++ b/lib/std/math/complex/acosh.zig
@@ -22,6 +22,6 @@ test "complex.cacosh" {
     const a = Complex(f32).new(5, 3);
     const c = acosh(a);
 
-    testing.expect(math.approxEq(f32, c.re, 2.452914, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 0.546975, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon));
 }
diff --git a/lib/std/math/complex/arg.zig b/lib/std/math/complex/arg.zig
index 7cfbc8bd0ff79aa195668c94b9781b9d9238335e..43c1d9387481fe1ad09939f8839159aa5b3b76b1 100644
--- a/lib/std/math/complex/arg.zig
+++ b/lib/std/math/complex/arg.zig
@@ -20,5 +20,5 @@ const epsilon = 0.0001;
 test "complex.carg" {
     const a = Complex(f32).new(5, 3);
     const c = arg(a);
-    testing.expect(math.approxEq(f32, c, 0.540420, epsilon));
+    testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon));
 }
diff --git a/lib/std/math/complex/asin.zig b/lib/std/math/complex/asin.zig
index 5c5de3ff4f1c2c98b8e91d79e99d8b141a1c5666..4911ccc2b21f9ba2067a8bd0a782ad5516bfe409 100644
--- a/lib/std/math/complex/asin.zig
+++ b/lib/std/math/complex/asin.zig
@@ -28,6 +28,6 @@ test "complex.casin" {
     const a = Complex(f32).new(5, 3);
     const c = asin(a);
 
-    testing.expect(math.approxEq(f32, c.re, 1.023822, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 2.452914, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon));
 }
diff --git a/lib/std/math/complex/asinh.zig b/lib/std/math/complex/asinh.zig
index a3f5f04fbc305d897f8002680f1f4a8278570f09..e93a2dabd73999f43f747a0432c26056eb4ad78b 100644
--- a/lib/std/math/complex/asinh.zig
+++ b/lib/std/math/complex/asinh.zig
@@ -23,6 +23,6 @@ test "complex.casinh" {
     const a = Complex(f32).new(5, 3);
     const c = asinh(a);
 
-    testing.expect(math.approxEq(f32, c.re, 2.459831, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 0.533999, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon));
 }
diff --git a/lib/std/math/complex/atan.zig b/lib/std/math/complex/atan.zig
index e5c49976ac0e7dc31cfa203b6591ebb4e3957ea8..e838751d73a6a7867cbcd317846d471554f0be7d 100644
--- a/lib/std/math/complex/atan.zig
+++ b/lib/std/math/complex/atan.zig
@@ -130,14 +130,14 @@ test "complex.catan32" {
     const a = Complex(f32).new(5, 3);
     const c = atan(a);
 
-    testing.expect(math.approxEq(f32, c.re, 1.423679, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 0.086569, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon));
 }
 
 test "complex.catan64" {
     const a = Complex(f64).new(5, 3);
     const c = atan(a);
 
-    testing.expect(math.approxEq(f64, c.re, 1.423679, epsilon));
-    testing.expect(math.approxEq(f64, c.im, 0.086569, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon));
 }
diff --git a/lib/std/math/complex/atanh.zig b/lib/std/math/complex/atanh.zig
index 4ab24102580715323c59463bf999cf227d0d6840..f3d378315fb164c96a21b87f9627324c80a836e0 100644
--- a/lib/std/math/complex/atanh.zig
+++ b/lib/std/math/complex/atanh.zig
@@ -23,6 +23,6 @@ test "complex.catanh" {
     const a = Complex(f32).new(5, 3);
     const c = atanh(a);
 
-    testing.expect(math.approxEq(f32, c.re, 0.146947, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 1.480870, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon));
 }
diff --git a/lib/std/math/complex/cos.zig b/lib/std/math/complex/cos.zig
index 559613cc341a99f412858ea1fbb0d9cb3613393c..2abfce58c6aeac3e22266827b0ef58b415ccf452 100644
--- a/lib/std/math/complex/cos.zig
+++ b/lib/std/math/complex/cos.zig
@@ -22,6 +22,6 @@ test "complex.ccos" {
     const a = Complex(f32).new(5, 3);
     const c = cos(a);
 
-    testing.expect(math.approxEq(f32, c.re, 2.855815, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 9.606383, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon));
 }
diff --git a/lib/std/math/complex/cosh.zig b/lib/std/math/complex/cosh.zig
index f668cb60cee2d84b1c1369ab3b358c86a73a1e2a..0a6be49e3e0f1a739702f7d06e31e4e4d2454815 100644
--- a/lib/std/math/complex/cosh.zig
+++ b/lib/std/math/complex/cosh.zig
@@ -165,14 +165,14 @@ test "complex.ccosh32" {
     const a = Complex(f32).new(5, 3);
     const c = cosh(a);
 
-    testing.expect(math.approxEq(f32, c.re, -73.467300, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 10.471557, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon));
 }
 
 test "complex.ccosh64" {
     const a = Complex(f64).new(5, 3);
     const c = cosh(a);
 
-    testing.expect(math.approxEq(f64, c.re, -73.467300, epsilon));
-    testing.expect(math.approxEq(f64, c.im, 10.471557, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon));
 }
diff --git a/lib/std/math/complex/exp.zig b/lib/std/math/complex/exp.zig
index 3ad51fe06fefc93962705ccc2ee8d6bf01f48b68..156a947a32bd25689a650eeb21b09eb36386d098 100644
--- a/lib/std/math/complex/exp.zig
+++ b/lib/std/math/complex/exp.zig
@@ -131,14 +131,14 @@ test "complex.cexp32" {
     const a = Complex(f32).new(5, 3);
     const c = exp(a);
 
-    testing.expect(math.approxEq(f32, c.re, -146.927917, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 20.944065, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, -146.927917, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 20.944065, epsilon));
 }
 
 test "complex.cexp64" {
     const a = Complex(f64).new(5, 3);
     const c = exp(a);
 
-    testing.expect(math.approxEq(f64, c.re, -146.927917, epsilon));
-    testing.expect(math.approxEq(f64, c.im, 20.944065, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.re, -146.927917, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.im, 20.944065, epsilon));
 }
diff --git a/lib/std/math/complex/log.zig b/lib/std/math/complex/log.zig
index cb719f4b312d0e4d2285b755deed6603f013c6a7..88175d00cc573a86850feacaf4077db592e89f22 100644
--- a/lib/std/math/complex/log.zig
+++ b/lib/std/math/complex/log.zig
@@ -24,6 +24,6 @@ test "complex.clog" {
     const a = Complex(f32).new(5, 3);
     const c = log(a);
 
-    testing.expect(math.approxEq(f32, c.re, 1.763180, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 0.540419, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon));
 }
diff --git a/lib/std/math/complex/pow.zig b/lib/std/math/complex/pow.zig
index 7be38cadf20b3b1c62a74e2ed45a5bc8ab27f876..30636dd10d10714577321b8e33992afbb1bf300a 100644
--- a/lib/std/math/complex/pow.zig
+++ b/lib/std/math/complex/pow.zig
@@ -23,6 +23,6 @@ test "complex.cpow" {
     const b = Complex(f32).new(2.3, -1.3);
     const c = pow(Complex(f32), a, b);
 
-    testing.expect(math.approxEq(f32, c.re, 58.049110, epsilon));
-    testing.expect(math.approxEq(f32, c.im, -101.003433, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon));
 }
diff --git a/lib/std/math/complex/sin.zig b/lib/std/math/complex/sin.zig
index 2f33e13354cf83aee1c3e6909152b17d246b8121..d5e2713b13acdc536e9ab52583c69a3af93e62dc 100644
--- a/lib/std/math/complex/sin.zig
+++ b/lib/std/math/complex/sin.zig
@@ -23,6 +23,6 @@ test "complex.csin" {
     const a = Complex(f32).new(5, 3);
     const c = sin(a);
 
-    testing.expect(math.approxEq(f32, c.re, -9.654126, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 2.841692, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon));
 }
diff --git a/lib/std/math/complex/sinh.zig b/lib/std/math/complex/sinh.zig
index 3242adef7901f265ab5ff5c3e17506e51dc17ae3..8c8930c0ba017bff155f83f6bcea3051a834a97f 100644
--- a/lib/std/math/complex/sinh.zig
+++ b/lib/std/math/complex/sinh.zig
@@ -164,14 +164,14 @@ test "complex.csinh32" {
     const a = Complex(f32).new(5, 3);
     const c = sinh(a);
 
-    testing.expect(math.approxEq(f32, c.re, -73.460617, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 10.472508, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon));
 }
 
 test "complex.csinh64" {
     const a = Complex(f64).new(5, 3);
     const c = sinh(a);
 
-    testing.expect(math.approxEq(f64, c.re, -73.460617, epsilon));
-    testing.expect(math.approxEq(f64, c.im, 10.472508, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon));
 }
diff --git a/lib/std/math/complex/sqrt.zig b/lib/std/math/complex/sqrt.zig
index 8abb9a6064cb34e96b671357c681ffcee50ddb93..a01473a5ead1295ca640623e90e0aa902c25e5d4 100644
--- a/lib/std/math/complex/sqrt.zig
+++ b/lib/std/math/complex/sqrt.zig
@@ -138,14 +138,14 @@ test "complex.csqrt32" {
     const a = Complex(f32).new(5, 3);
     const c = sqrt(a);
 
-    testing.expect(math.approxEq(f32, c.re, 2.327117, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 0.644574, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon));
 }
 
 test "complex.csqrt64" {
     const a = Complex(f64).new(5, 3);
     const c = sqrt(a);
 
-    testing.expect(math.approxEq(f64, c.re, 2.3271175190399496, epsilon));
-    testing.expect(math.approxEq(f64, c.im, 0.6445742373246469, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon));
 }
diff --git a/lib/std/math/complex/tan.zig b/lib/std/math/complex/tan.zig
index adcda786c1c2f6bc10332b832b6ea0ca021f712d..8d6e5da313d00b9499dcf4398c57e407e5c5f957 100644
--- a/lib/std/math/complex/tan.zig
+++ b/lib/std/math/complex/tan.zig
@@ -23,6 +23,6 @@ test "complex.ctan" {
     const a = Complex(f32).new(5, 3);
     const c = tan(a);
 
-    testing.expect(math.approxEq(f32, c.re, -0.002708233, epsilon));
-    testing.expect(math.approxEq(f32, c.im, 1.004165, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon));
 }
diff --git a/lib/std/math/complex/tanh.zig b/lib/std/math/complex/tanh.zig
index fd631149820be6d66598a76a53afaa4f2f7786ce..cf82f04f4145b601f06e2ea0ccd924100c8b3df9 100644
--- a/lib/std/math/complex/tanh.zig
+++ b/lib/std/math/complex/tanh.zig
@@ -113,14 +113,14 @@ test "complex.ctanh32" {
     const a = Complex(f32).new(5, 3);
     const c = tanh(a);
 
-    testing.expect(math.approxEq(f32, c.re, 0.999913, epsilon));
-    testing.expect(math.approxEq(f32, c.im, -0.000025, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon));
+    testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon));
 }
 
 test "complex.ctanh64" {
     const a = Complex(f64).new(5, 3);
     const c = tanh(a);
 
-    testing.expect(math.approxEq(f64, c.re, 0.999913, epsilon));
-    testing.expect(math.approxEq(f64, c.im, -0.000025, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon));
+    testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon));
 }
diff --git a/lib/std/math/cos.zig b/lib/std/math/cos.zig
index 5aaea9ce4e95ff8131248b689a7e419fa6f64d94..f8135e5d4f5b2b55b4f0bfbb9cea53d304c1ea34 100644
--- a/lib/std/math/cos.zig
+++ b/lib/std/math/cos.zig
@@ -95,25 +95,25 @@ test "math.cos" {
 test "math.cos32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, cos_(f32, 0.0), 1.0, epsilon));
-    expect(math.approxEq(f32, cos_(f32, 0.2), 0.980067, epsilon));
-    expect(math.approxEq(f32, cos_(f32, 0.8923), 0.627623, epsilon));
-    expect(math.approxEq(f32, cos_(f32, 1.5), 0.070737, epsilon));
-    expect(math.approxEq(f32, cos_(f32, -1.5), 0.070737, epsilon));
-    expect(math.approxEq(f32, cos_(f32, 37.45), 0.969132, epsilon));
-    expect(math.approxEq(f32, cos_(f32, 89.123), 0.400798, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, 0.0), 1.0, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, 0.2), 0.980067, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, 0.8923), 0.627623, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, 1.5), 0.070737, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, -1.5), 0.070737, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, 37.45), 0.969132, epsilon));
+    expect(math.approxEqAbs(f32, cos_(f32, 89.123), 0.400798, epsilon));
 }
 
 test "math.cos64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, cos_(f64, 0.0), 1.0, epsilon));
-    expect(math.approxEq(f64, cos_(f64, 0.2), 0.980067, epsilon));
-    expect(math.approxEq(f64, cos_(f64, 0.8923), 0.627623, epsilon));
-    expect(math.approxEq(f64, cos_(f64, 1.5), 0.070737, epsilon));
-    expect(math.approxEq(f64, cos_(f64, -1.5), 0.070737, epsilon));
-    expect(math.approxEq(f64, cos_(f64, 37.45), 0.969132, epsilon));
-    expect(math.approxEq(f64, cos_(f64, 89.123), 0.40080, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, 0.0), 1.0, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, 0.2), 0.980067, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, 0.8923), 0.627623, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, 1.5), 0.070737, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, -1.5), 0.070737, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, 37.45), 0.969132, epsilon));
+    expect(math.approxEqAbs(f64, cos_(f64, 89.123), 0.40080, epsilon));
 }
 
 test "math.cos32.special" {
diff --git a/lib/std/math/cosh.zig b/lib/std/math/cosh.zig
index 221ebcf08964cfc195fed110b2f8722af3648a07..c3736415d320079d985a838003bc01b68aabdc1d 100644
--- a/lib/std/math/cosh.zig
+++ b/lib/std/math/cosh.zig
@@ -100,27 +100,27 @@ test "math.cosh" {
 test "math.cosh32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, cosh32(0.0), 1.0, epsilon));
-    expect(math.approxEq(f32, cosh32(0.2), 1.020067, epsilon));
-    expect(math.approxEq(f32, cosh32(0.8923), 1.425225, epsilon));
-    expect(math.approxEq(f32, cosh32(1.5), 2.352410, epsilon));
-    expect(math.approxEq(f32, cosh32(-0.0), 1.0, epsilon));
-    expect(math.approxEq(f32, cosh32(-0.2), 1.020067, epsilon));
-    expect(math.approxEq(f32, cosh32(-0.8923), 1.425225, epsilon));
-    expect(math.approxEq(f32, cosh32(-1.5), 2.352410, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(0.0), 1.0, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(0.2), 1.020067, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(0.8923), 1.425225, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(1.5), 2.352410, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(-0.0), 1.0, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(-0.2), 1.020067, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(-0.8923), 1.425225, epsilon));
+    expect(math.approxEqAbs(f32, cosh32(-1.5), 2.352410, epsilon));
 }
 
 test "math.cosh64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, cosh64(0.0), 1.0, epsilon));
-    expect(math.approxEq(f64, cosh64(0.2), 1.020067, epsilon));
-    expect(math.approxEq(f64, cosh64(0.8923), 1.425225, epsilon));
-    expect(math.approxEq(f64, cosh64(1.5), 2.352410, epsilon));
-    expect(math.approxEq(f64, cosh64(-0.0), 1.0, epsilon));
-    expect(math.approxEq(f64, cosh64(-0.2), 1.020067, epsilon));
-    expect(math.approxEq(f64, cosh64(-0.8923), 1.425225, epsilon));
-    expect(math.approxEq(f64, cosh64(-1.5), 2.352410, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(0.0), 1.0, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(0.2), 1.020067, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(0.8923), 1.425225, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(1.5), 2.352410, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(-0.0), 1.0, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(-0.2), 1.020067, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(-0.8923), 1.425225, epsilon));
+    expect(math.approxEqAbs(f64, cosh64(-1.5), 2.352410, epsilon));
 }
 
 test "math.cosh32.special" {
diff --git a/lib/std/math/epsilon.zig b/lib/std/math/epsilon.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3243b085ad265284e7e91dc256dd8205f8fbefde
--- /dev/null
+++ b/lib/std/math/epsilon.zig
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2015-2020 Zig Contributors
+// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
+// The MIT license requires this copyright notice to be included in all copies
+// and substantial portions of the software.
+const math = @import("../math.zig");
+
+/// Returns the machine epsilon for type T.
+/// This is the smallest value of type T that satisfies the inequality 1.0 +
+/// epsilon != 1.0.
+pub fn epsilon(comptime T: type) T {
+    return switch (T) {
+        f16 => math.f16_epsilon,
+        f32 => math.f32_epsilon,
+        f64 => math.f64_epsilon,
+        f128 => math.f128_epsilon,
+        else => @compileError("epsilon not implemented for " ++ @typeName(T)),
+    };
+}
diff --git a/lib/std/math/exp.zig b/lib/std/math/exp.zig
index c6444480fdf0df2e0afda575d68df5969989e50e..35d26f2a5054bcc4bec15321cd26872085ae8d1f 100644
--- a/lib/std/math/exp.zig
+++ b/lib/std/math/exp.zig
@@ -196,20 +196,20 @@ test "math.exp32" {
     const epsilon = 0.000001;
 
     assert(exp32(0.0) == 1.0);
-    assert(math.approxEq(f32, exp32(0.0), 1.0, epsilon));
-    assert(math.approxEq(f32, exp32(0.2), 1.221403, epsilon));
-    assert(math.approxEq(f32, exp32(0.8923), 2.440737, epsilon));
-    assert(math.approxEq(f32, exp32(1.5), 4.481689, epsilon));
+    assert(math.approxEqAbs(f32, exp32(0.0), 1.0, epsilon));
+    assert(math.approxEqAbs(f32, exp32(0.2), 1.221403, epsilon));
+    assert(math.approxEqAbs(f32, exp32(0.8923), 2.440737, epsilon));
+    assert(math.approxEqAbs(f32, exp32(1.5), 4.481689, epsilon));
 }
 
 test "math.exp64" {
     const epsilon = 0.000001;
 
     assert(exp64(0.0) == 1.0);
-    assert(math.approxEq(f64, exp64(0.0), 1.0, epsilon));
-    assert(math.approxEq(f64, exp64(0.2), 1.221403, epsilon));
-    assert(math.approxEq(f64, exp64(0.8923), 2.440737, epsilon));
-    assert(math.approxEq(f64, exp64(1.5), 4.481689, epsilon));
+    assert(math.approxEqAbs(f64, exp64(0.0), 1.0, epsilon));
+    assert(math.approxEqAbs(f64, exp64(0.2), 1.221403, epsilon));
+    assert(math.approxEqAbs(f64, exp64(0.8923), 2.440737, epsilon));
+    assert(math.approxEqAbs(f64, exp64(1.5), 4.481689, epsilon));
 }
 
 test "math.exp32.special" {
diff --git a/lib/std/math/exp2.zig b/lib/std/math/exp2.zig
index dea6276469d813ade7ceffdc1354e90977a59846..0857fa573dc9c5baacaf413c56992fde296c98bb 100644
--- a/lib/std/math/exp2.zig
+++ b/lib/std/math/exp2.zig
@@ -434,19 +434,19 @@ test "math.exp2_32" {
     const epsilon = 0.000001;
 
     expect(exp2_32(0.0) == 1.0);
-    expect(math.approxEq(f32, exp2_32(0.2), 1.148698, epsilon));
-    expect(math.approxEq(f32, exp2_32(0.8923), 1.856133, epsilon));
-    expect(math.approxEq(f32, exp2_32(1.5), 2.828427, epsilon));
-    expect(math.approxEq(f32, exp2_32(37.45), 187747237888, epsilon));
+    expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon));
+    expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon));
+    expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon));
+    expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon));
 }
 
 test "math.exp2_64" {
     const epsilon = 0.000001;
 
     expect(exp2_64(0.0) == 1.0);
-    expect(math.approxEq(f64, exp2_64(0.2), 1.148698, epsilon));
-    expect(math.approxEq(f64, exp2_64(0.8923), 1.856133, epsilon));
-    expect(math.approxEq(f64, exp2_64(1.5), 2.828427, epsilon));
+    expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon));
+    expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon));
+    expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon));
 }
 
 test "math.exp2_32.special" {
diff --git a/lib/std/math/expm1.zig b/lib/std/math/expm1.zig
index 37085a5fa60062be58d0fefe3f12b820d606eaaa..1c22db342a5e30bbed42ef985c5a6b3b49656af6 100644
--- a/lib/std/math/expm1.zig
+++ b/lib/std/math/expm1.zig
@@ -300,20 +300,20 @@ test "math.expm1_32" {
     const epsilon = 0.000001;
 
     expect(expm1_32(0.0) == 0.0);
-    expect(math.approxEq(f32, expm1_32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, expm1_32(0.2), 0.221403, epsilon));
-    expect(math.approxEq(f32, expm1_32(0.8923), 1.440737, epsilon));
-    expect(math.approxEq(f32, expm1_32(1.5), 3.481689, epsilon));
+    expect(math.approxEqAbs(f32, expm1_32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, expm1_32(0.2), 0.221403, epsilon));
+    expect(math.approxEqAbs(f32, expm1_32(0.8923), 1.440737, epsilon));
+    expect(math.approxEqAbs(f32, expm1_32(1.5), 3.481689, epsilon));
 }
 
 test "math.expm1_64" {
     const epsilon = 0.000001;
 
     expect(expm1_64(0.0) == 0.0);
-    expect(math.approxEq(f64, expm1_64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, expm1_64(0.2), 0.221403, epsilon));
-    expect(math.approxEq(f64, expm1_64(0.8923), 1.440737, epsilon));
-    expect(math.approxEq(f64, expm1_64(1.5), 3.481689, epsilon));
+    expect(math.approxEqAbs(f64, expm1_64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, expm1_64(0.2), 0.221403, epsilon));
+    expect(math.approxEqAbs(f64, expm1_64(0.8923), 1.440737, epsilon));
+    expect(math.approxEqAbs(f64, expm1_64(1.5), 3.481689, epsilon));
 }
 
 test "math.expm1_32.special" {
diff --git a/lib/std/math/fma.zig b/lib/std/math/fma.zig
index 6993fc978648f26be94da69a027743339aa921bf..852bbe9d7563a2408800a127e79201e8a5bedabe 100644
--- a/lib/std/math/fma.zig
+++ b/lib/std/math/fma.zig
@@ -155,23 +155,23 @@ test "math.fma" {
 test "math.fma32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon));
-    expect(math.approxEq(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon));
-    expect(math.approxEq(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon));
-    expect(math.approxEq(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon));
-    expect(math.approxEq(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon));
-    expect(math.approxEq(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon));
-    expect(math.approxEq(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
+    expect(math.approxEqAbs(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon));
+    expect(math.approxEqAbs(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon));
+    expect(math.approxEqAbs(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon));
+    expect(math.approxEqAbs(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon));
+    expect(math.approxEqAbs(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon));
+    expect(math.approxEqAbs(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon));
+    expect(math.approxEqAbs(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
 }
 
 test "math.fma64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon));
-    expect(math.approxEq(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon));
-    expect(math.approxEq(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon));
-    expect(math.approxEq(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon));
-    expect(math.approxEq(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon));
-    expect(math.approxEq(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon));
-    expect(math.approxEq(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
+    expect(math.approxEqAbs(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon));
+    expect(math.approxEqAbs(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon));
+    expect(math.approxEqAbs(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon));
+    expect(math.approxEqAbs(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon));
+    expect(math.approxEqAbs(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon));
+    expect(math.approxEqAbs(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon));
+    expect(math.approxEqAbs(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon));
 }
diff --git a/lib/std/math/frexp.zig b/lib/std/math/frexp.zig
index 2d99c85c51f589766c2ef1db5e59ae9085db9fad..3f73c9eec3de74bbedaa261f779968bb754a714d 100644
--- a/lib/std/math/frexp.zig
+++ b/lib/std/math/frexp.zig
@@ -127,10 +127,10 @@ test "math.frexp32" {
     var r: frexp32_result = undefined;
 
     r = frexp32(1.3);
-    expect(math.approxEq(f32, r.significand, 0.65, epsilon) and r.exponent == 1);
+    expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1);
 
     r = frexp32(78.0234);
-    expect(math.approxEq(f32, r.significand, 0.609558, epsilon) and r.exponent == 7);
+    expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7);
 }
 
 test "math.frexp64" {
@@ -138,10 +138,10 @@ test "math.frexp64" {
     var r: frexp64_result = undefined;
 
     r = frexp64(1.3);
-    expect(math.approxEq(f64, r.significand, 0.65, epsilon) and r.exponent == 1);
+    expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1);
 
     r = frexp64(78.0234);
-    expect(math.approxEq(f64, r.significand, 0.609558, epsilon) and r.exponent == 7);
+    expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7);
 }
 
 test "math.frexp32.special" {
diff --git a/lib/std/math/hypot.zig b/lib/std/math/hypot.zig
index 595563076bde1d0777a9941b8dde56da6d415372..f04a42d1d5a47be2b6905e033546f69f0ee91cad 100644
--- a/lib/std/math/hypot.zig
+++ b/lib/std/math/hypot.zig
@@ -133,25 +133,25 @@ test "math.hypot" {
 test "math.hypot32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, hypot32(0.0, -1.2), 1.2, epsilon));
-    expect(math.approxEq(f32, hypot32(0.2, -0.34), 0.394462, epsilon));
-    expect(math.approxEq(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon));
-    expect(math.approxEq(f32, hypot32(1.5, 5.25), 5.460083, epsilon));
-    expect(math.approxEq(f32, hypot32(37.45, 159.835), 164.163742, epsilon));
-    expect(math.approxEq(f32, hypot32(89.123, 382.028905), 392.286865, epsilon));
-    expect(math.approxEq(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(0.0, -1.2), 1.2, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(0.2, -0.34), 0.394462, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(1.5, 5.25), 5.460083, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(37.45, 159.835), 164.163742, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(89.123, 382.028905), 392.286865, epsilon));
+    expect(math.approxEqAbs(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon));
 }
 
 test "math.hypot64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, hypot64(0.0, -1.2), 1.2, epsilon));
-    expect(math.approxEq(f64, hypot64(0.2, -0.34), 0.394462, epsilon));
-    expect(math.approxEq(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon));
-    expect(math.approxEq(f64, hypot64(1.5, 5.25), 5.460082, epsilon));
-    expect(math.approxEq(f64, hypot64(37.45, 159.835), 164.163728, epsilon));
-    expect(math.approxEq(f64, hypot64(89.123, 382.028905), 392.286876, epsilon));
-    expect(math.approxEq(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(0.0, -1.2), 1.2, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(0.2, -0.34), 0.394462, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(1.5, 5.25), 5.460082, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(37.45, 159.835), 164.163728, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(89.123, 382.028905), 392.286876, epsilon));
+    expect(math.approxEqAbs(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon));
 }
 
 test "math.hypot32.special" {
diff --git a/lib/std/math/ln.zig b/lib/std/math/ln.zig
index 60a2f528aae17bc10bdc74a36a2ebc55e3df6645..cb5c966ab8d1bc3e9734fe5b17cbeb77b0953be4 100644
--- a/lib/std/math/ln.zig
+++ b/lib/std/math/ln.zig
@@ -159,23 +159,23 @@ test "math.ln" {
 test "math.ln32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, ln_32(0.2), -1.609438, epsilon));
-    expect(math.approxEq(f32, ln_32(0.8923), -0.113953, epsilon));
-    expect(math.approxEq(f32, ln_32(1.5), 0.405465, epsilon));
-    expect(math.approxEq(f32, ln_32(37.45), 3.623007, epsilon));
-    expect(math.approxEq(f32, ln_32(89.123), 4.490017, epsilon));
-    expect(math.approxEq(f32, ln_32(123123.234375), 11.720941, epsilon));
+    expect(math.approxEqAbs(f32, ln_32(0.2), -1.609438, epsilon));
+    expect(math.approxEqAbs(f32, ln_32(0.8923), -0.113953, epsilon));
+    expect(math.approxEqAbs(f32, ln_32(1.5), 0.405465, epsilon));
+    expect(math.approxEqAbs(f32, ln_32(37.45), 3.623007, epsilon));
+    expect(math.approxEqAbs(f32, ln_32(89.123), 4.490017, epsilon));
+    expect(math.approxEqAbs(f32, ln_32(123123.234375), 11.720941, epsilon));
 }
 
 test "math.ln64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, ln_64(0.2), -1.609438, epsilon));
-    expect(math.approxEq(f64, ln_64(0.8923), -0.113953, epsilon));
-    expect(math.approxEq(f64, ln_64(1.5), 0.405465, epsilon));
-    expect(math.approxEq(f64, ln_64(37.45), 3.623007, epsilon));
-    expect(math.approxEq(f64, ln_64(89.123), 4.490017, epsilon));
-    expect(math.approxEq(f64, ln_64(123123.234375), 11.720941, epsilon));
+    expect(math.approxEqAbs(f64, ln_64(0.2), -1.609438, epsilon));
+    expect(math.approxEqAbs(f64, ln_64(0.8923), -0.113953, epsilon));
+    expect(math.approxEqAbs(f64, ln_64(1.5), 0.405465, epsilon));
+    expect(math.approxEqAbs(f64, ln_64(37.45), 3.623007, epsilon));
+    expect(math.approxEqAbs(f64, ln_64(89.123), 4.490017, epsilon));
+    expect(math.approxEqAbs(f64, ln_64(123123.234375), 11.720941, epsilon));
 }
 
 test "math.ln32.special" {
diff --git a/lib/std/math/log.zig b/lib/std/math/log.zig
index 4286b74960704108a3781f780a5d2bb71155c262..240ef759d1af01a8d6fc60ea50205aa0ce5b207d 100644
--- a/lib/std/math/log.zig
+++ b/lib/std/math/log.zig
@@ -61,9 +61,9 @@ test "math.log integer" {
 test "math.log float" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, log(f32, 6, 0.23947), -0.797723, epsilon));
-    expect(math.approxEq(f32, log(f32, 89, 0.23947), -0.318432, epsilon));
-    expect(math.approxEq(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon));
+    expect(math.approxEqAbs(f32, log(f32, 6, 0.23947), -0.797723, epsilon));
+    expect(math.approxEqAbs(f32, log(f32, 89, 0.23947), -0.318432, epsilon));
+    expect(math.approxEqAbs(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon));
 }
 
 test "math.log float_special" {
diff --git a/lib/std/math/log10.zig b/lib/std/math/log10.zig
index d7d192a564af299d1ee098a6908f3e9be42f7e02..269bc1d22841bd448f96eb6009bc9b0fe8d81a36 100644
--- a/lib/std/math/log10.zig
+++ b/lib/std/math/log10.zig
@@ -187,23 +187,23 @@ test "math.log10" {
 test "math.log10_32" {
     const epsilon = 0.000001;
 
-    testing.expect(math.approxEq(f32, log10_32(0.2), -0.698970, epsilon));
-    testing.expect(math.approxEq(f32, log10_32(0.8923), -0.049489, epsilon));
-    testing.expect(math.approxEq(f32, log10_32(1.5), 0.176091, epsilon));
-    testing.expect(math.approxEq(f32, log10_32(37.45), 1.573452, epsilon));
-    testing.expect(math.approxEq(f32, log10_32(89.123), 1.94999, epsilon));
-    testing.expect(math.approxEq(f32, log10_32(123123.234375), 5.09034, epsilon));
+    testing.expect(math.approxEqAbs(f32, log10_32(0.2), -0.698970, epsilon));
+    testing.expect(math.approxEqAbs(f32, log10_32(0.8923), -0.049489, epsilon));
+    testing.expect(math.approxEqAbs(f32, log10_32(1.5), 0.176091, epsilon));
+    testing.expect(math.approxEqAbs(f32, log10_32(37.45), 1.573452, epsilon));
+    testing.expect(math.approxEqAbs(f32, log10_32(89.123), 1.94999, epsilon));
+    testing.expect(math.approxEqAbs(f32, log10_32(123123.234375), 5.09034, epsilon));
 }
 
 test "math.log10_64" {
     const epsilon = 0.000001;
 
-    testing.expect(math.approxEq(f64, log10_64(0.2), -0.698970, epsilon));
-    testing.expect(math.approxEq(f64, log10_64(0.8923), -0.049489, epsilon));
-    testing.expect(math.approxEq(f64, log10_64(1.5), 0.176091, epsilon));
-    testing.expect(math.approxEq(f64, log10_64(37.45), 1.573452, epsilon));
-    testing.expect(math.approxEq(f64, log10_64(89.123), 1.94999, epsilon));
-    testing.expect(math.approxEq(f64, log10_64(123123.234375), 5.09034, epsilon));
+    testing.expect(math.approxEqAbs(f64, log10_64(0.2), -0.698970, epsilon));
+    testing.expect(math.approxEqAbs(f64, log10_64(0.8923), -0.049489, epsilon));
+    testing.expect(math.approxEqAbs(f64, log10_64(1.5), 0.176091, epsilon));
+    testing.expect(math.approxEqAbs(f64, log10_64(37.45), 1.573452, epsilon));
+    testing.expect(math.approxEqAbs(f64, log10_64(89.123), 1.94999, epsilon));
+    testing.expect(math.approxEqAbs(f64, log10_64(123123.234375), 5.09034, epsilon));
 }
 
 test "math.log10_32.special" {
diff --git a/lib/std/math/log1p.zig b/lib/std/math/log1p.zig
index 7686fc769172def3d9dec1fe2d1362d88c8f9a05..c0ca027ffb5faace9cb5807af7a0f2ab2b53b7db 100644
--- a/lib/std/math/log1p.zig
+++ b/lib/std/math/log1p.zig
@@ -195,25 +195,25 @@ test "math.log1p" {
 test "math.log1p_32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, log1p_32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, log1p_32(0.2), 0.182322, epsilon));
-    expect(math.approxEq(f32, log1p_32(0.8923), 0.637793, epsilon));
-    expect(math.approxEq(f32, log1p_32(1.5), 0.916291, epsilon));
-    expect(math.approxEq(f32, log1p_32(37.45), 3.649359, epsilon));
-    expect(math.approxEq(f32, log1p_32(89.123), 4.501175, epsilon));
-    expect(math.approxEq(f32, log1p_32(123123.234375), 11.720949, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(0.2), 0.182322, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(0.8923), 0.637793, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(1.5), 0.916291, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(37.45), 3.649359, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(89.123), 4.501175, epsilon));
+    expect(math.approxEqAbs(f32, log1p_32(123123.234375), 11.720949, epsilon));
 }
 
 test "math.log1p_64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, log1p_64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, log1p_64(0.2), 0.182322, epsilon));
-    expect(math.approxEq(f64, log1p_64(0.8923), 0.637793, epsilon));
-    expect(math.approxEq(f64, log1p_64(1.5), 0.916291, epsilon));
-    expect(math.approxEq(f64, log1p_64(37.45), 3.649359, epsilon));
-    expect(math.approxEq(f64, log1p_64(89.123), 4.501175, epsilon));
-    expect(math.approxEq(f64, log1p_64(123123.234375), 11.720949, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(0.2), 0.182322, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(0.8923), 0.637793, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(1.5), 0.916291, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(37.45), 3.649359, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(89.123), 4.501175, epsilon));
+    expect(math.approxEqAbs(f64, log1p_64(123123.234375), 11.720949, epsilon));
 }
 
 test "math.log1p_32.special" {
diff --git a/lib/std/math/log2.zig b/lib/std/math/log2.zig
index 2b9fbe3d84209c7ad1d36fa24032b783ae99946c..201364a8cf35172662d2c786bc587134597e16b9 100644
--- a/lib/std/math/log2.zig
+++ b/lib/std/math/log2.zig
@@ -185,21 +185,21 @@ test "math.log2" {
 test "math.log2_32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, log2_32(0.2), -2.321928, epsilon));
-    expect(math.approxEq(f32, log2_32(0.8923), -0.164399, epsilon));
-    expect(math.approxEq(f32, log2_32(1.5), 0.584962, epsilon));
-    expect(math.approxEq(f32, log2_32(37.45), 5.226894, epsilon));
-    expect(math.approxEq(f32, log2_32(123123.234375), 16.909744, epsilon));
+    expect(math.approxEqAbs(f32, log2_32(0.2), -2.321928, epsilon));
+    expect(math.approxEqAbs(f32, log2_32(0.8923), -0.164399, epsilon));
+    expect(math.approxEqAbs(f32, log2_32(1.5), 0.584962, epsilon));
+    expect(math.approxEqAbs(f32, log2_32(37.45), 5.226894, epsilon));
+    expect(math.approxEqAbs(f32, log2_32(123123.234375), 16.909744, epsilon));
 }
 
 test "math.log2_64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, log2_64(0.2), -2.321928, epsilon));
-    expect(math.approxEq(f64, log2_64(0.8923), -0.164399, epsilon));
-    expect(math.approxEq(f64, log2_64(1.5), 0.584962, epsilon));
-    expect(math.approxEq(f64, log2_64(37.45), 5.226894, epsilon));
-    expect(math.approxEq(f64, log2_64(123123.234375), 16.909744, epsilon));
+    expect(math.approxEqAbs(f64, log2_64(0.2), -2.321928, epsilon));
+    expect(math.approxEqAbs(f64, log2_64(0.8923), -0.164399, epsilon));
+    expect(math.approxEqAbs(f64, log2_64(1.5), 0.584962, epsilon));
+    expect(math.approxEqAbs(f64, log2_64(37.45), 5.226894, epsilon));
+    expect(math.approxEqAbs(f64, log2_64(123123.234375), 16.909744, epsilon));
 }
 
 test "math.log2_32.special" {
diff --git a/lib/std/math/modf.zig b/lib/std/math/modf.zig
index 830b99257ec990bb59a3fb02013b1022db155c31..fe73f0ce7591a4b960a58e369e003343b5bbddaf 100644
--- a/lib/std/math/modf.zig
+++ b/lib/std/math/modf.zig
@@ -143,24 +143,24 @@ test "math.modf32" {
     var r: modf32_result = undefined;
 
     r = modf32(1.0);
-    expect(math.approxEq(f32, r.ipart, 1.0, epsilon));
-    expect(math.approxEq(f32, r.fpart, 0.0, epsilon));
+    expect(math.approxEqAbs(f32, r.ipart, 1.0, epsilon));
+    expect(math.approxEqAbs(f32, r.fpart, 0.0, epsilon));
 
     r = modf32(2.545);
-    expect(math.approxEq(f32, r.ipart, 2.0, epsilon));
-    expect(math.approxEq(f32, r.fpart, 0.545, epsilon));
+    expect(math.approxEqAbs(f32, r.ipart, 2.0, epsilon));
+    expect(math.approxEqAbs(f32, r.fpart, 0.545, epsilon));
 
     r = modf32(3.978123);
-    expect(math.approxEq(f32, r.ipart, 3.0, epsilon));
-    expect(math.approxEq(f32, r.fpart, 0.978123, epsilon));
+    expect(math.approxEqAbs(f32, r.ipart, 3.0, epsilon));
+    expect(math.approxEqAbs(f32, r.fpart, 0.978123, epsilon));
 
     r = modf32(43874.3);
-    expect(math.approxEq(f32, r.ipart, 43874, epsilon));
-    expect(math.approxEq(f32, r.fpart, 0.300781, epsilon));
+    expect(math.approxEqAbs(f32, r.ipart, 43874, epsilon));
+    expect(math.approxEqAbs(f32, r.fpart, 0.300781, epsilon));
 
     r = modf32(1234.340780);
-    expect(math.approxEq(f32, r.ipart, 1234, epsilon));
-    expect(math.approxEq(f32, r.fpart, 0.340820, epsilon));
+    expect(math.approxEqAbs(f32, r.ipart, 1234, epsilon));
+    expect(math.approxEqAbs(f32, r.fpart, 0.340820, epsilon));
 }
 
 test "math.modf64" {
@@ -168,24 +168,24 @@ test "math.modf64" {
     var r: modf64_result = undefined;
 
     r = modf64(1.0);
-    expect(math.approxEq(f64, r.ipart, 1.0, epsilon));
-    expect(math.approxEq(f64, r.fpart, 0.0, epsilon));
+    expect(math.approxEqAbs(f64, r.ipart, 1.0, epsilon));
+    expect(math.approxEqAbs(f64, r.fpart, 0.0, epsilon));
 
     r = modf64(2.545);
-    expect(math.approxEq(f64, r.ipart, 2.0, epsilon));
-    expect(math.approxEq(f64, r.fpart, 0.545, epsilon));
+    expect(math.approxEqAbs(f64, r.ipart, 2.0, epsilon));
+    expect(math.approxEqAbs(f64, r.fpart, 0.545, epsilon));
 
     r = modf64(3.978123);
-    expect(math.approxEq(f64, r.ipart, 3.0, epsilon));
-    expect(math.approxEq(f64, r.fpart, 0.978123, epsilon));
+    expect(math.approxEqAbs(f64, r.ipart, 3.0, epsilon));
+    expect(math.approxEqAbs(f64, r.fpart, 0.978123, epsilon));
 
     r = modf64(43874.3);
-    expect(math.approxEq(f64, r.ipart, 43874, epsilon));
-    expect(math.approxEq(f64, r.fpart, 0.3, epsilon));
+    expect(math.approxEqAbs(f64, r.ipart, 43874, epsilon));
+    expect(math.approxEqAbs(f64, r.fpart, 0.3, epsilon));
 
     r = modf64(1234.340780);
-    expect(math.approxEq(f64, r.ipart, 1234, epsilon));
-    expect(math.approxEq(f64, r.fpart, 0.340780, epsilon));
+    expect(math.approxEqAbs(f64, r.ipart, 1234, epsilon));
+    expect(math.approxEqAbs(f64, r.fpart, 0.340780, epsilon));
 }
 
 test "math.modf32.special" {
diff --git a/lib/std/math/pow.zig b/lib/std/math/pow.zig
index ba88a7d95363f5013e2842d6df46ec7f4956cd9a..d4ea8876cc4ef4cbefa823da1467db588e762857 100644
--- a/lib/std/math/pow.zig
+++ b/lib/std/math/pow.zig
@@ -191,19 +191,19 @@ fn isOddInteger(x: f64) bool {
 test "math.pow" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, pow(f32, 0.0, 3.3), 0.0, epsilon));
-    expect(math.approxEq(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon));
-    expect(math.approxEq(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon));
-    expect(math.approxEq(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon));
-    expect(math.approxEq(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon));
-    expect(math.approxEq(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, 0.0, 3.3), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon));
 
-    expect(math.approxEq(f64, pow(f64, 0.0, 3.3), 0.0, epsilon));
-    expect(math.approxEq(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon));
-    expect(math.approxEq(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon));
-    expect(math.approxEq(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon));
-    expect(math.approxEq(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon));
-    expect(math.approxEq(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon));
+    expect(math.approxEqAbs(f64, pow(f64, 0.0, 3.3), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon));
+    expect(math.approxEqAbs(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon));
+    expect(math.approxEqAbs(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon));
+    expect(math.approxEqAbs(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon));
+    expect(math.approxEqAbs(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon));
 }
 
 test "math.pow.special" {
@@ -230,8 +230,8 @@ test "math.pow.special" {
     expect(pow(f32, -0.0, 1.0) == -0.0);
     expect(pow(f32, 0.0, 2.0) == 0.0);
     expect(pow(f32, -0.0, 2.0) == 0.0);
-    expect(math.approxEq(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon));
-    expect(math.approxEq(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon));
+    expect(math.approxEqAbs(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon));
     expect(math.isPositiveInf(pow(f32, 1.2, math.inf(f32))));
     expect(math.isPositiveInf(pow(f32, -1.2, math.inf(f32))));
     expect(pow(f32, 1.2, -math.inf(f32)) == 0.0);
diff --git a/lib/std/math/sin.zig b/lib/std/math/sin.zig
index d2d49743ec87ed1d75a2ac36db80f0f69f30e382..0f30e6749f5420bf7b0e717c8dcaa137122974ba 100644
--- a/lib/std/math/sin.zig
+++ b/lib/std/math/sin.zig
@@ -97,25 +97,25 @@ test "math.sin" {
 test "math.sin32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, sin_(f32, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, sin_(f32, 0.2), 0.198669, epsilon));
-    expect(math.approxEq(f32, sin_(f32, 0.8923), 0.778517, epsilon));
-    expect(math.approxEq(f32, sin_(f32, 1.5), 0.997495, epsilon));
-    expect(math.approxEq(f32, sin_(f32, -1.5), -0.997495, epsilon));
-    expect(math.approxEq(f32, sin_(f32, 37.45), -0.246544, epsilon));
-    expect(math.approxEq(f32, sin_(f32, 89.123), 0.916166, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, 0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, 0.2), 0.198669, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, 0.8923), 0.778517, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, 1.5), 0.997495, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, -1.5), -0.997495, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, 37.45), -0.246544, epsilon));
+    expect(math.approxEqAbs(f32, sin_(f32, 89.123), 0.916166, epsilon));
 }
 
 test "math.sin64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, sin_(f64, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, sin_(f64, 0.2), 0.198669, epsilon));
-    expect(math.approxEq(f64, sin_(f64, 0.8923), 0.778517, epsilon));
-    expect(math.approxEq(f64, sin_(f64, 1.5), 0.997495, epsilon));
-    expect(math.approxEq(f64, sin_(f64, -1.5), -0.997495, epsilon));
-    expect(math.approxEq(f64, sin_(f64, 37.45), -0.246543, epsilon));
-    expect(math.approxEq(f64, sin_(f64, 89.123), 0.916166, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, 0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, 0.2), 0.198669, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, 0.8923), 0.778517, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, 1.5), 0.997495, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, -1.5), -0.997495, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, 37.45), -0.246543, epsilon));
+    expect(math.approxEqAbs(f64, sin_(f64, 89.123), 0.916166, epsilon));
 }
 
 test "math.sin32.special" {
diff --git a/lib/std/math/sinh.zig b/lib/std/math/sinh.zig
index 1246c89cc06656b1a9aee345961bde3108b7774c..d39c7ee00224bd1a41453c7325b1cfc3788eefd0 100644
--- a/lib/std/math/sinh.zig
+++ b/lib/std/math/sinh.zig
@@ -105,27 +105,27 @@ test "math.sinh" {
 test "math.sinh32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, sinh32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, sinh32(0.2), 0.201336, epsilon));
-    expect(math.approxEq(f32, sinh32(0.8923), 1.015512, epsilon));
-    expect(math.approxEq(f32, sinh32(1.5), 2.129279, epsilon));
-    expect(math.approxEq(f32, sinh32(-0.0), -0.0, epsilon));
-    expect(math.approxEq(f32, sinh32(-0.2), -0.201336, epsilon));
-    expect(math.approxEq(f32, sinh32(-0.8923), -1.015512, epsilon));
-    expect(math.approxEq(f32, sinh32(-1.5), -2.129279, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(0.2), 0.201336, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(0.8923), 1.015512, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(1.5), 2.129279, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(-0.0), -0.0, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(-0.2), -0.201336, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(-0.8923), -1.015512, epsilon));
+    expect(math.approxEqAbs(f32, sinh32(-1.5), -2.129279, epsilon));
 }
 
 test "math.sinh64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, sinh64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, sinh64(0.2), 0.201336, epsilon));
-    expect(math.approxEq(f64, sinh64(0.8923), 1.015512, epsilon));
-    expect(math.approxEq(f64, sinh64(1.5), 2.129279, epsilon));
-    expect(math.approxEq(f64, sinh64(-0.0), -0.0, epsilon));
-    expect(math.approxEq(f64, sinh64(-0.2), -0.201336, epsilon));
-    expect(math.approxEq(f64, sinh64(-0.8923), -1.015512, epsilon));
-    expect(math.approxEq(f64, sinh64(-1.5), -2.129279, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(0.2), 0.201336, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(0.8923), 1.015512, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(1.5), 2.129279, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(-0.0), -0.0, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(-0.2), -0.201336, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(-0.8923), -1.015512, epsilon));
+    expect(math.approxEqAbs(f64, sinh64(-1.5), -2.129279, epsilon));
 }
 
 test "math.sinh32.special" {
diff --git a/lib/std/math/tan.zig b/lib/std/math/tan.zig
index 087b96c3bdecd332c0452b0ff06454ac7996be46..b80e2fbb27bdad8141d1472a52d2ea2fd4f97720 100644
--- a/lib/std/math/tan.zig
+++ b/lib/std/math/tan.zig
@@ -87,23 +87,23 @@ test "math.tan" {
 test "math.tan32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, tan_(f32, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, tan_(f32, 0.2), 0.202710, epsilon));
-    expect(math.approxEq(f32, tan_(f32, 0.8923), 1.240422, epsilon));
-    expect(math.approxEq(f32, tan_(f32, 1.5), 14.101420, epsilon));
-    expect(math.approxEq(f32, tan_(f32, 37.45), -0.254397, epsilon));
-    expect(math.approxEq(f32, tan_(f32, 89.123), 2.285852, epsilon));
+    expect(math.approxEqAbs(f32, tan_(f32, 0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, tan_(f32, 0.2), 0.202710, epsilon));
+    expect(math.approxEqAbs(f32, tan_(f32, 0.8923), 1.240422, epsilon));
+    expect(math.approxEqAbs(f32, tan_(f32, 1.5), 14.101420, epsilon));
+    expect(math.approxEqAbs(f32, tan_(f32, 37.45), -0.254397, epsilon));
+    expect(math.approxEqAbs(f32, tan_(f32, 89.123), 2.285852, epsilon));
 }
 
 test "math.tan64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, tan_(f64, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, tan_(f64, 0.2), 0.202710, epsilon));
-    expect(math.approxEq(f64, tan_(f64, 0.8923), 1.240422, epsilon));
-    expect(math.approxEq(f64, tan_(f64, 1.5), 14.101420, epsilon));
-    expect(math.approxEq(f64, tan_(f64, 37.45), -0.254397, epsilon));
-    expect(math.approxEq(f64, tan_(f64, 89.123), 2.2858376, epsilon));
+    expect(math.approxEqAbs(f64, tan_(f64, 0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, tan_(f64, 0.2), 0.202710, epsilon));
+    expect(math.approxEqAbs(f64, tan_(f64, 0.8923), 1.240422, epsilon));
+    expect(math.approxEqAbs(f64, tan_(f64, 1.5), 14.101420, epsilon));
+    expect(math.approxEqAbs(f64, tan_(f64, 37.45), -0.254397, epsilon));
+    expect(math.approxEqAbs(f64, tan_(f64, 89.123), 2.2858376, epsilon));
 }
 
 test "math.tan32.special" {
diff --git a/lib/std/math/tanh.zig b/lib/std/math/tanh.zig
index 5e5cc0accbb5b9554fb578dd845798b46ef4f1c9..81df2aed3568a102db6085aab02e960814ac9dee 100644
--- a/lib/std/math/tanh.zig
+++ b/lib/std/math/tanh.zig
@@ -131,21 +131,21 @@ test "math.tanh" {
 test "math.tanh32" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f32, tanh32(0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, tanh32(0.2), 0.197375, epsilon));
-    expect(math.approxEq(f32, tanh32(0.8923), 0.712528, epsilon));
-    expect(math.approxEq(f32, tanh32(1.5), 0.905148, epsilon));
-    expect(math.approxEq(f32, tanh32(37.45), 1.0, epsilon));
+    expect(math.approxEqAbs(f32, tanh32(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f32, tanh32(0.2), 0.197375, epsilon));
+    expect(math.approxEqAbs(f32, tanh32(0.8923), 0.712528, epsilon));
+    expect(math.approxEqAbs(f32, tanh32(1.5), 0.905148, epsilon));
+    expect(math.approxEqAbs(f32, tanh32(37.45), 1.0, epsilon));
 }
 
 test "math.tanh64" {
     const epsilon = 0.000001;
 
-    expect(math.approxEq(f64, tanh64(0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, tanh64(0.2), 0.197375, epsilon));
-    expect(math.approxEq(f64, tanh64(0.8923), 0.712528, epsilon));
-    expect(math.approxEq(f64, tanh64(1.5), 0.905148, epsilon));
-    expect(math.approxEq(f64, tanh64(37.45), 1.0, epsilon));
+    expect(math.approxEqAbs(f64, tanh64(0.0), 0.0, epsilon));
+    expect(math.approxEqAbs(f64, tanh64(0.2), 0.197375, epsilon));
+    expect(math.approxEqAbs(f64, tanh64(0.8923), 0.712528, epsilon));
+    expect(math.approxEqAbs(f64, tanh64(1.5), 0.905148, epsilon));
+    expect(math.approxEqAbs(f64, tanh64(37.45), 1.0, epsilon));
 }
 
 test "math.tanh32.special" {
diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig
index 462dcb537f24a4ff87689d7ade6e1d94480cb539..55548e399e9c1d173505be80732447d64c43b1fa 100644
--- a/lib/std/special/c.zig
+++ b/lib/std/special/c.zig
@@ -912,14 +912,14 @@ test "sqrt" {
     const epsilon = 0.000001;
 
     std.testing.expect(sqrt(0.0) == 0.0);
-    std.testing.expect(std.math.approxEq(f64, sqrt(2.0), 1.414214, epsilon));
-    std.testing.expect(std.math.approxEq(f64, sqrt(3.6), 1.897367, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f64, sqrt(2.0), 1.414214, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f64, sqrt(3.6), 1.897367, epsilon));
     std.testing.expect(sqrt(4.0) == 2.0);
-    std.testing.expect(std.math.approxEq(f64, sqrt(7.539840), 2.745877, epsilon));
-    std.testing.expect(std.math.approxEq(f64, sqrt(19.230934), 4.385309, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f64, sqrt(7.539840), 2.745877, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f64, sqrt(19.230934), 4.385309, epsilon));
     std.testing.expect(sqrt(64.0) == 8.0);
-    std.testing.expect(std.math.approxEq(f64, sqrt(64.1), 8.006248, epsilon));
-    std.testing.expect(std.math.approxEq(f64, sqrt(8942.230469), 94.563367, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f64, sqrt(64.1), 8.006248, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f64, sqrt(8942.230469), 94.563367, epsilon));
 }
 
 test "sqrt special" {
@@ -1010,14 +1010,14 @@ test "sqrtf" {
     const epsilon = 0.000001;
 
     std.testing.expect(sqrtf(0.0) == 0.0);
-    std.testing.expect(std.math.approxEq(f32, sqrtf(2.0), 1.414214, epsilon));
-    std.testing.expect(std.math.approxEq(f32, sqrtf(3.6), 1.897367, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f32, sqrtf(2.0), 1.414214, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f32, sqrtf(3.6), 1.897367, epsilon));
     std.testing.expect(sqrtf(4.0) == 2.0);
-    std.testing.expect(std.math.approxEq(f32, sqrtf(7.539840), 2.745877, epsilon));
-    std.testing.expect(std.math.approxEq(f32, sqrtf(19.230934), 4.385309, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f32, sqrtf(7.539840), 2.745877, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f32, sqrtf(19.230934), 4.385309, epsilon));
     std.testing.expect(sqrtf(64.0) == 8.0);
-    std.testing.expect(std.math.approxEq(f32, sqrtf(64.1), 8.006248, epsilon));
-    std.testing.expect(std.math.approxEq(f32, sqrtf(8942.230469), 94.563370, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f32, sqrtf(64.1), 8.006248, epsilon));
+    std.testing.expect(std.math.approxEqAbs(f32, sqrtf(8942.230469), 94.563370, epsilon));
 }
 
 test "sqrtf special" {
diff --git a/test/stage1/behavior/floatop.zig b/test/stage1/behavior/floatop.zig
index 01ad68fe0c831ca2992f59804e4fd6a06b10ccb9..9f2e45ed26130cd4efbcccebf782d57edea5548b 100644
--- a/test/stage1/behavior/floatop.zig
+++ b/test/stage1/behavior/floatop.zig
@@ -21,7 +21,7 @@ fn testSqrt() void {
         var a: f32 = 9;
         expect(@sqrt(a) == 3);
         var b: f32 = 1.1;
-        expect(math.approxEq(f32, @sqrt(b), 1.0488088481701516, epsilon));
+        expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon));
     }
     {
         var a: f64 = 25;
@@ -39,24 +39,24 @@ fn testSqrt() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
         var result = @sqrt(v);
-        expect(math.approxEq(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
     }
 }
 
 test "more @sqrt f16 tests" {
     // TODO these are not all passing at comptime
     expect(@sqrt(@as(f16, 0.0)) == 0.0);
-    expect(math.approxEq(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
-    expect(math.approxEq(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
+    expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
+    expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
     expect(@sqrt(@as(f16, 4.0)) == 2.0);
-    expect(math.approxEq(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
-    expect(math.approxEq(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
+    expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
+    expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
     expect(@sqrt(@as(f16, 64.0)) == 8.0);
-    expect(math.approxEq(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
-    expect(math.approxEq(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
+    expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
+    expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
 
     // special cases
     expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16)))));
@@ -89,10 +89,10 @@ fn testSin() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
         var result = @sin(v);
-        expect(math.approxEq(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
     }
 }
 
@@ -119,10 +119,10 @@ fn testCos() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
         var result = @cos(v);
-        expect(math.approxEq(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
     }
 }
 
@@ -149,10 +149,10 @@ fn testExp() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
         var result = @exp(v);
-        expect(math.approxEq(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
     }
 }
 
@@ -179,10 +179,10 @@ fn testExp2() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
         var result = @exp2(v);
-        expect(math.approxEq(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
     }
 }
 
@@ -198,7 +198,7 @@ fn testLog() void {
     // https://github.com/ziglang/zig/issues/4026
     {
         var a: f16 = e;
-        expect(math.approxEq(f16, @log(a), 1, epsilon));
+        expect(math.approxEqAbs(f16, @log(a), 1, epsilon));
     }
     {
         var a: f32 = e;
@@ -211,10 +211,10 @@ fn testLog() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
         var result = @log(v);
-        expect(math.approxEq(f32, @log(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @log(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @log(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @log(@as(f32, 0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon));
     }
 }
 
@@ -241,10 +241,10 @@ fn testLog2() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
         var result = @log2(v);
-        expect(math.approxEq(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
     }
 }
 
@@ -271,10 +271,10 @@ fn testLog10() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
         var result = @log10(v);
-        expect(math.approxEq(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
     }
 }
 
@@ -307,10 +307,10 @@ fn testFabs() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
         var result = @fabs(v);
-        expect(math.approxEq(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
     }
 }
 
@@ -337,10 +337,10 @@ fn testFloor() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
         var result = @floor(v);
-        expect(math.approxEq(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
     }
 }
 
@@ -367,10 +367,10 @@ fn testCeil() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
         var result = @ceil(v);
-        expect(math.approxEq(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
     }
 }
 
@@ -397,10 +397,10 @@ fn testTrunc() void {
     {
         var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
         var result = @trunc(v);
-        expect(math.approxEq(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
-        expect(math.approxEq(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
-        expect(math.approxEq(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
-        expect(math.approxEq(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
+        expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
+        expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
+        expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
+        expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
     }
 }