@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

package/compiler_rt/log.zig

@@ -443,8 +443,6 @@ pub fn logq(a: f128) callconv(.c) f128 {
 
 pub fn logl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __logh(x),
-        32 => return logf(x),
         64 => return log(x),
         80 => return __logx(x),
         128 => return logq(x),

package/compiler_rt/log10.zig

@@ -177,8 +177,6 @@ pub fn log10q(a: f128) callconv(.c) f128 {
 
 pub fn log10l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log10h(x),
-        32 => return log10f(x),
         64 => return log10(x),
         80 => return __log10x(x),
         128 => return log10q(x),

package/compiler_rt/log2.zig

@@ -170,8 +170,6 @@ pub fn log2q(a: f128) callconv(.c) f128 {
 
 pub fn log2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log2h(x),
-        32 => return log2f(x),
         64 => return log2(x),
         80 => return __log2x(x),
         128 => return log2q(x),

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/mulXi3.zig

@@ -63,7 +63,7 @@ fn DoubleInt(comptime T: type) type {
     };
 }
 
-fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
+pub fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
     const DT = DoubleInt(T);
     const word_t = compiler_rt.HalveInt(DT, false);
     const bits_in_word_2 = @sizeOf(T) * 8 / 2;

package/compiler_rt/mulo.zig

@@ -19,7 +19,12 @@ comptime {
 inline fn muloXi4_genericSmall(comptime ST: type, a: ST, b: ST, overflow: *c_int) ST {
     overflow.* = 0;
     const min = math.minInt(ST);
-    const res: ST = a *% b;
+    const res: ST = if (ST == i128 and builtin.target.cpu.arch.isWasm()) res: {
+        // Despite compiler-rt being built with `-fno-builtin`, LLVM still converts this function to
+        // a call to `__muloti4` on WASM. This is an upstream bug: circumvent it by directly calling
+        // the "lower-level" compiler-rt routine for this wrapping multiplication.
+        break :res @import("mulXi3.zig").__multi3(a, b);
+    } else a *% b;
     // Hacker's Delight section Overflow subsection Multiplication
     // case a=-2^{31}, b=-1 problem, because
     // on some machines a*b = -2^{31} with overflow

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;
+}

package/compiler_rt/round.zig

@@ -142,8 +142,6 @@ pub fn roundq(x_: f128) callconv(.c) f128 {
 
 pub fn roundl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __roundh(x),
-        32 => return roundf(x),
         64 => return round(x),
         80 => return __roundx(x),
         128 => return roundq(x),

package/compiler_rt/sin.zig

@@ -3,23 +3,28 @@
 //!
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/sinf.c
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/sin.c
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/sinl.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(&__sinh, "__sinh");
+    symbol(&sinh, "__sinh");
+    symbol(&sinl, "__sinl");
     symbol(&sinf, "sinf");
     symbol(&sin, "sin");
-    symbol(&__sinx, "__sinx");
+    symbol(&sinx, "__sinx");
     if (compiler_rt.want_ppc_abi) {
         symbol(&sinq, "sinf128");
     }
@@ -27,7 +32,7 @@ comptime {
     symbol(&sinl, "sinl");
 }
 
-pub fn __sinh(x: f16) callconv(.c) f16 {
+pub fn sinh(x: f16) callconv(.c) f16 {
     // TODO: more efficient implementation
     return @floatCast(sinf(x));
 }
@@ -55,27 +60,27 @@ pub fn sinf(x: f32) callconv(.c) f32 {
             }
             return x;
         }
-        return trig.__sindf(x);
+        return trig.sindf(x);
     }
     if (ix <= 0x407b53d1) { // |x| ~<= 5*pi/4
         if (ix <= 0x4016cbe3) { // |x| ~<= 3pi/4
             if (sign) {
-                return -trig.__cosdf(x + s1pio2);
+                return -trig.cosdf(x + s1pio2);
             } else {
-                return trig.__cosdf(x - s1pio2);
+                return trig.cosdf(x - s1pio2);
             }
         }
-        return trig.__sindf(if (sign) -(x + s2pio2) else -(x - s2pio2));
+        return trig.sindf(if (sign) -(x + s2pio2) else -(x - s2pio2));
     }
     if (ix <= 0x40e231d5) { // |x| ~<= 9*pi/4
         if (ix <= 0x40afeddf) { // |x| ~<= 7*pi/4
             if (sign) {
-                return trig.__cosdf(x + s3pio2);
+                return trig.cosdf(x + s3pio2);
             } else {
-                return -trig.__cosdf(x - s3pio2);
+                return -trig.cosdf(x - s3pio2);
             }
         }
-        return trig.__sindf(if (sign) x + s4pio2 else x - s4pio2);
+        return trig.sindf(if (sign) x + s4pio2 else x - s4pio2);
     }
 
     // sin(Inf or NaN) is NaN
@@ -86,10 +91,10 @@ pub fn sinf(x: f32) callconv(.c) f32 {
     var y: f64 = undefined;
     const n = rem_pio2f(x, &y);
     return switch (n & 3) {
-        0 => trig.__sindf(y),
-        1 => trig.__cosdf(y),
-        2 => trig.__sindf(-y),
-        else => -trig.__cosdf(y),
+        0 => trig.sindf(y),
+        1 => trig.cosdf(y),
+        2 => trig.sindf(-y),
+        else => -trig.cosdf(y),
     };
 }
 
@@ -110,7 +115,7 @@ pub fn sin(x: f64) callconv(.c) f64 {
             }
             return x;
         }
-        return trig.__sin(x, 0.0, 0);
+        return trig.sin(x, 0.0, 0);
     }
 
     // sin(Inf or NaN) is NaN
@@ -121,72 +126,150 @@ pub fn sin(x: f64) callconv(.c) f64 {
     var y: [2]f64 = undefined;
     const n = rem_pio2(x, &y);
     return switch (n & 3) {
-        0 => trig.__sin(y[0], y[1], 1),
-        1 => trig.__cos(y[0], y[1]),
-        2 => -trig.__sin(y[0], y[1], 1),
-        else => -trig.__cos(y[0], y[1]),
+        0 => trig.sin(y[0], y[1], 1),
+        1 => trig.cos(y[0], y[1]),
+        2 => -trig.sin(y[0], y[1], 1),
+        else => -trig.cos(y[0], y[1]),
     };
 }
 
-pub fn __sinx(x: f80) callconv(.c) f80 {
-    // TODO: more efficient implementation
-    return @floatCast(sinq(x));
+fn sinx(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) / 2)) {
+            // raise inexact if x!=0 and underflow if subnormal
+            if (compiler_rt.want_float_exceptions) {
+                mem.doNotOptimizeAway(if (se == 0) x * 0x1p-120 else x + 0x1p120);
+            }
+            return x;
+        }
+        return trig.sinx(x, 0.0, 0);
+    }
+
+    var y: [2]f80 = undefined;
+    const n = rem_pio2l(f80, x, &y);
+    return switch (n & 3) {
+        0 => trig.sinx(y[0], y[1], 1),
+        1 => trig.cosx(y[0], y[1]),
+        2 => -trig.sinx(y[0], y[1], 1),
+        else => -trig.cosx(y[0], y[1]),
+    };
 }
 
 pub fn sinq(x: f128) callconv(.c) f128 {
-    // TODO: more correct implementation
-    return sin(@floatCast(x));
+    const se = ld.signExponent(x) & 0x7fff;
+    if (se == 0x7fff) {
+        return x - x;
+    }
+
+    if (@abs(x) < trig.pi_4) {
+        if (se < 0x3fff - (math.floatMantissaBits(f128) / 2)) {
+            // raise inexact if x!=0 and underflow if subnormal
+            if (compiler_rt.want_float_exceptions) {
+                mem.doNotOptimizeAway(if (se == 0) x * 0x1p-120 else x + 0x1p120);
+            }
+            return x;
+        }
+        return trig.sinq(x, 0.0, 0);
+    }
+
+    var y: [2]f128 = undefined;
+    const n = rem_pio2l(f128, x, &y);
+    return switch (n & 3) {
+        0 => trig.sinq(y[0], y[1], 1),
+        1 => trig.cosq(y[0], y[1]),
+        2 => -trig.sinq(y[0], y[1], 1),
+        else => -trig.cosq(y[0], y[1]),
+    };
 }
 
 pub fn sinl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __sinh(x),
-        32 => return sinf(x),
         64 => return sin(x),
-        80 => return __sinx(x),
+        80 => return sinx(x),
         128 => return sinq(x),
         else => @compileError("unreachable"),
     }
 }
 
-test "sin32" {
-    const epsilon = 0.00001;
+fn testSinSpecial(comptime T: type) !void {
+    const f = switch (T) {
+        f32 => sinf,
+        f64 => sin,
+        f80 => sinx,
+        f128 => sinq,
+        else => @compileError("unimplemented"),
+    };
 
-    try expect(math.approxEqAbs(f32, sinf(0.0), 0.0, epsilon));
-    try expect(math.approxEqAbs(f32, sinf(0.2), 0.198669, epsilon));
-    try expect(math.approxEqAbs(f32, sinf(0.8923), 0.778517, epsilon));
-    try expect(math.approxEqAbs(f32, sinf(1.5), 0.997495, epsilon));
-    try expect(math.approxEqAbs(f32, sinf(-1.5), -0.997495, epsilon));
-    try expect(math.approxEqAbs(f32, sinf(37.45), -0.246544, epsilon));
-    try expect(math.approxEqAbs(f32, sinf(89.123), 0.916166, epsilon));
+    try expect(math.isPositiveZero(f(0.0)));
+    try expect(math.isNegativeZero(f(-0.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 "sin64" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f64, sin(0.0), 0.0, epsilon));
-    try expect(math.approxEqAbs(f64, sin(0.2), 0.198669, epsilon));
-    try expect(math.approxEqAbs(f64, sin(0.8923), 0.778517, epsilon));
-    try expect(math.approxEqAbs(f64, sin(1.5), 0.997495, epsilon));
-    try expect(math.approxEqAbs(f64, sin(-1.5), -0.997495, epsilon));
-    try expect(math.approxEqAbs(f64, sin(37.45), -0.246543, epsilon));
-    try expect(math.approxEqAbs(f64, sin(89.123), 0.916166, epsilon));
+test "sin32.normal" {
+    const epsilon = math.floatEps(f32);
+    try expectApproxEqAbs(@as(f32, 0.0), sinf(0.0), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.19866933), sinf(0.2), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.77851737), sinf(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.997495), sinf(1.5), epsilon);
+    try expectApproxEqAbs(@as(f32, -0.997495), sinf(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f32, -0.24654257), sinf(37.45), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.9161657), sinf(89.123), epsilon);
 }
 
 test "sin32.special" {
-    try expect(sinf(0.0) == 0.0);
-    try expect(sinf(-0.0) == -0.0);
-    try expect(math.isNan(sinf(math.inf(f32))));
-    try expect(math.isNan(sinf(-math.inf(f32))));
-    try expect(math.isNan(sinf(math.nan(f32))));
+    try testSinSpecial(f32);
+}
+
+test "sin64.normal" {
+    const epsilon = math.floatEps(f64);
+    try expectApproxEqAbs(@as(f64, 0.0), sin(0.0), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.19866933079506122), sin(0.2), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.7785173385577349), sin(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.9974949866040544), sin(1.5), epsilon);
+    try expectApproxEqAbs(@as(f64, -0.9974949866040544), sin(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f64, -0.24654331551411082), sin(37.45), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.9161652766622714), sin(89.123), epsilon);
 }
 
 test "sin64.special" {
-    try expect(sin(0.0) == 0.0);
-    try expect(sin(-0.0) == -0.0);
-    try expect(math.isNan(sin(math.inf(f64))));
-    try expect(math.isNan(sin(-math.inf(f64))));
-    try expect(math.isNan(sin(math.nan(f64))));
+    try testSinSpecial(f64);
+}
+
+test "sin80.normal" {
+    const epsilon = math.floatEps(f80);
+    try expectApproxEqAbs(@as(f80, 0.0), sinx(0.0), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.19866933079506121545941262711838975), sinx(0.2), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.77851733855773487830689285621486050), sinx(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.99749498660405443094172337114148732), sinx(1.5), epsilon);
+    try expectApproxEqAbs(@as(f80, -0.99749498660405443094172337114148732), sinx(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f80, -0.24654331551411356504), sinx(37.45), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.91616527666226951006), sinx(89.123), epsilon);
+}
+
+test "sin80.special" {
+    try testSinSpecial(f80);
+}
+
+test "sin128.normal" {
+    const epsilon = math.floatEps(f128);
+    try expectApproxEqAbs(@as(f128, 0.0), sinq(0.0), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.19866933079506121545941262711838975), sinq(0.2), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.77851733855773487830689285621486050), sinq(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.99749498660405443094172337114148732), sinq(1.5), epsilon);
+    try expectApproxEqAbs(@as(f128, -0.99749498660405443094172337114148732), sinq(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f128, -0.24654331551411356571238581321661085), sinq(37.45), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.91616527666226951075019849560482170), sinq(89.123), epsilon);
+}
+
+test "sin128.special" {
+    try testSinSpecial(f128);
 }
 
 test "sin32 #9901" {