@zigc/lib 0.16.0-dev.3091 → 0.16.0-dev.3121

package/c/math.zig

@@ -36,6 +36,8 @@ comptime {
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&coshf, "coshf");
+        symbol(&frexpf, "frexpf");
+        symbol(&frexpl, "frexpl");
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
         symbol(&modff, "modff");
@@ -46,6 +48,11 @@ comptime {
         symbol(&tanhf, "tanhf");
     }
 
+    if (builtin.target.isMinGW() or builtin.target.isMuslLibC()) {
+        symbol(&rint, "rint");
+        symbol(&rintf, "rintf");
+    }
+
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&acos, "acos");
         symbol(&acosf, "acosf");
@@ -60,7 +67,12 @@ comptime {
         symbol(&exp10, "exp10");
         symbol(&exp10f, "exp10f");
         symbol(&fdim, "fdim");
+        symbol(&finite, "finite");
+        symbol(&finitef, "finitef");
+        symbol(&frexp, "frexp");
         symbol(&hypot, "hypot");
+        symbol(&lrint, "lrint");
+        symbol(&lrintf, "lrintf");
         symbol(&modf, "modf");
         symbol(&pow, "pow");
         symbol(&pow10, "pow10");
@@ -71,7 +83,6 @@ comptime {
     if (builtin.target.isMuslLibC()) {
         symbol(&copysign, "copysign");
         symbol(&copysignf, "copysignf");
-        symbol(&rint, "rint");
     }
 
     symbol(&copysignl, "copysignl");
@@ -161,6 +172,45 @@ fn fdim(x: f64, y: f64) callconv(.c) f64 {
     return 0;
 }
 
+fn finite(x: f64) callconv(.c) c_int {
+    return if (math.isFinite(x)) 1 else 0;
+}
+
+fn finitef(x: f32) callconv(.c) c_int {
+    return if (math.isFinite(x)) 1 else 0;
+}
+
+fn frexpGeneric(comptime T: type, x: T, e: *c_int) T {
+    // libc expects `*e` to be unspecified in this case; an unspecified C value
+    // should be a valid value of the relevant type, yet Zig's std
+    // implementation sets it to `undefined` -- which can even be nonsense
+    // according to the type (int). Therefore, we're setting it to a valid
+    // int value in Zig -- a zero.
+    //
+    // This mirrors the handling of infinities, where libc also expects
+    // unspecified for the value of `*e` and Zig std sets it to a zero.
+    if (math.isNan(x)) {
+        e.* = 0;
+        return x;
+    }
+
+    const r = math.frexp(x);
+    e.* = r.exponent;
+    return r.significand;
+}
+
+fn frexp(x: f64, e: *c_int) callconv(.c) f64 {
+    return frexpGeneric(f64, x, e);
+}
+
+fn frexpf(x: f32, e: *c_int) callconv(.c) f32 {
+    return frexpGeneric(f32, x, e);
+}
+
+fn frexpl(x: c_longdouble, e: *c_int) callconv(.c) c_longdouble {
+    return frexpGeneric(c_longdouble, x, e);
+}
+
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
     return math.hypot(x, y);
 }
@@ -185,6 +235,14 @@ fn isnanl(x: c_longdouble) callconv(.c) c_int {
     return if (math.isNan(x)) 1 else 0;
 }
 
+fn lrint(x: f64) callconv(.c) c_long {
+    return @intFromFloat(rint(x));
+}
+
+fn lrintf(x: f32) callconv(.c) c_long {
+    return @intFromFloat(rintf(x));
+}
+
 fn modfGeneric(comptime T: type, x: T, iptr: *T) T {
     if (math.isNegativeInf(x)) {
         iptr.* = -math.inf(T);
@@ -299,7 +357,7 @@ fn pow10f(x: f32) callconv(.c) f32 {
 }
 
 fn rint(x: f64) callconv(.c) f64 {
-    const toint: f64 = 1.0 / @as(f64, math.floatEps(f64));
+    const toint: f64 = 1.0 / math.floatEps(f64);
     const a: u64 = @bitCast(x);
     const e = a >> 52 & 0x7ff;
     const s = a >> 63;
@@ -319,39 +377,70 @@ fn rint(x: f64) callconv(.c) f64 {
     return y;
 }
 
-test "rint" {
+fn rintf(x: f32) callconv(.c) f32 {
+    const toint: f32 = 1.0 / math.floatEps(f32);
+    const a: u32 = @bitCast(x);
+    const e = a >> 23 & 0xff;
+    const s = a >> 31;
+    var y: f32 = undefined;
+
+    if (e >= 0x7f + 23) {
+        return x;
+    }
+
+    if (s == 1) {
+        y = x - toint + toint;
+    } else {
+        y = x + toint - toint;
+    }
+
+    if (y == 0) {
+        return if (s == 1) -0.0 else 0;
+    }
+    return y;
+}
+
+fn testRint(comptime T: type) !void {
+    const f = switch (T) {
+        f32 => rintf,
+        f64 => rint,
+        else => @compileError("rint not implemented for" ++ @typeName(T)),
+    };
+
     // Positive numbers round correctly
-    try expectEqual(@as(f64, 42.0), rint(42.2));
-    try expectEqual(@as(f64, 42.0), rint(41.8));
+    try expectEqual(@as(T, 42.0), f(42.2));
+    try expectEqual(@as(T, 42.0), f(41.8));
 
     // Negative numbers round correctly
-    try expectEqual(@as(f64, -6.0), rint(-5.9));
-    try expectEqual(@as(f64, -6.0), rint(-6.1));
+    try expectEqual(@as(T, -6.0), f(-5.9));
+    try expectEqual(@as(T, -6.0), f(-6.1));
 
     // No rounding needed test
-    try expectEqual(@as(f64, 5.0), rint(5.0));
-    try expectEqual(@as(f64, -10.0), rint(-10.0));
-    try expectEqual(@as(f64, 0.0), rint(0.0));
+    try expectEqual(@as(T, 5.0), f(5.0));
+    try expectEqual(@as(T, -10.0), f(-10.0));
+    try expectEqual(@as(T, 0.0), f(0.0));
 
     // Very large numbers return unchanged
-    const large: f64 = 9007199254740992.0; // 2^53
-    try expectEqual(large, rint(large));
-    try expectEqual(-large, rint(-large));
+    const large: T = 9007199254740992.0; // 2^53
+    try expectEqual(large, f(large));
+    try expectEqual(-large, f(-large));
 
     // Small positive numbers round to zero
-    const pos_result = rint(0.3);
-    try expectEqual(@as(f64, 0.0), pos_result);
-    try expect(@as(u64, @bitCast(pos_result)) == 0);
+    const pos_result = f(0.3);
+    try expect(math.isPositiveZero(pos_result));
 
     // Small negative numbers round to negative zero
-    const neg_result = rint(-0.3);
-    try expectEqual(@as(f64, 0.0), neg_result);
-    const bits: u64 = @bitCast(neg_result);
-    try expect((bits >> 63) == 1);
+    const neg_result = f(-0.3);
+    try expect(math.isNegativeZero(neg_result));
 
     // Exact half rounds to nearest even (banker's rounding)
-    try expectEqual(@as(f64, 2.0), rint(2.5));
-    try expectEqual(@as(f64, 4.0), rint(3.5));
+    try expectEqual(@as(T, 2.0), f(2.5));
+    try expectEqual(@as(T, 4.0), f(3.5));
+}
+
+test "rint" {
+    try testRint(f32);
+    try testRint(f64);
 }
 
 fn tanh(x: f64) callconv(.c) f64 {

package/compiler_rt/cos.zig

@@ -1,19 +1,30 @@
+//! Ported from musl, which is licensed under the MIT license:
+//! https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//!
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/cosf.c
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/cos.c
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/cosl.c
+
 const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+const expectApproxEqAbs = std.testing.expectApproxEqAbs;
 
 const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
+const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
+const ld = @import("long_double.zig");
 
 comptime {
-    symbol(&__cosh, "__cosh");
+    symbol(&cosh, "__cosh");
+    symbol(&cosl, "__cosl");
     symbol(&cosf, "cosf");
     symbol(&cos, "cos");
-    symbol(&__cosx, "__cosx");
+    symbol(&cosx, "__cosx");
     if (compiler_rt.want_ppc_abi) {
         symbol(&cosq, "cosf128");
     }
@@ -21,7 +32,7 @@ comptime {
     symbol(&cosl, "cosl");
 }
 
-pub fn __cosh(a: f16) callconv(.c) f16 {
+pub fn cosh(a: f16) callconv(.c) f16 {
     // TODO: more efficient implementation
     return @floatCast(cosf(a));
 }
@@ -43,27 +54,27 @@ pub fn cosf(x: f32) callconv(.c) f32 {
             if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
             return 1.0;
         }
-        return trig.__cosdf(x);
+        return trig.cosdf(x);
     }
     if (ix <= 0x407b53d1) { // |x| ~<= 5*pi/4
         if (ix > 0x4016cbe3) { // |x|  ~> 3*pi/4
-            return -trig.__cosdf(if (sign) x + c2pio2 else x - c2pio2);
+            return -trig.cosdf(if (sign) x + c2pio2 else x - c2pio2);
         } else {
             if (sign) {
-                return trig.__sindf(x + c1pio2);
+                return trig.sindf(x + c1pio2);
             } else {
-                return trig.__sindf(c1pio2 - x);
+                return trig.sindf(c1pio2 - x);
             }
         }
     }
     if (ix <= 0x40e231d5) { // |x| ~<= 9*pi/4
         if (ix > 0x40afeddf) { // |x| ~> 7*pi/4
-            return trig.__cosdf(if (sign) x + c4pio2 else x - c4pio2);
+            return trig.cosdf(if (sign) x + c4pio2 else x - c4pio2);
         } else {
             if (sign) {
-                return trig.__sindf(-x - c3pio2);
+                return trig.sindf(-x - c3pio2);
             } else {
-                return trig.__sindf(x - c3pio2);
+                return trig.sindf(x - c3pio2);
             }
         }
     }
@@ -76,10 +87,10 @@ pub fn cosf(x: f32) callconv(.c) f32 {
     var y: f64 = undefined;
     const n = rem_pio2f(x, &y);
     return switch (n & 3) {
-        0 => trig.__cosdf(y),
-        1 => trig.__sindf(-y),
-        2 => -trig.__cosdf(y),
-        else => trig.__sindf(y),
+        0 => trig.cosdf(y),
+        1 => trig.sindf(-y),
+        2 => -trig.cosdf(y),
+        else => trig.sindf(y),
     };
 }
 
@@ -94,7 +105,7 @@ pub fn cos(x: f64) callconv(.c) f64 {
             if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
             return 1.0;
         }
-        return trig.__cos(x, 0);
+        return trig.cos(x, 0);
     }
 
     // cos(Inf or NaN) is NaN
@@ -105,66 +116,144 @@ pub fn cos(x: f64) callconv(.c) f64 {
     var y: [2]f64 = undefined;
     const n = rem_pio2(x, &y);
     return switch (n & 3) {
-        0 => trig.__cos(y[0], y[1]),
-        1 => -trig.__sin(y[0], y[1], 1),
-        2 => -trig.__cos(y[0], y[1]),
-        else => trig.__sin(y[0], y[1], 1),
+        0 => trig.cos(y[0], y[1]),
+        1 => -trig.sin(y[0], y[1], 1),
+        2 => -trig.cos(y[0], y[1]),
+        else => trig.sin(y[0], y[1], 1),
     };
 }
 
-pub fn __cosx(a: f80) callconv(.c) f80 {
-    // TODO: more efficient implementation
-    return @floatCast(cosq(a));
+pub fn cosx(x: f80) callconv(.c) f80 {
+    const se = ld.signExponent(x) & 0x7fff;
+    if (se == 0x7fff) {
+        return x - x;
+    }
+
+    if (@abs(x) < trig.pi_4) {
+        if (se < 0x3fff - math.floatMantissaBits(f80)) {
+            // raise inexact if x!=0
+            return 1.0 + x;
+        }
+        return trig.cosx(x, 0.0);
+    }
+
+    var y: [2]f80 = undefined;
+    const n = rem_pio2l(f80, x, &y);
+    return switch (n & 3) {
+        0 => trig.cosx(y[0], y[1]),
+        1 => -trig.sinx(y[0], y[1], 1),
+        2 => -trig.cosx(y[0], y[1]),
+        else => trig.sinx(y[0], y[1], 1),
+    };
 }
 
-pub fn cosq(a: f128) callconv(.c) f128 {
-    // TODO: more correct implementation
-    return cos(@floatCast(a));
+pub fn cosq(x: f128) callconv(.c) f128 {
+    const se = ld.signExponent(x) & 0x7fff;
+    if (se == 0x7fff) {
+        return x - x;
+    }
+
+    if (@abs(x) < trig.pi_4) {
+        if (se < 0x3fff - math.floatMantissaBits(f128)) {
+            // raise inexact if x!=0
+            return 1.0 + x;
+        }
+        return trig.cosq(x, 0.0);
+    }
+
+    var y: [2]f128 = undefined;
+    const n = rem_pio2l(f128, x, &y);
+    return switch (n & 3) {
+        0 => trig.cosq(y[0], y[1]),
+        1 => -trig.sinq(y[0], y[1], 1),
+        2 => -trig.cosq(y[0], y[1]),
+        else => trig.sinq(y[0], y[1], 1),
+    };
 }
 
 pub fn cosl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __cosh(x),
+        16 => return cosh(x),
         32 => return cosf(x),
         64 => return cos(x),
-        80 => return __cosx(x),
+        80 => return cosx(x),
         128 => return cosq(x),
         else => @compileError("unreachable"),
     }
 }
 
-test "cos32" {
-    const epsilon = 0.00001;
+fn testCosSpecial(comptime T: type) !void {
+    const f = switch (T) {
+        f32 => cosf,
+        f64 => cos,
+        f80 => cosx,
+        f128 => cosq,
+        else => @compileError("unimplemented"),
+    };
 
-    try expect(math.approxEqAbs(f32, cosf(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(0.2), 0.980067, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(0.8923), 0.627623, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(-1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(37.45), 0.969132, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(89.123), 0.400798, epsilon));
+    try expect(f(0.0) == 1.0);
+    try expect(f(-0.0) == 1.0);
+    try expect(math.isNan(f(math.inf(T))));
+    try expect(math.isNan(f(-math.inf(T))));
+    try expect(math.isNan(f(math.nan(T))));
 }
 
-test "cos64" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f64, cos(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f64, cos(0.2), 0.980067, epsilon));
-    try expect(math.approxEqAbs(f64, cos(0.8923), 0.627623, epsilon));
-    try expect(math.approxEqAbs(f64, cos(1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f64, cos(-1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f64, cos(37.45), 0.969132, epsilon));
-    try expect(math.approxEqAbs(f64, cos(89.123), 0.40080, epsilon));
+test "cos32.normal" {
+    const epsilon = math.floatEps(f32);
+    try expectApproxEqAbs(@as(f32, 1.0), cosf(0.0), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.9800666), cosf(0.2), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.6276231), cosf(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.0707372), cosf(1.5), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.0707372), cosf(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.96913195), cosf(37.45), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.40079966), cosf(89.123), epsilon);
 }
 
 test "cos32.special" {
-    try expect(math.isNan(cosf(math.inf(f32))));
-    try expect(math.isNan(cosf(-math.inf(f32))));
-    try expect(math.isNan(cosf(math.nan(f32))));
+    try testCosSpecial(f32);
+}
+
+test "cos64.normal" {
+    const epsilon = math.floatEps(f64);
+    try expectApproxEqAbs(@as(f64, 1.0), cos(0.0), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.9800665778412416), cos(0.2), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.6276230983360804), cos(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.0707372016677029), cos(1.5), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.0707372016677029), cos(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.9691317730707778), cos(37.45), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.4008006809354791), cos(89.123), epsilon);
 }
 
 test "cos64.special" {
-    try expect(math.isNan(cos(math.inf(f64))));
-    try expect(math.isNan(cos(-math.inf(f64))));
-    try expect(math.isNan(cos(math.nan(f64))));
+    try testCosSpecial(f64);
+}
+
+test "cos80.normal" {
+    const epsilon = math.floatEps(f80);
+    try expectApproxEqAbs(@as(f80, 1.0), cosx(0.0), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.98006657784124163112419651674816888), cosx(0.2), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.62762309833608037003563995939286067), cosx(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.070737201667702910088189851434268747), cosx(1.5), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.070737201667702910088189851434268747), cosx(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.9691317730707771246), cosx(37.45), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.4008006809354834001), cosx(89.123), epsilon);
+}
+
+test "cos80.special" {
+    try testCosSpecial(f80);
+}
+
+test "cos128.normal" {
+    const epsilon = math.floatEps(f128);
+    try expectApproxEqAbs(@as(f128, 1.0), cosq(0.0), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.98006657784124163112419651674816888), cosq(0.2), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.62762309833608037003563995939286067), cosq(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.070737201667702910088189851434268747), cosq(1.5), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.070737201667702910088189851434268747), cosq(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.96913177307077712443149563847233230), cosq(37.45), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.40080068093548339848199454493704702), cosq(89.123), epsilon);
+}
+
+test "cos128.special" {
+    try testCosSpecial(f128);
 }

package/compiler_rt/long_double.zig

@@ -0,0 +1,37 @@
+//! Utilities for dealing with the `long double` type (`f80` or `f128`)
+
+const std = @import("std");
+
+pub const U80 = std.meta.Int(.unsigned, 80);
+
+/// Returns the sign + exponent bits of a `long double`
+pub fn signExponent(x: anytype) u16 {
+    const T = @TypeOf(x);
+    switch (T) {
+        f80 => {
+            const bits: U80 = @bitCast(x);
+            return @intCast(bits >> 64);
+        },
+        f128 => {
+            const bits: u128 = @bitCast(x);
+            return @intCast(bits >> 112);
+        },
+        else => @compileError("`signExponent` supports only `f80` and `f128`, got: " ++ @typeName(T)),
+    }
+}
+
+/// Takes the top 16 bits of a `long double`'s mantissa
+pub fn mantissaTop(x: anytype) u16 {
+    const T = @TypeOf(x);
+    switch (T) {
+        f80 => {
+            const bits: U80 = @bitCast(x);
+            return @intCast((bits >> 48) & 0xFFFF);
+        },
+        f128 => {
+            const bits: u128 = @bitCast(x);
+            return @intCast((bits >> 96) & 0xFFFF);
+        },
+        else => @compileError("`mantissaTop` supports only `f80` and `f128`, got: " ++ @typeName(T)),
+    }
+}

package/compiler_rt/rem_pio2l.zig

@@ -0,0 +1,173 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/math/__rem_pio2l.c
+
+const std = @import("std");
+const math = std.math;
+
+const ld = @import("long_double.zig");
+const rem_pio2_large = @import("rem_pio2_large.zig").rem_pio2_large;
+
+pub fn rem_pio2l(comptime T: type, x: T, y: *[2]T) i32 {
+    const impl = switch (T) {
+        f80 => struct {
+            const round1: i8 = 22;
+            const round2: i8 = 61;
+            const nx: i8 = 3;
+            const ny: i8 = 2;
+
+            const pio4: T = 0x1.921fb54442d1846ap-1;
+            // 64 bits of 2/pi
+            const invpio2: T = 6.36619772367581343076e-01; // 0xa2f9836e4e44152a.0p-64
+            // first  39 bits of pi/2
+            const pio2_1: f64 = 1.57079632679597125389e+00; // 0x3FF921FB, 0x54444000
+            // pi/2 - pio2_1
+            const pio2_1t: T = -1.07463465549719416346e-12; // -0x973dcb3b399d747f.0p-103
+            // second 39 bits of pi/2
+            const pio2_2: f64 = -1.07463465549783099519e-12; // -0x12e7b967674000.0p-92
+            // pi/2 - (pio2_1+pio2_2)
+            const pio2_2t: T = 6.36831716351095013979e-25; // 0xc51701b839a25205.0p-144
+            // pi/2 - (pio2_1+pio2_2+pio2_3)
+            const pio2_3t: T = -2.75299651904407171810e-37; // -0xbb5bf6c7ddd660ce.0p-185
+            // third  39 bits of pi/2
+            const pio2_3: f64 = 6.36831716351370313614e-25; // 0x18a2e037074000.0p-133
+
+            fn small(x_val: T) bool {
+                const se = ld.signExponent(x_val);
+                const top = ld.mantissaTop(x_val);
+                const lhs = (@as(u32, se & 0x7fff) << 16) | top;
+                const rhs: u32 = ((0x3fff + 25) << 16) | 0x921f >> 1 | 0x8000;
+                return lhs < rhs;
+            }
+
+            fn quobits(v: T) i32 {
+                const q: i32 = @intFromFloat(v);
+                return @intCast(@as(u32, @bitCast(q)) & 0x7fffffff);
+            }
+        },
+        f128 => struct {
+            const round1: i8 = 51;
+            const round2: i8 = 119;
+            const nx: i8 = 5;
+            const ny: i8 = 3;
+
+            const pio4: T = 0x1.921fb54442d18469898cc51701b8p-1;
+            const invpio2: T = 6.3661977236758134307553505349005747e-01;
+            const pio2_1: T = 1.5707963267948966192292994253909555e+00;
+            const pio2_1t: T = 2.0222662487959507323996846200947577e-21;
+            const pio2_2: T = 2.0222662487959507323994779168837751e-21;
+            const pio2_2t: T = 2.0670321098263988236496903051604844e-43;
+            const pio2_3: T = 2.0670321098263988236499468110329591e-43;
+            const pio2_3t: T = -2.5650587247459238361625433492959285e-65;
+
+            fn small(x_val: T) bool {
+                const se = ld.signExponent(x_val);
+                const top = ld.mantissaTop(x_val);
+                const lhs = (@as(u32, se & 0x7fff) << 16) | top;
+                const rhs: u32 = ((0x3fff + 45) << 16) | 0x921f;
+                return lhs < rhs;
+            }
+
+            fn quobits(fn_val: T) i32 {
+                const q: i64 = @intFromFloat(fn_val);
+                return @intCast(@as(u64, @bitCast(q)) & 0x7fffffff);
+            }
+        },
+        else => @compileError("rem_pio2l supports only f80 and f128, got: " ++ @typeName(T)),
+    };
+
+    const x_se = ld.signExponent(x);
+    const ex: i32 = @intCast(x_se & 0x7fff);
+
+    if (impl.small(x)) {
+        // rint(x/(pi/2))
+        const toint: T = 1.5 / math.floatEps(T);
+        var fn_ = x * impl.invpio2 + toint - toint;
+        var n = impl.quobits(fn_);
+        var r = x - fn_ * @as(T, impl.pio2_1);
+        var w = fn_ * impl.pio2_1t; // 1st round good to 102/180 bits
+
+        // Matters with directed rounding.
+        if (r - w < -impl.pio4) {
+            @branchHint(.unlikely);
+            n -= 1;
+            fn_ -= 1;
+            r = x - fn_ * @as(T, impl.pio2_1);
+            w = fn_ * impl.pio2_1t;
+        } else if (r - w > impl.pio4) {
+            @branchHint(.unlikely);
+            n += 1;
+            fn_ += 1;
+            r = x - fn_ * @as(T, impl.pio2_1);
+            w = fn_ * impl.pio2_1t;
+        }
+
+        y[0] = r - w;
+
+        const ey: i32 = @intCast(ld.signExponent(y[0]) & 0x7fff);
+        if (ex - ey > impl.round1) {
+            var t = r;
+            w = fn_ * impl.pio2_2;
+            r = t - w;
+            w = fn_ * impl.pio2_2t - ((t - r) - w);
+            y[0] = r - w;
+            const ey2: i32 = @intCast(ld.signExponent(y[0]) & 0x7fff);
+            if (ex - ey2 > impl.round2) {
+                t = r;
+                w = fn_ * impl.pio2_3;
+                r = t - w;
+                w = fn_ * impl.pio2_3t - ((t - r) - w);
+                y[0] = r - w;
+            }
+        }
+        y[1] = (r - y[0]) - w;
+        return n;
+    }
+
+    // all other (large) arguments
+    if (ex == 0x7fff) { // x is inf or NaN
+        y[0] = x - x;
+        y[1] = y[0];
+        return 0;
+    }
+
+    var z: T = math.scalbn(@abs(x), -math.ilogb(x) + 23);
+    var tx: [impl.nx]f64 = undefined;
+    var ty: [impl.ny]f64 = undefined;
+    var i: usize = 0;
+
+    while (i < impl.nx - 1) : (i += 1) {
+        tx[i] = @floatFromInt(@as(i32, @intFromFloat(z)));
+        z = (z - @as(T, tx[i])) * 0x1p24;
+    }
+
+    tx[i] = @floatCast(z);
+    while (tx[i] == 0.0) {
+        i -= 1;
+    }
+
+    const n = rem_pio2_large(
+        tx[0..(i + 1)],
+        ty[0..impl.ny],
+        ex - 0x3fff - 23,
+        @intCast(i + 1),
+        impl.ny,
+    );
+    var w: f64 = ty[1];
+    if (impl.ny == 3) {
+        w += ty[2];
+    }
+    const r = ty[0] + w;
+    w -= r - ty[0];
+
+    if (x_se >> 15 != 0) {
+        y[0] = -@as(T, r);
+        y[1] = -@as(T, w);
+        return -n;
+    }
+
+    y[0] = @as(T, r);
+    y[1] = @as(T, w);
+    return n;
+}