Merge pull request #17248 from antlilja/abs

Replace @fabs builtin with new @abs builtin

3 files changed, 410 insertions, 36 deletions

diff --git a/test/behavior/abs.zig b/test/behavior/abs.zig
new file mode 100644
index 0000000000..eefea306c4
--- /dev/null
+++ b/test/behavior/abs.zig
@@ -0,0 +1,371 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const expect = std.testing.expect;
+
+test "@abs integers" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try comptime testAbsIntegers();
+    try testAbsIntegers();
+}
+
+fn testAbsIntegers() !void {
+    {
+        var x: i32 = -1000;
+        try expect(@abs(x) == 1000);
+    }
+    {
+        var x: i32 = 0;
+        try expect(@abs(x) == 0);
+    }
+    {
+        var x: i32 = 1000;
+        try expect(@abs(x) == 1000);
+    }
+    {
+        var x: i64 = std.math.minInt(i64);
+        try expect(@abs(x) == @as(u64, -std.math.minInt(i64)));
+    }
+    {
+        var x: i5 = -1;
+        try expect(@abs(x) == 1);
+    }
+    {
+        var x: i5 = -5;
+        try expect(@abs(x) == 5);
+    }
+    comptime {
+        try expect(@abs(@as(i2, -2)) == 2);
+    }
+}
+
+test "@abs unsigned integers" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try comptime testAbsUnsignedIntegers();
+    try testAbsUnsignedIntegers();
+}
+
+fn testAbsUnsignedIntegers() !void {
+    {
+        var x: u32 = 1000;
+        try expect(@abs(x) == 1000);
+    }
+    {
+        var x: u32 = 0;
+        try expect(@abs(x) == 0);
+    }
+    {
+        var x: u32 = 1000;
+        try expect(@abs(x) == 1000);
+    }
+    {
+        var x: u5 = 1;
+        try expect(@abs(x) == 1);
+    }
+    {
+        var x: u5 = 5;
+        try expect(@abs(x) == 5);
+    }
+    comptime {
+        try expect(@abs(@as(u2, 2)) == 2);
+    }
+}
+
+test "@abs floats" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try comptime testAbsFloats(f16);
+    if (builtin.zig_backend != .stage2_x86_64) try testAbsFloats(f16);
+    try comptime testAbsFloats(f32);
+    try testAbsFloats(f32);
+    try comptime testAbsFloats(f64);
+    try testAbsFloats(f64);
+    try comptime testAbsFloats(f80);
+    if (builtin.zig_backend != .stage2_x86_64 and builtin.zig_backend != .stage2_wasm) try testAbsFloats(f80);
+    try comptime testAbsFloats(f128);
+    if (builtin.zig_backend != .stage2_x86_64 and builtin.zig_backend != .stage2_wasm) try testAbsFloats(f128);
+}
+
+fn testAbsFloats(comptime T: type) !void {
+    {
+        var x: T = -2.62;
+        try expect(@abs(x) == 2.62);
+    }
+    {
+        var x: T = 2.62;
+        try expect(@abs(x) == 2.62);
+    }
+    {
+        var x: T = 0.0;
+        try expect(@abs(x) == 0.0);
+    }
+    {
+        var x: T = -std.math.pi;
+        try expect(@abs(x) == std.math.pi);
+    }
+
+    {
+        var x: T = -std.math.inf(T);
+        try expect(@abs(x) == std.math.inf(T));
+    }
+    {
+        var x: T = std.math.inf(T);
+        try expect(@abs(x) == std.math.inf(T));
+    }
+    comptime {
+        try expect(@abs(@as(T, -std.math.e)) == std.math.e);
+    }
+}
+
+test "@abs int vectors" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try comptime testAbsIntVectors(1);
+    try testAbsIntVectors(1);
+    try comptime testAbsIntVectors(2);
+    try testAbsIntVectors(2);
+    try comptime testAbsIntVectors(3);
+    try testAbsIntVectors(3);
+    try comptime testAbsIntVectors(4);
+    try testAbsIntVectors(4);
+    try comptime testAbsIntVectors(8);
+    try testAbsIntVectors(8);
+    try comptime testAbsIntVectors(16);
+    try testAbsIntVectors(16);
+    try comptime testAbsIntVectors(17);
+    try testAbsIntVectors(17);
+}
+
+fn testAbsIntVectors(comptime len: comptime_int) !void {
+    const I32 = @Vector(len, i32);
+    const U32 = @Vector(len, u32);
+    const I64 = @Vector(len, i64);
+    const U64 = @Vector(len, u64);
+    {
+        var x: I32 = @splat(-10);
+        var y: U32 = @splat(10);
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+    {
+        var x: I32 = @splat(10);
+        var y: U32 = @splat(10);
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+    {
+        var x: I32 = @splat(0);
+        var y: U32 = @splat(0);
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+    {
+        var x: I64 = @splat(-10);
+        var y: U64 = @splat(10);
+        try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
+    }
+    {
+        var x: I64 = @splat(std.math.minInt(i64));
+        var y: U64 = @splat(-std.math.minInt(i64));
+        try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
+    }
+    {
+        var x = std.simd.repeat(len, @Vector(4, i32){ -2, 5, std.math.minInt(i32), -7 });
+        var y = std.simd.repeat(len, @Vector(4, u32){ 2, 5, -std.math.minInt(i32), 7 });
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+}
+
+test "@abs unsigned int vectors" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    try comptime testAbsUnsignedIntVectors(1);
+    try testAbsUnsignedIntVectors(1);
+    try comptime testAbsUnsignedIntVectors(2);
+    try testAbsUnsignedIntVectors(2);
+    try comptime testAbsUnsignedIntVectors(3);
+    try testAbsUnsignedIntVectors(3);
+    try comptime testAbsUnsignedIntVectors(4);
+    try testAbsUnsignedIntVectors(4);
+    try comptime testAbsUnsignedIntVectors(8);
+    try testAbsUnsignedIntVectors(8);
+    try comptime testAbsUnsignedIntVectors(16);
+    try testAbsUnsignedIntVectors(16);
+    try comptime testAbsUnsignedIntVectors(17);
+    try testAbsUnsignedIntVectors(17);
+}
+
+fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {
+    const U32 = @Vector(len, u32);
+    const U64 = @Vector(len, u64);
+    {
+        var x: U32 = @splat(10);
+        var y: U32 = @splat(10);
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+    {
+        var x: U32 = @splat(10);
+        var y: U32 = @splat(10);
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+    {
+        var x: U32 = @splat(0);
+        var y: U32 = @splat(0);
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+    {
+        var x: U64 = @splat(10);
+        var y: U64 = @splat(10);
+        try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
+    }
+    {
+        var x = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
+        var y = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
+        try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
+    }
+}
+
+test "@abs float vectors" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    // https://github.com/ziglang/zig/issues/12827
+    if (builtin.zig_backend == .stage2_llvm and
+        builtin.os.tag == .macos and
+        builtin.target.cpu.arch == .x86_64) return error.SkipZigTest;
+
+    @setEvalBranchQuota(2000);
+    try comptime testAbsFloatVectors(f16, 1);
+    try testAbsFloatVectors(f16, 1);
+    try comptime testAbsFloatVectors(f16, 2);
+    try testAbsFloatVectors(f16, 2);
+    try comptime testAbsFloatVectors(f16, 3);
+    try testAbsFloatVectors(f16, 3);
+    try comptime testAbsFloatVectors(f16, 4);
+    try testAbsFloatVectors(f16, 4);
+    try comptime testAbsFloatVectors(f16, 8);
+    try testAbsFloatVectors(f16, 8);
+    try comptime testAbsFloatVectors(f16, 16);
+    try testAbsFloatVectors(f16, 16);
+    try comptime testAbsFloatVectors(f16, 17);
+
+    try testAbsFloatVectors(f32, 17);
+    try comptime testAbsFloatVectors(f32, 1);
+    try testAbsFloatVectors(f32, 1);
+    try comptime testAbsFloatVectors(f32, 2);
+    try testAbsFloatVectors(f32, 2);
+    try comptime testAbsFloatVectors(f32, 3);
+    try testAbsFloatVectors(f32, 3);
+    try comptime testAbsFloatVectors(f32, 4);
+    try testAbsFloatVectors(f32, 4);
+    try comptime testAbsFloatVectors(f32, 8);
+    try testAbsFloatVectors(f32, 8);
+    try comptime testAbsFloatVectors(f32, 16);
+    try testAbsFloatVectors(f32, 16);
+    try comptime testAbsFloatVectors(f32, 17);
+    try testAbsFloatVectors(f32, 17);
+
+    try comptime testAbsFloatVectors(f64, 1);
+    try testAbsFloatVectors(f64, 1);
+    try comptime testAbsFloatVectors(f64, 2);
+    try testAbsFloatVectors(f64, 2);
+    try comptime testAbsFloatVectors(f64, 3);
+    try testAbsFloatVectors(f64, 3);
+    try comptime testAbsFloatVectors(f64, 4);
+    try testAbsFloatVectors(f64, 4);
+    try comptime testAbsFloatVectors(f64, 8);
+    try testAbsFloatVectors(f64, 8);
+    try comptime testAbsFloatVectors(f64, 16);
+    try testAbsFloatVectors(f64, 16);
+    try comptime testAbsFloatVectors(f64, 17);
+    try testAbsFloatVectors(f64, 17);
+
+    try comptime testAbsFloatVectors(f80, 1);
+    try testAbsFloatVectors(f80, 1);
+    try comptime testAbsFloatVectors(f80, 2);
+    try testAbsFloatVectors(f80, 2);
+    try comptime testAbsFloatVectors(f80, 3);
+    try testAbsFloatVectors(f80, 3);
+    try comptime testAbsFloatVectors(f80, 4);
+    try testAbsFloatVectors(f80, 4);
+    try comptime testAbsFloatVectors(f80, 8);
+    try testAbsFloatVectors(f80, 8);
+    try comptime testAbsFloatVectors(f80, 16);
+    try testAbsFloatVectors(f80, 16);
+    try comptime testAbsFloatVectors(f80, 17);
+    try testAbsFloatVectors(f80, 17);
+
+    try comptime testAbsFloatVectors(f128, 1);
+    try testAbsFloatVectors(f128, 1);
+    try comptime testAbsFloatVectors(f128, 2);
+    try testAbsFloatVectors(f128, 2);
+    try comptime testAbsFloatVectors(f128, 3);
+    try testAbsFloatVectors(f128, 3);
+    try comptime testAbsFloatVectors(f128, 4);
+    try testAbsFloatVectors(f128, 4);
+    try comptime testAbsFloatVectors(f128, 8);
+    try testAbsFloatVectors(f128, 8);
+    try comptime testAbsFloatVectors(f128, 16);
+    try testAbsFloatVectors(f128, 16);
+    try comptime testAbsFloatVectors(f128, 17);
+    try testAbsFloatVectors(f128, 17);
+}
+
+fn testAbsFloatVectors(comptime T: type, comptime len: comptime_int) !void {
+    const V = @Vector(len, T);
+    {
+        var x: V = @splat(-7.5);
+        var y: V = @splat(7.5);
+        try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
+    }
+    {
+        var x: V = @splat(7.5);
+        var y: V = @splat(7.5);
+        try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
+    }
+    {
+        var x: V = @splat(0.0);
+        var y: V = @splat(0.0);
+        try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
+    }
+    {
+        var x: V = @splat(-std.math.pi);
+        var y: V = @splat(std.math.pi);
+        try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
+    }
+    {
+        var x: V = @splat(std.math.pi);
+        var y: V = @splat(std.math.pi);
+        try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
+    }
+}
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index 33460b827e..7ac965d5b4 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -523,7 +523,7 @@ fn testLog10WithVectors() !void {
     try expect(@log10(@as(f32, 0.4)) == result[3]);
 }
 
-test "@fabs" {
+test "@abs" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -533,24 +533,24 @@ test "@fabs" {
 }
 
 fn testFabs() !void {
-    try expect(@fabs(@as(f16, -2.5)) == 2.5);
-    try expect(@fabs(@as(f16, 2.5)) == 2.5);
-    try expect(@fabs(@as(f32, -2.5)) == 2.5);
-    try expect(@fabs(@as(f32, 2.5)) == 2.5);
-    try expect(@fabs(@as(f64, -2.5)) == 2.5);
-    try expect(@fabs(@as(f64, 2.5)) == 2.5);
+    try expect(@abs(@as(f16, -2.5)) == 2.5);
+    try expect(@abs(@as(f16, 2.5)) == 2.5);
+    try expect(@abs(@as(f32, -2.5)) == 2.5);
+    try expect(@abs(@as(f32, 2.5)) == 2.5);
+    try expect(@abs(@as(f64, -2.5)) == 2.5);
+    try expect(@abs(@as(f64, 2.5)) == 2.5);
 
     // TODO test f128, and c_longdouble
     // https://github.com/ziglang/zig/issues/4026
     // {
     //     var a: f80 = -2.5;
     //     var b: f80 = 2.5;
-    //     try expect(@fabs(a) == 2.5);
-    //     try expect(@fabs(b) == 2.5);
+    //     try expect(@abs(a) == 2.5);
+    //     try expect(@abs(b) == 2.5);
     // }
 }
 
-test "@fabs with vectors" {
+test "@abs with vectors" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -562,14 +562,15 @@ test "@fabs with vectors" {
 
 fn testFabsWithVectors() !void {
     var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
-    var result = @fabs(v);
-    try expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
-    try expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
-    try expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
-    try expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
+    var result = @abs(v);
+    try expect(math.approxEqAbs(f32, @abs(@as(f32, 1.1)), result[0], epsilon));
+    try expect(math.approxEqAbs(f32, @abs(@as(f32, -2.2)), result[1], epsilon));
+    try expect(math.approxEqAbs(f32, @abs(@as(f32, 0.3)), result[2], epsilon));
+    try expect(math.approxEqAbs(f32, @abs(@as(f32, -0.4)), result[3], epsilon));
 }
 
-test "another, possibly redundant, @fabs test" {
+test "another, possibly redundant, @abs test" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -587,11 +588,12 @@ test "another, possibly redundant, @fabs test" {
 
     const x = 14.0;
     const y = -x;
-    const z = @fabs(y);
+    const z = @abs(y);
     try comptime std.testing.expectEqual(x, z);
 }
 
-test "@fabs f80" {
+test "@abs f80" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -604,11 +606,12 @@ test "@fabs f80" {
 
 fn testFabsLegacy(comptime T: type, x: T) !void {
     const y = -x;
-    const z = @fabs(y);
+    const z = @abs(y);
     try expect(x == z);
 }
 
-test "a third @fabs test, surely there should not be three fabs tests" {
+test "a third @abs test, surely there should not be three fabs tests" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -617,23 +620,23 @@ test "a third @fabs test, surely there should not be three fabs tests" {
 
     inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
         // normals
-        try expect(@fabs(@as(T, 1.0)) == 1.0);
-        try expect(@fabs(@as(T, -1.0)) == 1.0);
-        try expect(@fabs(math.floatMin(T)) == math.floatMin(T));
-        try expect(@fabs(-math.floatMin(T)) == math.floatMin(T));
-        try expect(@fabs(math.floatMax(T)) == math.floatMax(T));
-        try expect(@fabs(-math.floatMax(T)) == math.floatMax(T));
+        try expect(@abs(@as(T, 1.0)) == 1.0);
+        try expect(@abs(@as(T, -1.0)) == 1.0);
+        try expect(@abs(math.floatMin(T)) == math.floatMin(T));
+        try expect(@abs(-math.floatMin(T)) == math.floatMin(T));
+        try expect(@abs(math.floatMax(T)) == math.floatMax(T));
+        try expect(@abs(-math.floatMax(T)) == math.floatMax(T));
 
         // subnormals
-        try expect(@fabs(@as(T, 0.0)) == 0.0);
-        try expect(@fabs(@as(T, -0.0)) == 0.0);
-        try expect(@fabs(math.floatTrueMin(T)) == math.floatTrueMin(T));
-        try expect(@fabs(-math.floatTrueMin(T)) == math.floatTrueMin(T));
+        try expect(@abs(@as(T, 0.0)) == 0.0);
+        try expect(@abs(@as(T, -0.0)) == 0.0);
+        try expect(@abs(math.floatTrueMin(T)) == math.floatTrueMin(T));
+        try expect(@abs(-math.floatTrueMin(T)) == math.floatTrueMin(T));
 
         // non-finite numbers
-        try expect(math.isPositiveInf(@fabs(math.inf(T))));
-        try expect(math.isPositiveInf(@fabs(-math.inf(T))));
-        try expect(math.isNan(@fabs(math.nan(T))));
+        try expect(math.isPositiveInf(@abs(math.inf(T))));
+        try expect(math.isPositiveInf(@abs(-math.inf(T))));
+        try expect(math.isNan(@abs(math.nan(T))));
     }
 }
 
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index 9e4ec783e7..18c39e7b8e 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -1391,7 +1391,7 @@ fn frem(comptime T: type) !void {
 }
 
 fn fremOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
-    try expect(@fabs(@rem(a, b) - c) < epsilon);
+    try expect(@abs(@rem(a, b) - c) < epsilon);
 }
 
 test "float modulo division using @mod" {
@@ -1434,7 +1434,7 @@ fn fmod(comptime T: type) !void {
 }
 
 fn fmodOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
-    try expect(@fabs(@mod(@as(T, a), @as(T, b)) - @as(T, c)) < epsilon);
+    try expect(@abs(@mod(@as(T, a), @as(T, b)) - @as(T, c)) < epsilon);
 }
 
 test "@round" {
@@ -1627,7 +1627,7 @@ fn testAbsFloat() !void {
     try testAbsFloatOne(10.05, 10.05);
 }
 fn testAbsFloatOne(in: f32, out: f32) !void {
-    try expect(@fabs(@as(f32, in)) == @as(f32, out));
+    try expect(@abs(@as(f32, in)) == @as(f32, out));
 }
 
 test "mod lazy values" {