Commit 41dd2beaac

@@ -113,7 +113,7 @@ fn errolSlow(val: f64, buffer: []u8) FloatDecimal {
     // normalize the midpoint
 
     const e = math.frexp(val).exponent;
-    var exp = @floatToInt(i16, math.floor(307 + @intToFloat(f64, e) * 0.30103));
+    var exp = @floatToInt(i16, @floor(307 + @intToFloat(f64, e) * 0.30103));
     if (exp < 20) {
         exp = 20;
     } else if (@intCast(usize, exp) >= lookup_table.len) {
@@ -170,10 +170,10 @@ fn errolSlow(val: f64, buffer: []u8) FloatDecimal {
     // digit generation
     var buf_index: usize = 0;
     while (true) {
-        var hdig = @floatToInt(u8, math.floor(high.val));
+        var hdig = @floatToInt(u8, @floor(high.val));
         if ((high.val == @intToFloat(f64, hdig)) and (high.off < 0)) hdig -= 1;
 
-        var ldig = @floatToInt(u8, math.floor(low.val));
+        var ldig = @floatToInt(u8, @floor(low.val));
         if ((low.val == @intToFloat(f64, ldig)) and (low.off < 0)) ldig -= 1;
 
         if (ldig != hdig) break;
@@ -187,7 +187,7 @@ fn errolSlow(val: f64, buffer: []u8) FloatDecimal {
     }
 
     const tmp = (high.val + low.val) / 2.0;
-    var mdig = @floatToInt(u8, math.floor(tmp + 0.5));
+    var mdig = @floatToInt(u8, @floor(tmp + 0.5));
     if ((@intToFloat(f64, mdig) - tmp) == 0.5 and (mdig & 0x1) != 0) mdig -= 1;
 
     buffer[buf_index] = mdig + '0';

@@ -66,7 +66,7 @@ fn atan32(z: Complex(f32)) Complex(f32) {
 
     t = y + 1.0;
     a = (x2 + (t * t)) / a;
-    return Complex(f32).init(w, 0.25 * math.ln(a));
+    return Complex(f32).init(w, 0.25 * @log(a));
 }
 
 fn redupif64(x: f64) f64 {
@@ -115,7 +115,7 @@ fn atan64(z: Complex(f64)) Complex(f64) {
 
     t = y + 1.0;
     a = (x2 + (t * t)) / a;
-    return Complex(f64).init(w, 0.25 * math.ln(a));
+    return Complex(f64).init(w, 0.25 * @log(a));
 }
 
 const epsilon = 0.0001;

@@ -44,12 +44,12 @@ fn cosh32(z: Complex(f32)) Complex(f32) {
         // |x|>= 9, so cosh(x) ~= exp(|x|)
         if (ix < 0x42b17218) {
             // x < 88.7: exp(|x|) won't overflow
-            const h = math.exp(math.fabs(x)) * 0.5;
+            const h = @exp(@fabs(x)) * 0.5;
             return Complex(f32).init(math.copysign(f32, h, x) * math.cos(y), h * math.sin(y));
         }
         // x < 192.7: scale to avoid overflow
         else if (ix < 0x4340b1e7) {
-            const v = Complex(f32).init(math.fabs(x), y);
+            const v = Complex(f32).init(@fabs(x), y);
             const r = ldexp_cexp(v, -1);
             return Complex(f32).init(r.re, r.im * math.copysign(f32, 1, x));
         }
@@ -112,12 +112,12 @@ fn cosh64(z: Complex(f64)) Complex(f64) {
         // |x|>= 22, so cosh(x) ~= exp(|x|)
         if (ix < 0x40862e42) {
             // x < 710: exp(|x|) won't overflow
-            const h = math.exp(math.fabs(x)) * 0.5;
+            const h = @exp(@fabs(x)) * 0.5;
             return Complex(f64).init(h * math.cos(y), math.copysign(f64, h, x) * math.sin(y));
         }
         // x < 1455: scale to avoid overflow
         else if (ix < 0x4096bbaa) {
-            const v = Complex(f64).init(math.fabs(x), y);
+            const v = Complex(f64).init(@fabs(x), y);
             const r = ldexp_cexp(v, -1);
             return Complex(f64).init(r.re, r.im * math.copysign(f64, 1, x));
         }

@@ -33,7 +33,7 @@ fn exp32(z: Complex(f32)) Complex(f32) {
     const hy = @bitCast(u32, y) & 0x7fffffff;
     // cexp(x + i0) = exp(x) + i0
     if (hy == 0) {
-        return Complex(f32).init(math.exp(x), y);
+        return Complex(f32).init(@exp(x), y);
     }
 
     const hx = @bitCast(u32, x);
@@ -63,7 +63,7 @@ fn exp32(z: Complex(f32)) Complex(f32) {
     // - x = +-inf
     // - x = nan
     else {
-        const exp_x = math.exp(x);
+        const exp_x = @exp(x);
         return Complex(f32).init(exp_x * math.cos(y), exp_x * math.sin(y));
     }
 }
@@ -81,7 +81,7 @@ fn exp64(z: Complex(f64)) Complex(f64) {
 
     // cexp(x + i0) = exp(x) + i0
     if (hy | ly == 0) {
-        return Complex(f64).init(math.exp(x), y);
+        return Complex(f64).init(@exp(x), y);
     }
 
     const fx = @bitCast(u64, x);
@@ -114,13 +114,13 @@ fn exp64(z: Complex(f64)) Complex(f64) {
     // - x = +-inf
     // - x = nan
     else {
-        const exp_x = math.exp(x);
+        const exp_x = @exp(x);
         return Complex(f64).init(exp_x * math.cos(y), exp_x * math.sin(y));
     }
 }
 
 test "complex.cexp32" {
-    const tolerance_f32 = math.sqrt(math.floatEps(f32));
+    const tolerance_f32 = @sqrt(math.floatEps(f32));
 
     {
         const a = Complex(f32).init(5, 3);
@@ -140,7 +140,7 @@ test "complex.cexp32" {
 }
 
 test "complex.cexp64" {
-    const tolerance_f64 = math.sqrt(math.floatEps(f64));
+    const tolerance_f64 = @sqrt(math.floatEps(f64));
 
     {
         const a = Complex(f64).init(5, 3);

@@ -26,7 +26,7 @@ fn frexp_exp32(x: f32, expt: *i32) f32 {
     const k = 235; // reduction constant
     const kln2 = 162.88958740; // k * ln2
 
-    const exp_x = math.exp(x - kln2);
+    const exp_x = @exp(x - kln2);
     const hx = @bitCast(u32, exp_x);
     // TODO zig should allow this cast implicitly because it should know the value is in range
     expt.* = @intCast(i32, hx >> 23) - (0x7f + 127) + k;
@@ -54,7 +54,7 @@ fn frexp_exp64(x: f64, expt: *i32) f64 {
     const k = 1799; // reduction constant
     const kln2 = 1246.97177782734161156; // k * ln2
 
-    const exp_x = math.exp(x - kln2);
+    const exp_x = @exp(x - kln2);
 
     const fx = @bitCast(u64, exp_x);
     const hx = @intCast(u32, fx >> 32);

@@ -10,7 +10,7 @@ pub fn log(z: anytype) Complex(@TypeOf(z.re)) {
     const r = cmath.abs(z);
     const phi = cmath.arg(z);
 
-    return Complex(T).init(math.ln(r), phi);
+    return Complex(T).init(@log(r), phi);
 }
 
 const epsilon = 0.0001;

@@ -44,12 +44,12 @@ fn sinh32(z: Complex(f32)) Complex(f32) {
         // |x|>= 9, so cosh(x) ~= exp(|x|)
         if (ix < 0x42b17218) {
             // x < 88.7: exp(|x|) won't overflow
-            const h = math.exp(math.fabs(x)) * 0.5;
+            const h = @exp(@fabs(x)) * 0.5;
             return Complex(f32).init(math.copysign(f32, h, x) * math.cos(y), h * math.sin(y));
         }
         // x < 192.7: scale to avoid overflow
         else if (ix < 0x4340b1e7) {
-            const v = Complex(f32).init(math.fabs(x), y);
+            const v = Complex(f32).init(@fabs(x), y);
             const r = ldexp_cexp(v, -1);
             return Complex(f32).init(r.re * math.copysign(f32, 1, x), r.im);
         }
@@ -111,12 +111,12 @@ fn sinh64(z: Complex(f64)) Complex(f64) {
         // |x|>= 22, so cosh(x) ~= exp(|x|)
         if (ix < 0x40862e42) {
             // x < 710: exp(|x|) won't overflow
-            const h = math.exp(math.fabs(x)) * 0.5;
+            const h = @exp(@fabs(x)) * 0.5;
             return Complex(f64).init(math.copysign(f64, h, x) * math.cos(y), h * math.sin(y));
         }
         // x < 1455: scale to avoid overflow
         else if (ix < 0x4096bbaa) {
-            const v = Complex(f64).init(math.fabs(x), y);
+            const v = Complex(f64).init(@fabs(x), y);
             const r = ldexp_cexp(v, -1);
             return Complex(f64).init(r.re * math.copysign(f64, 1, x), r.im);
         }

@@ -43,7 +43,7 @@ fn sqrt32(z: Complex(f32)) Complex(f32) {
         // sqrt(-inf + i nan)   = nan +- inf i
         // sqrt(-inf + iy)      = 0 + inf i
         if (math.signbit(x)) {
-            return Complex(f32).init(math.fabs(x - y), math.copysign(f32, x, y));
+            return Complex(f32).init(@fabs(x - y), math.copysign(f32, x, y));
         } else {
             return Complex(f32).init(x, math.copysign(f32, y - y, y));
         }
@@ -56,15 +56,15 @@ fn sqrt32(z: Complex(f32)) Complex(f32) {
     const dy = @as(f64, y);
 
     if (dx >= 0) {
-        const t = math.sqrt((dx + math.hypot(f64, dx, dy)) * 0.5);
+        const t = @sqrt((dx + math.hypot(f64, dx, dy)) * 0.5);
         return Complex(f32).init(
             @floatCast(f32, t),
             @floatCast(f32, dy / (2.0 * t)),
         );
     } else {
-        const t = math.sqrt((-dx + math.hypot(f64, dx, dy)) * 0.5);
+        const t = @sqrt((-dx + math.hypot(f64, dx, dy)) * 0.5);
         return Complex(f32).init(
-            @floatCast(f32, math.fabs(y) / (2.0 * t)),
+            @floatCast(f32, @fabs(y) / (2.0 * t)),
             @floatCast(f32, math.copysign(f64, t, y)),
         );
     }
@@ -94,7 +94,7 @@ fn sqrt64(z: Complex(f64)) Complex(f64) {
         // sqrt(-inf + i nan)   = nan +- inf i
         // sqrt(-inf + iy)      = 0 + inf i
         if (math.signbit(x)) {
-            return Complex(f64).init(math.fabs(x - y), math.copysign(f64, x, y));
+            return Complex(f64).init(@fabs(x - y), math.copysign(f64, x, y));
         } else {
             return Complex(f64).init(x, math.copysign(f64, y - y, y));
         }
@@ -104,7 +104,7 @@ fn sqrt64(z: Complex(f64)) Complex(f64) {
 
     // scale to avoid overflow
     var scale = false;
-    if (math.fabs(x) >= threshold or math.fabs(y) >= threshold) {
+    if (@fabs(x) >= threshold or @fabs(y) >= threshold) {
         x *= 0.25;
         y *= 0.25;
         scale = true;
@@ -112,11 +112,11 @@ fn sqrt64(z: Complex(f64)) Complex(f64) {
 
     var result: Complex(f64) = undefined;
     if (x >= 0) {
-        const t = math.sqrt((x + math.hypot(f64, x, y)) * 0.5);
+        const t = @sqrt((x + math.hypot(f64, x, y)) * 0.5);
         result = Complex(f64).init(t, y / (2.0 * t));
     } else {
-        const t = math.sqrt((-x + math.hypot(f64, x, y)) * 0.5);
-        result = Complex(f64).init(math.fabs(y) / (2.0 * t), math.copysign(f64, t, y));
+        const t = @sqrt((-x + math.hypot(f64, x, y)) * 0.5);
+        result = Complex(f64).init(@fabs(y) / (2.0 * t), math.copysign(f64, t, y));
     }
 
     if (scale) {

@@ -44,7 +44,7 @@ fn tanh32(z: Complex(f32)) Complex(f32) {
 
     // x >= 11
     if (ix >= 0x41300000) {
-        const exp_mx = math.exp(-math.fabs(x));
+        const exp_mx = @exp(-@fabs(x));
         return Complex(f32).init(math.copysign(f32, 1, x), 4 * math.sin(y) * math.cos(y) * exp_mx * exp_mx);
     }
 
@@ -52,7 +52,7 @@ fn tanh32(z: Complex(f32)) Complex(f32) {
     const t = math.tan(y);
     const beta = 1.0 + t * t;
     const s = math.sinh(x);
-    const rho = math.sqrt(1 + s * s);
+    const rho = @sqrt(1 + s * s);
     const den = 1 + beta * s * s;
 
     return Complex(f32).init((beta * rho * s) / den, t / den);
@@ -87,7 +87,7 @@ fn tanh64(z: Complex(f64)) Complex(f64) {
 
     // x >= 22
     if (ix >= 0x40360000) {
-        const exp_mx = math.exp(-math.fabs(x));
+        const exp_mx = @exp(-@fabs(x));
         return Complex(f64).init(math.copysign(f64, 1, x), 4 * math.sin(y) * math.cos(y) * exp_mx * exp_mx);
     }
 
@@ -95,7 +95,7 @@ fn tanh64(z: Complex(f64)) Complex(f64) {
     const t = math.tan(y);
     const beta = 1.0 + t * t;
     const s = math.sinh(x);
-    const rho = math.sqrt(1 + s * s);
+    const rho = @sqrt(1 + s * s);
     const den = 1 + beta * s * s;
 
     return Complex(f64).init((beta * rho * s) / den, t / den);

@@ -64,14 +64,14 @@ fn acos32(x: f32) f32 {
     // x < -0.5
     if (hx >> 31 != 0) {
         const z = (1 + x) * 0.5;
-        const s = math.sqrt(z);
+        const s = @sqrt(z);
         const w = r32(z) * s - pio2_lo;
         return 2 * (pio2_hi - (s + w));
     }
 
     // x > 0.5
     const z = (1.0 - x) * 0.5;
-    const s = math.sqrt(z);
+    const s = @sqrt(z);
     const jx = @bitCast(u32, s);
     const df = @bitCast(f32, jx & 0xFFFFF000);
     const c = (z - df * df) / (s + df);
@@ -133,14 +133,14 @@ fn acos64(x: f64) f64 {
     // x < -0.5
     if (hx >> 31 != 0) {
         const z = (1.0 + x) * 0.5;
-        const s = math.sqrt(z);
+        const s = @sqrt(z);
         const w = r64(z) * s - pio2_lo;
         return 2 * (pio2_hi - (s + w));
     }
 
     // x > 0.5
     const z = (1.0 - x) * 0.5;
-    const s = math.sqrt(z);
+    const s = @sqrt(z);
     const jx = @bitCast(u64, s);
     const df = @bitCast(f64, jx & 0xFFFFFFFF00000000);
     const c = (z - df * df) / (s + df);

@@ -29,15 +29,15 @@ fn acosh32(x: f32) f32 {
 
     // |x| < 2, invalid if x < 1 or nan
     if (i < 0x3F800000 + (1 << 23)) {
-        return math.log1p(x - 1 + math.sqrt((x - 1) * (x - 1) + 2 * (x - 1)));
+        return math.log1p(x - 1 + @sqrt((x - 1) * (x - 1) + 2 * (x - 1)));
     }
     // |x| < 0x1p12
     else if (i < 0x3F800000 + (12 << 23)) {
-        return math.ln(2 * x - 1 / (x + math.sqrt(x * x - 1)));
+        return @log(2 * x - 1 / (x + @sqrt(x * x - 1)));
     }
     // |x| >= 0x1p12
     else {
-        return math.ln(x) + 0.693147180559945309417232121458176568;
+        return @log(x) + 0.693147180559945309417232121458176568;
     }
 }
 
@@ -47,15 +47,15 @@ fn acosh64(x: f64) f64 {
 
     // |x| < 2, invalid if x < 1 or nan
     if (e < 0x3FF + 1) {
-        return math.log1p(x - 1 + math.sqrt((x - 1) * (x - 1) + 2 * (x - 1)));
+        return math.log1p(x - 1 + @sqrt((x - 1) * (x - 1) + 2 * (x - 1)));
     }
     // |x| < 0x1p26
     else if (e < 0x3FF + 26) {
-        return math.ln(2 * x - 1 / (x + math.sqrt(x * x - 1)));
+        return @log(2 * x - 1 / (x + @sqrt(x * x - 1)));
     }
     // |x| >= 0x1p26 or nan
     else {
-        return math.ln(x) + 0.693147180559945309417232121458176568;
+        return @log(x) + 0.693147180559945309417232121458176568;
     }
 }
 

@@ -60,8 +60,8 @@ fn asin32(x: f32) f32 {
     }
 
     // 1 > |x| >= 0.5
-    const z = (1 - math.fabs(x)) * 0.5;
-    const s = math.sqrt(z);
+    const z = (1 - @fabs(x)) * 0.5;
+    const s = @sqrt(z);
     const fx = pio2 - 2 * (s + s * r32(z));
 
     if (hx >> 31 != 0) {
@@ -119,8 +119,8 @@ fn asin64(x: f64) f64 {
     }
 
     // 1 > |x| >= 0.5
-    const z = (1 - math.fabs(x)) * 0.5;
-    const s = math.sqrt(z);
+    const z = (1 - @fabs(x)) * 0.5;
+    const s = @sqrt(z);
     const r = r64(z);
     var fx: f64 = undefined;
 

@@ -39,15 +39,15 @@ fn asinh32(x: f32) f32 {
 
     // |x| >= 0x1p12 or inf or nan
     if (i >= 0x3F800000 + (12 << 23)) {
-        rx = math.ln(rx) + 0.69314718055994530941723212145817656;
+        rx = @log(rx) + 0.69314718055994530941723212145817656;
     }
     // |x| >= 2
     else if (i >= 0x3F800000 + (1 << 23)) {
-        rx = math.ln(2 * x + 1 / (math.sqrt(x * x + 1) + x));
+        rx = @log(2 * x + 1 / (@sqrt(x * x + 1) + x));
     }
     // |x| >= 0x1p-12, up to 1.6ulp error
     else if (i >= 0x3F800000 - (12 << 23)) {
-        rx = math.log1p(x + x * x / (math.sqrt(x * x + 1) + 1));
+        rx = math.log1p(x + x * x / (@sqrt(x * x + 1) + 1));
     }
     // |x| < 0x1p-12, inexact if x != 0
     else {
@@ -70,15 +70,15 @@ fn asinh64(x: f64) f64 {
 
     // |x| >= 0x1p26 or inf or nan
     if (e >= 0x3FF + 26) {
-        rx = math.ln(rx) + 0.693147180559945309417232121458176568;
+        rx = @log(rx) + 0.693147180559945309417232121458176568;
     }
     // |x| >= 2
     else if (e >= 0x3FF + 1) {
-        rx = math.ln(2 * x + 1 / (math.sqrt(x * x + 1) + x));
+        rx = @log(2 * x + 1 / (@sqrt(x * x + 1) + x));
     }
     // |x| >= 0x1p-12, up to 1.6ulp error
     else if (e >= 0x3FF - 26) {
-        rx = math.log1p(x + x * x / (math.sqrt(x * x + 1) + 1));
+        rx = math.log1p(x + x * x / (@sqrt(x * x + 1) + 1));
     }
     // |x| < 0x1p-12, inexact if x != 0
     else {

@@ -73,7 +73,7 @@ fn atan32(x_: f32) f32 {
         }
         id = null;
     } else {
-        x = math.fabs(x);
+        x = @fabs(x);
         // |x| < 1.1875
         if (ix < 0x3F980000) {
             // 7/16 <= |x| < 11/16
@@ -171,7 +171,7 @@ fn atan64(x_: f64) f64 {
         }
         id = null;
     } else {
-        x = math.fabs(x);
+        x = @fabs(x);
         // |x| < 1.1875
         if (ix < 0x3FF30000) {
             // 7/16 <= |x| < 11/16

@@ -108,7 +108,7 @@ fn atan2_32(y: f32, x: f32) f32 {
         if ((m & 2) != 0 and iy + (26 << 23) < ix) {
             break :z 0.0;
         } else {
-            break :z math.atan(math.fabs(y / x));
+            break :z math.atan(@fabs(y / x));
         }
     };
 
@@ -198,7 +198,7 @@ fn atan2_64(y: f64, x: f64) f64 {
         if ((m & 2) != 0 and iy +% (64 << 20) < ix) {
             break :z 0.0;
         } else {
-            break :z math.atan(math.fabs(y / x));
+            break :z math.atan(@fabs(y / x));
         }
     };
 

@@ -115,7 +115,7 @@ pub fn Complex(comptime T: type) type {
 
         /// Returns the magnitude of a complex number.
         pub fn magnitude(self: Self) T {
-            return math.sqrt(self.re * self.re + self.im * self.im);
+            return @sqrt(self.re * self.re + self.im * self.im);
         }
     };
 }

@@ -45,7 +45,7 @@ fn cosh32(x: f32) f32 {
 
     // |x| < log(FLT_MAX)
     if (ux < 0x42B17217) {
-        const t = math.exp(ax);
+        const t = @exp(ax);
         return 0.5 * (t + 1 / t);
     }
 
@@ -77,7 +77,7 @@ fn cosh64(x: f64) f64 {
 
     // |x| < log(DBL_MAX)
     if (w < 0x40862E42) {
-        const t = math.exp(ax);
+        const t = @exp(ax);
         // NOTE: If x > log(0x1p26) then 1/t is not required.
         return 0.5 * (t + 1 / t);
     }

@@ -22,7 +22,7 @@ fn expo2f(x: f32) f32 {
 
     const u = (0x7F + k / 2) << 23;
     const scale = @bitCast(f32, u);
-    return math.exp(x - kln2) * scale * scale;
+    return @exp(x - kln2) * scale * scale;
 }
 
 fn expo2d(x: f64) f64 {
@@ -31,5 +31,5 @@ fn expo2d(x: f64) f64 {
 
     const u = (0x3FF + k / 2) << 20;
     const scale = @bitCast(f64, @as(u64, u) << 32);
-    return math.exp(x - kln2) * scale * scale;
+    return @exp(x - kln2) * scale * scale;
 }

@@ -1,45 +0,0 @@
-const std = @import("../std.zig");
-const math = std.math;
-const expect = std.testing.expect;
-
-/// Returns the absolute value of x.
-///
-/// Special Cases:
-///  - fabs(+-inf) = +inf
-///  - fabs(nan)   = nan
-pub fn fabs(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @bitSizeOf(T));
-    if (@typeInfo(T) != .Float) {
-        @compileError("fabs not implemented for " ++ @typeName(T));
-    }
-
-    const float_bits = @bitCast(TBits, x);
-    const remove_sign = ~@as(TBits, 0) >> 1;
-
-    return @bitCast(T, float_bits & remove_sign);
-}
-
-test "math.fabs" {
-    // TODO add support for c_longdouble here
-    inline for ([_]type{ f16, f32, f64, f80, f128 }) |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));
-
-        // 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));
-
-        // 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))));
-    }
-}

@@ -56,7 +56,7 @@ fn hypot32(x: f32, y: f32) f32 {
         yy *= 0x1.0p-90;
     }
 
-    return z * math.sqrt(@floatCast(f32, @as(f64, x) * x + @as(f64, y) * y));
+    return z * @sqrt(@floatCast(f32, @as(f64, x) * x + @as(f64, y) * y));
 }
 
 fn sq(hi: *f64, lo: *f64, x: f64) void {
@@ -117,7 +117,7 @@ fn hypot64(x: f64, y: f64) f64 {
     sq(&hx, &lx, x);
     sq(&hy, &ly, y);
 
-    return z * math.sqrt(ly + lx + hy + hx);
+    return z * @sqrt(ly + lx + hy + hx);
 }
 
 test "math.hypot" {

@@ -1,12 +1,6 @@
-// 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/lnf.c
-// https://git.musl-libc.org/cgit/musl/tree/src/math/ln.c
-
 const std = @import("../std.zig");
 const math = std.math;
-const expect = std.testing.expect;
+const testing = std.testing;
 
 /// Returns the natural logarithm of x.
 ///
@@ -15,175 +9,26 @@ const expect = std.testing.expect;
 ///  - ln(0)     = -inf
 ///  - ln(x)     = nan if x < 0
 ///  - ln(nan)   = nan
+///  TODO remove this in favor of `@log`.
 pub fn ln(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     switch (@typeInfo(T)) {
         .ComptimeFloat => {
-            return @as(comptime_float, ln_64(x));
-        },
-        .Float => {
-            return switch (T) {
-                f32 => ln_32(x),
-                f64 => ln_64(x),
-                else => @compileError("ln not implemented for " ++ @typeName(T)),
-            };
+            return @as(comptime_float, @log(x));
         },
+        .Float => return @log(x),
         .ComptimeInt => {
-            return @as(comptime_int, math.floor(ln_64(@as(f64, x))));
+            return @as(comptime_int, @floor(@log(@as(f64, x))));
         },
         .Int => |IntType| switch (IntType.signedness) {
             .signed => @compileError("ln not implemented for signed integers"),
-            .unsigned => return @as(T, math.floor(ln_64(@as(f64, x)))),
+            .unsigned => return @as(T, @floor(@log(@as(f64, x)))),
         },
         else => @compileError("ln not implemented for " ++ @typeName(T)),
     }
 }
 
-pub fn ln_32(x_: f32) f32 {
-    const ln2_hi: f32 = 6.9313812256e-01;
-    const ln2_lo: f32 = 9.0580006145e-06;
-    const Lg1: f32 = 0xaaaaaa.0p-24;
-    const Lg2: f32 = 0xccce13.0p-25;
-    const Lg3: f32 = 0x91e9ee.0p-25;
-    const Lg4: f32 = 0xf89e26.0p-26;
-
-    var x = x_;
-    var ix = @bitCast(u32, x);
-    var k: i32 = 0;
-
-    // x < 2^(-126)
-    if (ix < 0x00800000 or ix >> 31 != 0) {
-        // log(+-0) = -inf
-        if (ix << 1 == 0) {
-            return -math.inf(f32);
-        }
-        // log(-#) = nan
-        if (ix >> 31 != 0) {
-            return math.nan(f32);
-        }
-
-        // subnormal, scale x
-        k -= 25;
-        x *= 0x1.0p25;
-        ix = @bitCast(u32, x);
-    } else if (ix >= 0x7F800000) {
-        return x;
-    } else if (ix == 0x3F800000) {
-        return 0;
-    }
-
-    // x into [sqrt(2) / 2, sqrt(2)]
-    ix += 0x3F800000 - 0x3F3504F3;
-    k += @intCast(i32, ix >> 23) - 0x7F;
-    ix = (ix & 0x007FFFFF) + 0x3F3504F3;
-    x = @bitCast(f32, ix);
-
-    const f = x - 1.0;
-    const s = f / (2.0 + f);
-    const z = s * s;
-    const w = z * z;
-    const t1 = w * (Lg2 + w * Lg4);
-    const t2 = z * (Lg1 + w * Lg3);
-    const R = t2 + t1;
-    const hfsq = 0.5 * f * f;
-    const dk = @intToFloat(f32, k);
-
-    return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi;
-}
-
-pub fn ln_64(x_: f64) f64 {
-    const ln2_hi: f64 = 6.93147180369123816490e-01;
-    const ln2_lo: f64 = 1.90821492927058770002e-10;
-    const Lg1: f64 = 6.666666666666735130e-01;
-    const Lg2: f64 = 3.999999999940941908e-01;
-    const Lg3: f64 = 2.857142874366239149e-01;
-    const Lg4: f64 = 2.222219843214978396e-01;
-    const Lg5: f64 = 1.818357216161805012e-01;
-    const Lg6: f64 = 1.531383769920937332e-01;
-    const Lg7: f64 = 1.479819860511658591e-01;
-
-    var x = x_;
-    var ix = @bitCast(u64, x);
-    var hx = @intCast(u32, ix >> 32);
-    var k: i32 = 0;
-
-    if (hx < 0x00100000 or hx >> 31 != 0) {
-        // log(+-0) = -inf
-        if (ix << 1 == 0) {
-            return -math.inf(f64);
-        }
-        // log(-#) = nan
-        if (hx >> 31 != 0) {
-            return math.nan(f64);
-        }
-
-        // subnormal, scale x
-        k -= 54;
-        x *= 0x1.0p54;
-        hx = @intCast(u32, @bitCast(u64, ix) >> 32);
-    } else if (hx >= 0x7FF00000) {
-        return x;
-    } else if (hx == 0x3FF00000 and ix << 32 == 0) {
-        return 0;
-    }
-
-    // x into [sqrt(2) / 2, sqrt(2)]
-    hx += 0x3FF00000 - 0x3FE6A09E;
-    k += @intCast(i32, hx >> 20) - 0x3FF;
-    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;
-    ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF);
-    x = @bitCast(f64, ix);
-
-    const f = x - 1.0;
-    const hfsq = 0.5 * f * f;
-    const s = f / (2.0 + f);
-    const z = s * s;
-    const w = z * z;
-    const t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
-    const t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
-    const R = t2 + t1;
-    const dk = @intToFloat(f64, k);
-
-    return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi;
-}
-
 test "math.ln" {
-    try expect(ln(@as(f32, 0.2)) == ln_32(0.2));
-    try expect(ln(@as(f64, 0.2)) == ln_64(0.2));
-}
-
-test "math.ln32" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f32, ln_32(0.2), -1.609438, epsilon));
-    try expect(math.approxEqAbs(f32, ln_32(0.8923), -0.113953, epsilon));
-    try expect(math.approxEqAbs(f32, ln_32(1.5), 0.405465, epsilon));
-    try expect(math.approxEqAbs(f32, ln_32(37.45), 3.623007, epsilon));
-    try expect(math.approxEqAbs(f32, ln_32(89.123), 4.490017, epsilon));
-    try expect(math.approxEqAbs(f32, ln_32(123123.234375), 11.720941, epsilon));
-}
-
-test "math.ln64" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f64, ln_64(0.2), -1.609438, epsilon));
-    try expect(math.approxEqAbs(f64, ln_64(0.8923), -0.113953, epsilon));
-    try expect(math.approxEqAbs(f64, ln_64(1.5), 0.405465, epsilon));
-    try expect(math.approxEqAbs(f64, ln_64(37.45), 3.623007, epsilon));
-    try expect(math.approxEqAbs(f64, ln_64(89.123), 4.490017, epsilon));
-    try expect(math.approxEqAbs(f64, ln_64(123123.234375), 11.720941, epsilon));
-}
-
-test "math.ln32.special" {
-    try expect(math.isPositiveInf(ln_32(math.inf(f32))));
-    try expect(math.isNegativeInf(ln_32(0.0)));
-    try expect(math.isNan(ln_32(-1.0)));
-    try expect(math.isNan(ln_32(math.nan(f32))));
-}
-
-test "math.ln64.special" {
-    try expect(math.isPositiveInf(ln_64(math.inf(f64))));
-    try expect(math.isNegativeInf(ln_64(0.0)));
-    try expect(math.isNan(ln_64(-1.0)));
-    try expect(math.isNan(ln_64(math.nan(f64))));
+    try testing.expect(ln(@as(f32, 0.2)) == @log(0.2));
+    try testing.expect(ln(@as(f64, 0.2)) == @log(0.2));
 }

@@ -15,28 +15,28 @@ pub fn log(comptime T: type, base: T, x: T) T {
     } else if (base == 10) {
         return math.log10(x);
     } else if ((@typeInfo(T) == .Float or @typeInfo(T) == .ComptimeFloat) and base == math.e) {
-        return math.ln(x);
+        return @log(x);
     }
 
     const float_base = math.lossyCast(f64, base);
     switch (@typeInfo(T)) {
         .ComptimeFloat => {
-            return @as(comptime_float, math.ln(@as(f64, x)) / math.ln(float_base));
+            return @as(comptime_float, @log(@as(f64, x)) / @log(float_base));
         },
         .ComptimeInt => {
-            return @as(comptime_int, math.floor(math.ln(@as(f64, x)) / math.ln(float_base)));
+            return @as(comptime_int, @floor(@log(@as(f64, x)) / @log(float_base)));
         },
 
         // TODO implement integer log without using float math
         .Int => |IntType| switch (IntType.signedness) {
             .signed => @compileError("log not implemented for signed integers"),
-            .unsigned => return @floatToInt(T, math.floor(math.ln(@intToFloat(f64, x)) / math.ln(float_base))),
+            .unsigned => return @floatToInt(T, @floor(@log(@intToFloat(f64, x)) / @log(float_base))),
         },
 
         .Float => {
             switch (T) {
-                f32 => return @floatCast(f32, math.ln(@as(f64, x)) / math.ln(float_base)),
-                f64 => return math.ln(x) / math.ln(float_base),
+                f32 => return @floatCast(f32, @log(@as(f64, x)) / @log(float_base)),
+                f64 => return @log(x) / @log(float_base),
                 else => @compileError("log not implemented for " ++ @typeName(T)),
             }
         },

@@ -1,9 +1,3 @@
-// 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/log10f.c
-// https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c
-
 const std = @import("../std.zig");
 const math = std.math;
 const testing = std.testing;
@@ -20,198 +14,16 @@ pub fn log10(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     switch (@typeInfo(T)) {
         .ComptimeFloat => {
-            return @as(comptime_float, log10_64(x));
-        },
-        .Float => {
-            return switch (T) {
-                f32 => log10_32(x),
-                f64 => log10_64(x),
-                else => @compileError("log10 not implemented for " ++ @typeName(T)),
-            };
+            return @as(comptime_float, @log10(x));
         },
+        .Float => return @log10(x),
         .ComptimeInt => {
-            return @as(comptime_int, math.floor(log10_64(@as(f64, x))));
+            return @as(comptime_int, @floor(@log10(@as(f64, x))));
         },
         .Int => |IntType| switch (IntType.signedness) {
             .signed => @compileError("log10 not implemented for signed integers"),
-            .unsigned => return @floatToInt(T, math.floor(log10_64(@intToFloat(f64, x)))),
+            .unsigned => return @floatToInt(T, @floor(@log10(@intToFloat(f64, x)))),
         },
         else => @compileError("log10 not implemented for " ++ @typeName(T)),
     }
 }
-
-pub fn log10_32(x_: f32) f32 {
-    const ivln10hi: f32 = 4.3432617188e-01;
-    const ivln10lo: f32 = -3.1689971365e-05;
-    const log10_2hi: f32 = 3.0102920532e-01;
-    const log10_2lo: f32 = 7.9034151668e-07;
-    const Lg1: f32 = 0xaaaaaa.0p-24;
-    const Lg2: f32 = 0xccce13.0p-25;
-    const Lg3: f32 = 0x91e9ee.0p-25;
-    const Lg4: f32 = 0xf89e26.0p-26;
-
-    var x = x_;
-    var u = @bitCast(u32, x);
-    var ix = u;
-    var k: i32 = 0;
-
-    // x < 2^(-126)
-    if (ix < 0x00800000 or ix >> 31 != 0) {
-        // log(+-0) = -inf
-        if (ix << 1 == 0) {
-            return -math.inf(f32);
-        }
-        // log(-#) = nan
-        if (ix >> 31 != 0) {
-            return math.nan(f32);
-        }
-
-        k -= 25;
-        x *= 0x1.0p25;
-        ix = @bitCast(u32, x);
-    } else if (ix >= 0x7F800000) {
-        return x;
-    } else if (ix == 0x3F800000) {
-        return 0;
-    }
-
-    // x into [sqrt(2) / 2, sqrt(2)]
-    ix += 0x3F800000 - 0x3F3504F3;
-    k += @intCast(i32, ix >> 23) - 0x7F;
-    ix = (ix & 0x007FFFFF) + 0x3F3504F3;
-    x = @bitCast(f32, ix);
-
-    const f = x - 1.0;
-    const s = f / (2.0 + f);
-    const z = s * s;
-    const w = z * z;
-    const t1 = w * (Lg2 + w * Lg4);
-    const t2 = z * (Lg1 + w * Lg3);
-    const R = t2 + t1;
-    const hfsq = 0.5 * f * f;
-
-    var hi = f - hfsq;
-    u = @bitCast(u32, hi);
-    u &= 0xFFFFF000;
-    hi = @bitCast(f32, u);
-    const lo = f - hi - hfsq + s * (hfsq + R);
-    const dk = @intToFloat(f32, k);
-
-    return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;
-}
-
-pub fn log10_64(x_: f64) f64 {
-    const ivln10hi: f64 = 4.34294481878168880939e-01;
-    const ivln10lo: f64 = 2.50829467116452752298e-11;
-    const log10_2hi: f64 = 3.01029995663611771306e-01;
-    const log10_2lo: f64 = 3.69423907715893078616e-13;
-    const Lg1: f64 = 6.666666666666735130e-01;
-    const Lg2: f64 = 3.999999999940941908e-01;
-    const Lg3: f64 = 2.857142874366239149e-01;
-    const Lg4: f64 = 2.222219843214978396e-01;
-    const Lg5: f64 = 1.818357216161805012e-01;
-    const Lg6: f64 = 1.531383769920937332e-01;
-    const Lg7: f64 = 1.479819860511658591e-01;
-
-    var x = x_;
-    var ix = @bitCast(u64, x);
-    var hx = @intCast(u32, ix >> 32);
-    var k: i32 = 0;
-
-    if (hx < 0x00100000 or hx >> 31 != 0) {
-        // log(+-0) = -inf
-        if (ix << 1 == 0) {
-            return -math.inf(f32);
-        }
-        // log(-#) = nan
-        if (hx >> 31 != 0) {
-            return math.nan(f32);
-        }
-
-        // subnormal, scale x
-        k -= 54;
-        x *= 0x1.0p54;
-        hx = @intCast(u32, @bitCast(u64, x) >> 32);
-    } else if (hx >= 0x7FF00000) {
-        return x;
-    } else if (hx == 0x3FF00000 and ix << 32 == 0) {
-        return 0;
-    }
-
-    // x into [sqrt(2) / 2, sqrt(2)]
-    hx += 0x3FF00000 - 0x3FE6A09E;
-    k += @intCast(i32, hx >> 20) - 0x3FF;
-    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;
-    ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF);
-    x = @bitCast(f64, ix);
-
-    const f = x - 1.0;
-    const hfsq = 0.5 * f * f;
-    const s = f / (2.0 + f);
-    const z = s * s;
-    const w = z * z;
-    const t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
-    const t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
-    const R = t2 + t1;
-
-    // hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f)
-    var hi = f - hfsq;
-    var hii = @bitCast(u64, hi);
-    hii &= @as(u64, maxInt(u64)) << 32;
-    hi = @bitCast(f64, hii);
-    const lo = f - hi - hfsq + s * (hfsq + R);
-
-    // val_hi + val_lo ~ log10(1 + f) + k * log10(2)
-    var val_hi = hi * ivln10hi;
-    const dk = @intToFloat(f64, k);
-    const y = dk * log10_2hi;
-    var val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;
-
-    // Extra precision multiplication
-    const ww = y + val_hi;
-    val_lo += (y - ww) + val_hi;
-    val_hi = ww;
-
-    return val_lo + val_hi;
-}
-
-test "math.log10" {
-    try testing.expect(log10(@as(f32, 0.2)) == log10_32(0.2));
-    try testing.expect(log10(@as(f64, 0.2)) == log10_64(0.2));
-}
-
-test "math.log10_32" {
-    const epsilon = 0.000001;
-
-    try testing.expect(math.approxEqAbs(f32, log10_32(0.2), -0.698970, epsilon));
-    try testing.expect(math.approxEqAbs(f32, log10_32(0.8923), -0.049489, epsilon));
-    try testing.expect(math.approxEqAbs(f32, log10_32(1.5), 0.176091, epsilon));
-    try testing.expect(math.approxEqAbs(f32, log10_32(37.45), 1.573452, epsilon));
-    try testing.expect(math.approxEqAbs(f32, log10_32(89.123), 1.94999, epsilon));
-    try testing.expect(math.approxEqAbs(f32, log10_32(123123.234375), 5.09034, epsilon));
-}
-
-test "math.log10_64" {
-    const epsilon = 0.000001;
-
-    try testing.expect(math.approxEqAbs(f64, log10_64(0.2), -0.698970, epsilon));
-    try testing.expect(math.approxEqAbs(f64, log10_64(0.8923), -0.049489, epsilon));
-    try testing.expect(math.approxEqAbs(f64, log10_64(1.5), 0.176091, epsilon));
-    try testing.expect(math.approxEqAbs(f64, log10_64(37.45), 1.573452, epsilon));
-    try testing.expect(math.approxEqAbs(f64, log10_64(89.123), 1.94999, epsilon));
-    try testing.expect(math.approxEqAbs(f64, log10_64(123123.234375), 5.09034, epsilon));
-}
-
-test "math.log10_32.special" {
-    try testing.expect(math.isPositiveInf(log10_32(math.inf(f32))));
-    try testing.expect(math.isNegativeInf(log10_32(0.0)));
-    try testing.expect(math.isNan(log10_32(-1.0)));
-    try testing.expect(math.isNan(log10_32(math.nan(f32))));
-}
-
-test "math.log10_64.special" {
-    try testing.expect(math.isPositiveInf(log10_64(math.inf(f64))));
-    try testing.expect(math.isNegativeInf(log10_64(0.0)));
-    try testing.expect(math.isNan(log10_64(-1.0)));
-    try testing.expect(math.isNan(log10_64(math.nan(f64))));
-}

@@ -1,13 +1,6 @@
-// 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/log2f.c
-// https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c
-
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
-const maxInt = std.math.maxInt;
 
 /// Returns the base-2 logarithm of x.
 ///
@@ -20,15 +13,9 @@ pub fn log2(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     switch (@typeInfo(T)) {
         .ComptimeFloat => {
-            return @as(comptime_float, log2_64(x));
-        },
-        .Float => {
-            return switch (T) {
-                f32 => log2_32(x),
-                f64 => log2_64(x),
-                else => @compileError("log2 not implemented for " ++ @typeName(T)),
-            };
+            return @as(comptime_float, @log2(x));
         },
+        .Float => return @log2(x),
         .ComptimeInt => comptime {
             var result = 0;
             var x_shifted = x;
@@ -46,168 +33,7 @@ pub fn log2(x: anytype) @TypeOf(x) {
     }
 }
 
-pub fn log2_32(x_: f32) f32 {
-    const ivln2hi: f32 = 1.4428710938e+00;
-    const ivln2lo: f32 = -1.7605285393e-04;
-    const Lg1: f32 = 0xaaaaaa.0p-24;
-    const Lg2: f32 = 0xccce13.0p-25;
-    const Lg3: f32 = 0x91e9ee.0p-25;
-    const Lg4: f32 = 0xf89e26.0p-26;
-
-    var x = x_;
-    var u = @bitCast(u32, x);
-    var ix = u;
-    var k: i32 = 0;
-
-    // x < 2^(-126)
-    if (ix < 0x00800000 or ix >> 31 != 0) {
-        // log(+-0) = -inf
-        if (ix << 1 == 0) {
-            return -math.inf(f32);
-        }
-        // log(-#) = nan
-        if (ix >> 31 != 0) {
-            return math.nan(f32);
-        }
-
-        k -= 25;
-        x *= 0x1.0p25;
-        ix = @bitCast(u32, x);
-    } else if (ix >= 0x7F800000) {
-        return x;
-    } else if (ix == 0x3F800000) {
-        return 0;
-    }
-
-    // x into [sqrt(2) / 2, sqrt(2)]
-    ix += 0x3F800000 - 0x3F3504F3;
-    k += @intCast(i32, ix >> 23) - 0x7F;
-    ix = (ix & 0x007FFFFF) + 0x3F3504F3;
-    x = @bitCast(f32, ix);
-
-    const f = x - 1.0;
-    const s = f / (2.0 + f);
-    const z = s * s;
-    const w = z * z;
-    const t1 = w * (Lg2 + w * Lg4);
-    const t2 = z * (Lg1 + w * Lg3);
-    const R = t2 + t1;
-    const hfsq = 0.5 * f * f;
-
-    var hi = f - hfsq;
-    u = @bitCast(u32, hi);
-    u &= 0xFFFFF000;
-    hi = @bitCast(f32, u);
-    const lo = f - hi - hfsq + s * (hfsq + R);
-    return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + @intToFloat(f32, k);
-}
-
-pub fn log2_64(x_: f64) f64 {
-    const ivln2hi: f64 = 1.44269504072144627571e+00;
-    const ivln2lo: f64 = 1.67517131648865118353e-10;
-    const Lg1: f64 = 6.666666666666735130e-01;
-    const Lg2: f64 = 3.999999999940941908e-01;
-    const Lg3: f64 = 2.857142874366239149e-01;
-    const Lg4: f64 = 2.222219843214978396e-01;
-    const Lg5: f64 = 1.818357216161805012e-01;
-    const Lg6: f64 = 1.531383769920937332e-01;
-    const Lg7: f64 = 1.479819860511658591e-01;
-
-    var x = x_;
-    var ix = @bitCast(u64, x);
-    var hx = @intCast(u32, ix >> 32);
-    var k: i32 = 0;
-
-    if (hx < 0x00100000 or hx >> 31 != 0) {
-        // log(+-0) = -inf
-        if (ix << 1 == 0) {
-            return -math.inf(f64);
-        }
-        // log(-#) = nan
-        if (hx >> 31 != 0) {
-            return math.nan(f64);
-        }
-
-        // subnormal, scale x
-        k -= 54;
-        x *= 0x1.0p54;
-        hx = @intCast(u32, @bitCast(u64, x) >> 32);
-    } else if (hx >= 0x7FF00000) {
-        return x;
-    } else if (hx == 0x3FF00000 and ix << 32 == 0) {
-        return 0;
-    }
-
-    // x into [sqrt(2) / 2, sqrt(2)]
-    hx += 0x3FF00000 - 0x3FE6A09E;
-    k += @intCast(i32, hx >> 20) - 0x3FF;
-    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;
-    ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF);
-    x = @bitCast(f64, ix);
-
-    const f = x - 1.0;
-    const hfsq = 0.5 * f * f;
-    const s = f / (2.0 + f);
-    const z = s * s;
-    const w = z * z;
-    const t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
-    const t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
-    const R = t2 + t1;
-
-    // hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f)
-    var hi = f - hfsq;
-    var hii = @bitCast(u64, hi);
-    hii &= @as(u64, maxInt(u64)) << 32;
-    hi = @bitCast(f64, hii);
-    const lo = f - hi - hfsq + s * (hfsq + R);
-
-    var val_hi = hi * ivln2hi;
-    var val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;
-
-    // spadd(val_hi, val_lo, y)
-    const y = @intToFloat(f64, k);
-    const ww = y + val_hi;
-    val_lo += (y - ww) + val_hi;
-    val_hi = ww;
-
-    return val_lo + val_hi;
-}
-
-test "math.log2" {
-    try expect(log2(@as(f32, 0.2)) == log2_32(0.2));
-    try expect(log2(@as(f64, 0.2)) == log2_64(0.2));
-}
-
-test "math.log2_32" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f32, log2_32(0.2), -2.321928, epsilon));
-    try expect(math.approxEqAbs(f32, log2_32(0.8923), -0.164399, epsilon));
-    try expect(math.approxEqAbs(f32, log2_32(1.5), 0.584962, epsilon));
-    try expect(math.approxEqAbs(f32, log2_32(37.45), 5.226894, epsilon));
-    try expect(math.approxEqAbs(f32, log2_32(123123.234375), 16.909744, epsilon));
-}
-
-test "math.log2_64" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f64, log2_64(0.2), -2.321928, epsilon));
-    try expect(math.approxEqAbs(f64, log2_64(0.8923), -0.164399, epsilon));
-    try expect(math.approxEqAbs(f64, log2_64(1.5), 0.584962, epsilon));
-    try expect(math.approxEqAbs(f64, log2_64(37.45), 5.226894, epsilon));
-    try expect(math.approxEqAbs(f64, log2_64(123123.234375), 16.909744, epsilon));
-}
-
-test "math.log2_32.special" {
-    try expect(math.isPositiveInf(log2_32(math.inf(f32))));
-    try expect(math.isNegativeInf(log2_32(0.0)));
-    try expect(math.isNan(log2_32(-1.0)));
-    try expect(math.isNan(log2_32(math.nan(f32))));
-}
-
-test "math.log2_64.special" {
-    try expect(math.isPositiveInf(log2_64(math.inf(f64))));
-    try expect(math.isNegativeInf(log2_64(0.0)));
-    try expect(math.isNan(log2_64(-1.0)));
-    try expect(math.isNan(log2_64(math.nan(f64))));
+test "log2" {
+    try expect(log2(@as(f32, 0.2)) == @log2(0.2));
+    try expect(log2(@as(f64, 0.2)) == @log2(0.2));
 }

@@ -2,13 +2,13 @@ const math = @import("../math.zig");
 
 /// Returns the nan representation for type T.
 pub fn nan(comptime T: type) T {
-    return switch (T) {
-        f16 => math.nan_f16,
-        f32 => math.nan_f32,
-        f64 => math.nan_f64,
-        f80 => math.nan_f80,
-        f128 => math.nan_f128,
-        else => @compileError("nan not implemented for " ++ @typeName(T)),
+    return switch (@typeInfo(T).Float.bits) {
+        16 => math.nan_f16,
+        32 => math.nan_f32,
+        64 => math.nan_f64,
+        80 => math.nan_f80,
+        128 => math.nan_f128,
+        else => @compileError("unreachable"),
     };
 }
 
@@ -16,12 +16,12 @@ pub fn nan(comptime T: type) T {
 pub fn snan(comptime T: type) T {
     // Note: A signalling nan is identical to a standard right now by may have a different bit
     // representation in the future when required.
-    return switch (T) {
-        f16 => @bitCast(f16, math.nan_u16),
-        f32 => @bitCast(f32, math.nan_u32),
-        f64 => @bitCast(f64, math.nan_u64),
-        f80 => @bitCast(f80, math.nan_u80),
-        f128 => @bitCast(f128, math.nan_u128),
-        else => @compileError("snan not implemented for " ++ @typeName(T)),
+    return switch (@typeInfo(T).Float.bits) {
+        16 => math.nan_u16,
+        32 => math.nan_u32,
+        64 => math.nan_u64,
+        80 => math.nan_u80,
+        128 => math.nan_u128,
+        else => @compileError("unreachable"),
     };
 }

@@ -82,7 +82,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
         }
         // pow(x, +inf) = +0    for |x| < 1
         // pow(x, -inf) = +0    for |x| > 1
-        else if ((math.fabs(x) < 1) == math.isPositiveInf(y)) {
+        else if ((@fabs(x) < 1) == math.isPositiveInf(y)) {
             return 0;
         }
         // pow(x, -inf) = +inf  for |x| < 1
@@ -108,14 +108,14 @@ pub fn pow(comptime T: type, x: T, y: T) T {
 
     // special case sqrt
     if (y == 0.5) {
-        return math.sqrt(x);
+        return @sqrt(x);
     }
 
     if (y == -0.5) {
-        return 1 / math.sqrt(x);
+        return 1 / @sqrt(x);
     }
 
-    const r1 = math.modf(math.fabs(y));
+    const r1 = math.modf(@fabs(y));
     var yi = r1.ipart;
     var yf = r1.fpart;
 
@@ -123,7 +123,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
         return math.nan(T);
     }
     if (yi >= 1 << (@typeInfo(T).Float.bits - 1)) {
-        return math.exp(y * math.ln(x));
+        return @exp(y * @log(x));
     }
 
     // a = a1 * 2^ae
@@ -136,7 +136,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
             yf -= 1;
             yi += 1;
         }
-        a1 = math.exp(yf * math.ln(x));
+        a1 = @exp(yf * @log(x));
     }
 
     // a *= x^yi

@@ -1,185 +0,0 @@
-// 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/roundf.c
-// https://git.musl-libc.org/cgit/musl/tree/src/math/round.c
-
-const expect = std.testing.expect;
-const std = @import("../std.zig");
-const math = std.math;
-
-/// Returns x rounded to the nearest integer, rounding half away from zero.
-///
-/// Special Cases:
-///  - round(+-0)   = +-0
-///  - round(+-inf) = +-inf
-///  - round(nan)   = nan
-pub fn round(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    return switch (T) {
-        f32 => round32(x),
-        f64 => round64(x),
-        f128 => round128(x),
-
-        // TODO this is not correct for some targets
-        c_longdouble => @floatCast(c_longdouble, round128(x)),
-
-        else => @compileError("round not implemented for " ++ @typeName(T)),
-    };
-}
-
-fn round32(x_: f32) f32 {
-    const f32_toint = 1.0 / math.floatEps(f32);
-
-    var x = x_;
-    const u = @bitCast(u32, x);
-    const e = (u >> 23) & 0xFF;
-    var y: f32 = undefined;
-
-    if (e >= 0x7F + 23) {
-        return x;
-    }
-    if (u >> 31 != 0) {
-        x = -x;
-    }
-    if (e < 0x7F - 1) {
-        math.doNotOptimizeAway(x + f32_toint);
-        return 0 * @bitCast(f32, u);
-    }
-
-    y = x + f32_toint - f32_toint - x;
-    if (y > 0.5) {
-        y = y + x - 1;
-    } else if (y <= -0.5) {
-        y = y + x + 1;
-    } else {
-        y = y + x;
-    }
-
-    if (u >> 31 != 0) {
-        return -y;
-    } else {
-        return y;
-    }
-}
-
-fn round64(x_: f64) f64 {
-    const f64_toint = 1.0 / math.floatEps(f64);
-
-    var x = x_;
-    const u = @bitCast(u64, x);
-    const e = (u >> 52) & 0x7FF;
-    var y: f64 = undefined;
-
-    if (e >= 0x3FF + 52) {
-        return x;
-    }
-    if (u >> 63 != 0) {
-        x = -x;
-    }
-    if (e < 0x3ff - 1) {
-        math.doNotOptimizeAway(x + f64_toint);
-        return 0 * @bitCast(f64, u);
-    }
-
-    y = x + f64_toint - f64_toint - x;
-    if (y > 0.5) {
-        y = y + x - 1;
-    } else if (y <= -0.5) {
-        y = y + x + 1;
-    } else {
-        y = y + x;
-    }
-
-    if (u >> 63 != 0) {
-        return -y;
-    } else {
-        return y;
-    }
-}
-
-fn round128(x_: f128) f128 {
-    const f128_toint = 1.0 / math.floatEps(f128);
-
-    var x = x_;
-    const u = @bitCast(u128, x);
-    const e = (u >> 112) & 0x7FFF;
-    var y: f128 = undefined;
-
-    if (e >= 0x3FFF + 112) {
-        return x;
-    }
-    if (u >> 127 != 0) {
-        x = -x;
-    }
-    if (e < 0x3FFF - 1) {
-        math.doNotOptimizeAway(x + f128_toint);
-        return 0 * @bitCast(f128, u);
-    }
-
-    y = x + f128_toint - f128_toint - x;
-    if (y > 0.5) {
-        y = y + x - 1;
-    } else if (y <= -0.5) {
-        y = y + x + 1;
-    } else {
-        y = y + x;
-    }
-
-    if (u >> 127 != 0) {
-        return -y;
-    } else {
-        return y;
-    }
-}
-
-test "math.round" {
-    try expect(round(@as(f32, 1.3)) == round32(1.3));
-    try expect(round(@as(f64, 1.3)) == round64(1.3));
-    try expect(round(@as(f128, 1.3)) == round128(1.3));
-}
-
-test "math.round32" {
-    try expect(round32(1.3) == 1.0);
-    try expect(round32(-1.3) == -1.0);
-    try expect(round32(0.2) == 0.0);
-    try expect(round32(1.8) == 2.0);
-}
-
-test "math.round64" {
-    try expect(round64(1.3) == 1.0);
-    try expect(round64(-1.3) == -1.0);
-    try expect(round64(0.2) == 0.0);
-    try expect(round64(1.8) == 2.0);
-}
-
-test "math.round128" {
-    try expect(round128(1.3) == 1.0);
-    try expect(round128(-1.3) == -1.0);
-    try expect(round128(0.2) == 0.0);
-    try expect(round128(1.8) == 2.0);
-}
-
-test "math.round32.special" {
-    try expect(round32(0.0) == 0.0);
-    try expect(round32(-0.0) == -0.0);
-    try expect(math.isPositiveInf(round32(math.inf(f32))));
-    try expect(math.isNegativeInf(round32(-math.inf(f32))));
-    try expect(math.isNan(round32(math.nan(f32))));
-}
-
-test "math.round64.special" {
-    try expect(round64(0.0) == 0.0);
-    try expect(round64(-0.0) == -0.0);
-    try expect(math.isPositiveInf(round64(math.inf(f64))));
-    try expect(math.isNegativeInf(round64(-math.inf(f64))));
-    try expect(math.isNan(round64(math.nan(f64))));
-}
-
-test "math.round128.special" {
-    try expect(round128(0.0) == 0.0);
-    try expect(round128(-0.0) == -0.0);
-    try expect(math.isPositiveInf(round128(math.inf(f128))));
-    try expect(math.isNegativeInf(round128(-math.inf(f128))));
-    try expect(math.isNan(round128(math.nan(f128))));
-}

@@ -1,141 +0,0 @@
-// 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/truncf.c
-// https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c
-
-const std = @import("../std.zig");
-const math = std.math;
-const expect = std.testing.expect;
-const maxInt = std.math.maxInt;
-
-/// Returns the integer value of x.
-///
-/// Special Cases:
-///  - trunc(+-0)   = +-0
-///  - trunc(+-inf) = +-inf
-///  - trunc(nan)   = nan
-pub fn trunc(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    return switch (T) {
-        f32 => trunc32(x),
-        f64 => trunc64(x),
-        f128 => trunc128(x),
-
-        // TODO this is not correct for some targets
-        c_longdouble => @floatCast(c_longdouble, trunc128(x)),
-
-        else => @compileError("trunc not implemented for " ++ @typeName(T)),
-    };
-}
-
-fn trunc32(x: f32) f32 {
-    const u = @bitCast(u32, x);
-    var e = @intCast(i32, ((u >> 23) & 0xFF)) - 0x7F + 9;
-    var m: u32 = undefined;
-
-    if (e >= 23 + 9) {
-        return x;
-    }
-    if (e < 9) {
-        e = 1;
-    }
-
-    m = @as(u32, maxInt(u32)) >> @intCast(u5, e);
-    if (u & m == 0) {
-        return x;
-    } else {
-        math.doNotOptimizeAway(x + 0x1p120);
-        return @bitCast(f32, u & ~m);
-    }
-}
-
-fn trunc64(x: f64) f64 {
-    const u = @bitCast(u64, x);
-    var e = @intCast(i32, ((u >> 52) & 0x7FF)) - 0x3FF + 12;
-    var m: u64 = undefined;
-
-    if (e >= 52 + 12) {
-        return x;
-    }
-    if (e < 12) {
-        e = 1;
-    }
-
-    m = @as(u64, maxInt(u64)) >> @intCast(u6, e);
-    if (u & m == 0) {
-        return x;
-    } else {
-        math.doNotOptimizeAway(x + 0x1p120);
-        return @bitCast(f64, u & ~m);
-    }
-}
-
-fn trunc128(x: f128) f128 {
-    const u = @bitCast(u128, x);
-    var e = @intCast(i32, ((u >> 112) & 0x7FFF)) - 0x3FFF + 16;
-    var m: u128 = undefined;
-
-    if (e >= 112 + 16) {
-        return x;
-    }
-    if (e < 16) {
-        e = 1;
-    }
-
-    m = @as(u128, maxInt(u128)) >> @intCast(u7, e);
-    if (u & m == 0) {
-        return x;
-    } else {
-        math.doNotOptimizeAway(x + 0x1p120);
-        return @bitCast(f128, u & ~m);
-    }
-}
-
-test "math.trunc" {
-    try expect(trunc(@as(f32, 1.3)) == trunc32(1.3));
-    try expect(trunc(@as(f64, 1.3)) == trunc64(1.3));
-    try expect(trunc(@as(f128, 1.3)) == trunc128(1.3));
-}
-
-test "math.trunc32" {
-    try expect(trunc32(1.3) == 1.0);
-    try expect(trunc32(-1.3) == -1.0);
-    try expect(trunc32(0.2) == 0.0);
-}
-
-test "math.trunc64" {
-    try expect(trunc64(1.3) == 1.0);
-    try expect(trunc64(-1.3) == -1.0);
-    try expect(trunc64(0.2) == 0.0);
-}
-
-test "math.trunc128" {
-    try expect(trunc128(1.3) == 1.0);
-    try expect(trunc128(-1.3) == -1.0);
-    try expect(trunc128(0.2) == 0.0);
-}
-
-test "math.trunc32.special" {
-    try expect(trunc32(0.0) == 0.0); // 0x3F800000
-    try expect(trunc32(-0.0) == -0.0);
-    try expect(math.isPositiveInf(trunc32(math.inf(f32))));
-    try expect(math.isNegativeInf(trunc32(-math.inf(f32))));
-    try expect(math.isNan(trunc32(math.nan(f32))));
-}
-
-test "math.trunc64.special" {
-    try expect(trunc64(0.0) == 0.0);
-    try expect(trunc64(-0.0) == -0.0);
-    try expect(math.isPositiveInf(trunc64(math.inf(f64))));
-    try expect(math.isNegativeInf(trunc64(-math.inf(f64))));
-    try expect(math.isNan(trunc64(math.nan(f64))));
-}
-
-test "math.trunc128.special" {
-    try expect(trunc128(0.0) == 0.0);
-    try expect(trunc128(-0.0) == -0.0);
-    try expect(math.isPositiveInf(trunc128(math.inf(f128))));
-    try expect(math.isNegativeInf(trunc128(-math.inf(f128))));
-    try expect(math.isNan(trunc128(math.nan(f128))));
-}

@@ -33,7 +33,7 @@ pub fn next_f64(random: Random, comptime tables: ZigTable) f64 {
         };
 
         const x = u * tables.x[i];
-        const test_x = if (tables.is_symmetric) math.fabs(x) else x;
+        const test_x = if (tables.is_symmetric) @fabs(x) else x;
 
         // equivalent to |u| < tables.x[i+1] / tables.x[i] (or u < tables.x[i+1] / tables.x[i])
         if (test_x < tables.x[i + 1]) {
@@ -106,18 +106,18 @@ const norm_r = 3.6541528853610088;
 const norm_v = 0.00492867323399;
 
 fn norm_f(x: f64) f64 {
-    return math.exp(-x * x / 2.0);
+    return @exp(-x * x / 2.0);
 }
 fn norm_f_inv(y: f64) f64 {
-    return math.sqrt(-2.0 * math.ln(y));
+    return @sqrt(-2.0 * @log(y));
 }
 fn norm_zero_case(random: Random, u: f64) f64 {
     var x: f64 = 1;
     var y: f64 = 0;
 
     while (-2.0 * y < x * x) {
-        x = math.ln(random.float(f64)) / norm_r;
-        y = math.ln(random.float(f64));
+        x = @log(random.float(f64)) / norm_r;
+        y = @log(random.float(f64));
     }
 
     if (u < 0) {
@@ -151,13 +151,13 @@ const exp_r = 7.69711747013104972;
 const exp_v = 0.0039496598225815571993;
 
 fn exp_f(x: f64) f64 {
-    return math.exp(-x);
+    return @exp(-x);
 }
 fn exp_f_inv(y: f64) f64 {
-    return -math.ln(y);
+    return -@log(y);
 }
 fn exp_zero_case(random: Random, _: f64) f64 {
-    return exp_r - math.ln(random.float(f64));
+    return exp_r - @log(random.float(f64));
 }
 
 test "exp dist sanity" {

@@ -4,31 +4,16 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/ceilf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/ceil.c
 
-const std = @import("../std.zig");
+const std = @import("std");
 const math = std.math;
 const expect = std.testing.expect;
 
-/// Returns the least integer value greater than of equal to x.
-///
-/// Special Cases:
-///  - ceil(+-0)   = +-0
-///  - ceil(+-inf) = +-inf
-///  - ceil(nan)   = nan
-pub fn ceil(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    return switch (T) {
-        f32 => ceil32(x),
-        f64 => ceil64(x),
-        f128 => ceil128(x),
-
-        // TODO this is not correct for some targets
-        c_longdouble => @floatCast(c_longdouble, ceil128(x)),
-
-        else => @compileError("ceil not implemented for " ++ @typeName(T)),
-    };
+pub fn __ceilh(x: f16) callconv(.C) f16 {
+    // TODO: more efficient implementation
+    return @floatCast(f16, ceilf(x));
 }
 
-fn ceil32(x: f32) f32 {
+pub fn ceilf(x: f32) callconv(.C) f32 {
     var u = @bitCast(u32, x);
     var e = @intCast(i32, (u >> 23) & 0xFF) - 0x7F;
     var m: u32 = undefined;
@@ -61,7 +46,7 @@ fn ceil32(x: f32) f32 {
     }
 }
 
-fn ceil64(x: f64) f64 {
+pub fn ceil(x: f64) callconv(.C) f64 {
     const f64_toint = 1.0 / math.floatEps(f64);
 
     const u = @bitCast(u64, x);
@@ -92,7 +77,12 @@ fn ceil64(x: f64) f64 {
     }
 }
 
-fn ceil128(x: f128) f128 {
+pub fn __ceilx(x: f80) callconv(.C) f80 {
+    // TODO: more efficient implementation
+    return @floatCast(f80, ceilq(x));
+}
+
+pub fn ceilq(x: f128) callconv(.C) f128 {
     const f128_toint = 1.0 / math.floatEps(f128);
 
     const u = @bitCast(u128, x);
@@ -121,50 +111,44 @@ fn ceil128(x: f128) f128 {
     }
 }
 
-test "math.ceil" {
-    try expect(ceil(@as(f32, 0.0)) == ceil32(0.0));
-    try expect(ceil(@as(f64, 0.0)) == ceil64(0.0));
-    try expect(ceil(@as(f128, 0.0)) == ceil128(0.0));
-}
-
-test "math.ceil32" {
-    try expect(ceil32(1.3) == 2.0);
-    try expect(ceil32(-1.3) == -1.0);
-    try expect(ceil32(0.2) == 1.0);
+test "ceil32" {
+    try expect(ceilf(1.3) == 2.0);
+    try expect(ceilf(-1.3) == -1.0);
+    try expect(ceilf(0.2) == 1.0);
 }
 
-test "math.ceil64" {
-    try expect(ceil64(1.3) == 2.0);
-    try expect(ceil64(-1.3) == -1.0);
-    try expect(ceil64(0.2) == 1.0);
+test "ceil64" {
+    try expect(ceil(1.3) == 2.0);
+    try expect(ceil(-1.3) == -1.0);
+    try expect(ceil(0.2) == 1.0);
 }
 
-test "math.ceil128" {
-    try expect(ceil128(1.3) == 2.0);
-    try expect(ceil128(-1.3) == -1.0);
-    try expect(ceil128(0.2) == 1.0);
+test "ceil128" {
+    try expect(ceilq(1.3) == 2.0);
+    try expect(ceilq(-1.3) == -1.0);
+    try expect(ceilq(0.2) == 1.0);
 }
 
-test "math.ceil32.special" {
-    try expect(ceil32(0.0) == 0.0);
-    try expect(ceil32(-0.0) == -0.0);
-    try expect(math.isPositiveInf(ceil32(math.inf(f32))));
-    try expect(math.isNegativeInf(ceil32(-math.inf(f32))));
-    try expect(math.isNan(ceil32(math.nan(f32))));
+test "ceil32.special" {
+    try expect(ceilf(0.0) == 0.0);
+    try expect(ceilf(-0.0) == -0.0);
+    try expect(math.isPositiveInf(ceilf(math.inf(f32))));
+    try expect(math.isNegativeInf(ceilf(-math.inf(f32))));
+    try expect(math.isNan(ceilf(math.nan(f32))));
 }
 
-test "math.ceil64.special" {
-    try expect(ceil64(0.0) == 0.0);
-    try expect(ceil64(-0.0) == -0.0);
-    try expect(math.isPositiveInf(ceil64(math.inf(f64))));
-    try expect(math.isNegativeInf(ceil64(-math.inf(f64))));
-    try expect(math.isNan(ceil64(math.nan(f64))));
+test "ceil64.special" {
+    try expect(ceil(0.0) == 0.0);
+    try expect(ceil(-0.0) == -0.0);
+    try expect(math.isPositiveInf(ceil(math.inf(f64))));
+    try expect(math.isNegativeInf(ceil(-math.inf(f64))));
+    try expect(math.isNan(ceil(math.nan(f64))));
 }
 
-test "math.ceil128.special" {
-    try expect(ceil128(0.0) == 0.0);
-    try expect(ceil128(-0.0) == -0.0);
-    try expect(math.isPositiveInf(ceil128(math.inf(f128))));
-    try expect(math.isNegativeInf(ceil128(-math.inf(f128))));
-    try expect(math.isNan(ceil128(math.nan(f128))));
+test "ceil128.special" {
+    try expect(ceilq(0.0) == 0.0);
+    try expect(ceilq(-0.0) == -0.0);
+    try expect(math.isPositiveInf(ceilq(math.inf(f128))));
+    try expect(math.isNegativeInf(ceilq(-math.inf(f128))));
+    try expect(math.isNan(ceilq(math.nan(f128))));
 }

@@ -1,32 +1,17 @@
-// 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
-
-const std = @import("../std.zig");
+const std = @import("std");
 const math = std.math;
 const expect = std.testing.expect;
 
-const kernel = @import("__trig.zig");
-const __rem_pio2 = @import("__rem_pio2.zig").__rem_pio2;
-const __rem_pio2f = @import("__rem_pio2f.zig").__rem_pio2f;
-
-/// Returns the cosine of the radian value x.
-///
-/// Special Cases:
-///  - cos(+-inf) = nan
-///  - cos(nan)   = nan
-pub fn cos(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    return switch (T) {
-        f32 => cos32(x),
-        f64 => cos64(x),
-        else => @compileError("cos not implemented for " ++ @typeName(T)),
-    };
+const kernel = @import("trig.zig");
+const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
+const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
+
+pub fn __cosh(a: f16) callconv(.C) f16 {
+    // TODO: more efficient implementation
+    return @floatCast(f16, cosf(a));
 }
 
-fn cos32(x: f32) f32 {
+pub fn cosf(x: f32) callconv(.C) f32 {
     // Small multiples of pi/2 rounded to double precision.
     const c1pio2: f64 = 1.0 * math.pi / 2.0; // 0x3FF921FB, 0x54442D18
     const c2pio2: f64 = 2.0 * math.pi / 2.0; // 0x400921FB, 0x54442D18
@@ -74,7 +59,7 @@ fn cos32(x: f32) f32 {
     }
 
     var y: f64 = undefined;
-    const n = __rem_pio2f(x, &y);
+    const n = rem_pio2f(x, &y);
     return switch (n & 3) {
         0 => kernel.__cosdf(y),
         1 => kernel.__sindf(-y),
@@ -83,7 +68,7 @@ fn cos32(x: f32) f32 {
     };
 }
 
-fn cos64(x: f64) f64 {
+pub fn cos(x: f64) callconv(.C) f64 {
     var ix = @bitCast(u64, x) >> 32;
     ix &= 0x7fffffff;
 
@@ -103,7 +88,7 @@ fn cos64(x: f64) f64 {
     }
 
     var y: [2]f64 = undefined;
-    const n = __rem_pio2(x, &y);
+    const n = rem_pio2(x, &y);
     return switch (n & 3) {
         0 => kernel.__cos(y[0], y[1]),
         1 => -kernel.__sin(y[0], y[1], 1),
@@ -112,43 +97,48 @@ fn cos64(x: f64) f64 {
     };
 }
 
-test "math.cos" {
-    try expect(cos(@as(f32, 0.0)) == cos32(0.0));
-    try expect(cos(@as(f64, 0.0)) == cos64(0.0));
+pub fn __cosx(a: f80) callconv(.C) f80 {
+    // TODO: more efficient implementation
+    return @floatCast(f80, cosq(a));
+}
+
+pub fn cosq(a: f128) callconv(.C) f128 {
+    // TODO: more correct implementation
+    return cos(@floatCast(f64, a));
 }
 
-test "math.cos32" {
+test "cos32" {
     const epsilon = 0.00001;
 
-    try expect(math.approxEqAbs(f32, cos32(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f32, cos32(0.2), 0.980067, epsilon));
-    try expect(math.approxEqAbs(f32, cos32(0.8923), 0.627623, epsilon));
-    try expect(math.approxEqAbs(f32, cos32(1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f32, cos32(-1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f32, cos32(37.45), 0.969132, epsilon));
-    try expect(math.approxEqAbs(f32, cos32(89.123), 0.400798, epsilon));
+    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));
 }
 
-test "math.cos64" {
+test "cos64" {
     const epsilon = 0.000001;
 
-    try expect(math.approxEqAbs(f64, cos64(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f64, cos64(0.2), 0.980067, epsilon));
-    try expect(math.approxEqAbs(f64, cos64(0.8923), 0.627623, epsilon));
-    try expect(math.approxEqAbs(f64, cos64(1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f64, cos64(-1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f64, cos64(37.45), 0.969132, epsilon));
-    try expect(math.approxEqAbs(f64, cos64(89.123), 0.40080, epsilon));
+    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 "math.cos32.special" {
-    try expect(math.isNan(cos32(math.inf(f32))));
-    try expect(math.isNan(cos32(-math.inf(f32))));
-    try expect(math.isNan(cos32(math.nan(f32))));
+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))));
 }
 
-test "math.cos64.special" {
-    try expect(math.isNan(cos64(math.inf(f64))));
-    try expect(math.isNan(cos64(-math.inf(f64))));
-    try expect(math.isNan(cos64(math.nan(f64))));
+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))));
 }

@@ -30,9 +30,9 @@ fn test__divxf3(a: f80, b: f80) !void {
     const x_minus_eps = @bitCast(f80, (@bitCast(u80, x) - 1) | integerBit);
 
     // Make sure result is more accurate than the adjacent floats
-    const err_x = std.math.fabs(@mulAdd(f80, x, b, -a));
-    const err_x_plus_eps = std.math.fabs(@mulAdd(f80, x_plus_eps, b, -a));
-    const err_x_minus_eps = std.math.fabs(@mulAdd(f80, x_minus_eps, b, -a));
+    const err_x = @fabs(@mulAdd(f80, x, b, -a));
+    const err_x_plus_eps = @fabs(@mulAdd(f80, x_plus_eps, b, -a));
+    const err_x_minus_eps = @fabs(@mulAdd(f80, x_minus_eps, b, -a));
 
     try testing.expect(err_x_minus_eps > err_x);
     try testing.expect(err_x_plus_eps > err_x);

@@ -4,25 +4,16 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/expf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c
 
-const std = @import("../std.zig");
+const std = @import("std");
 const math = std.math;
 const expect = std.testing.expect;
 
-/// Returns e raised to the power of x (e^x).
-///
-/// Special Cases:
-///  - exp(+inf) = +inf
-///  - exp(nan)  = nan
-pub fn exp(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    return switch (T) {
-        f32 => exp32(x),
-        f64 => exp64(x),
-        else => @compileError("exp not implemented for " ++ @typeName(T)),
-    };
+pub fn __exph(a: f16) callconv(.C) f16 {
+    // TODO: more efficient implementation
+    return @floatCast(f16, expf(a));
 }
 
-fn exp32(x_: f32) f32 {
+pub fn expf(x_: f32) callconv(.C) f32 {
     const half = [_]f32{ 0.5, -0.5 };
     const ln2hi = 6.9314575195e-1;
     const ln2lo = 1.4286067653e-6;
@@ -97,7 +88,7 @@ fn exp32(x_: f32) f32 {
     }
 }
 
-fn exp64(x_: f64) f64 {
+pub fn exp(x_: f64) callconv(.C) f64 {
     const half = [_]f64{ 0.5, -0.5 };
     const ln2hi: f64 = 6.93147180369123816490e-01;
     const ln2lo: f64 = 1.90821492927058770002e-10;
@@ -181,37 +172,42 @@ fn exp64(x_: f64) f64 {
     }
 }
 
-test "math.exp" {
-    try expect(exp(@as(f32, 0.0)) == exp32(0.0));
-    try expect(exp(@as(f64, 0.0)) == exp64(0.0));
+pub fn __expx(a: f80) callconv(.C) f80 {
+    // TODO: more efficient implementation
+    return @floatCast(f80, expq(a));
 }
 
-test "math.exp32" {
+pub fn expq(a: f128) callconv(.C) f128 {
+    // TODO: more correct implementation
+    return exp(@floatCast(f64, a));
+}
+
+test "exp32" {
     const epsilon = 0.000001;
 
-    try expect(exp32(0.0) == 1.0);
-    try expect(math.approxEqAbs(f32, exp32(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f32, exp32(0.2), 1.221403, epsilon));
-    try expect(math.approxEqAbs(f32, exp32(0.8923), 2.440737, epsilon));
-    try expect(math.approxEqAbs(f32, exp32(1.5), 4.481689, epsilon));
+    try expect(expf(0.0) == 1.0);
+    try expect(math.approxEqAbs(f32, expf(0.0), 1.0, epsilon));
+    try expect(math.approxEqAbs(f32, expf(0.2), 1.221403, epsilon));
+    try expect(math.approxEqAbs(f32, expf(0.8923), 2.440737, epsilon));
+    try expect(math.approxEqAbs(f32, expf(1.5), 4.481689, epsilon));
 }
 
-test "math.exp64" {
+test "exp64" {
     const epsilon = 0.000001;
 
-    try expect(exp64(0.0) == 1.0);
-    try expect(math.approxEqAbs(f64, exp64(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f64, exp64(0.2), 1.221403, epsilon));
-    try expect(math.approxEqAbs(f64, exp64(0.8923), 2.440737, epsilon));
-    try expect(math.approxEqAbs(f64, exp64(1.5), 4.481689, epsilon));
+    try expect(exp(0.0) == 1.0);
+    try expect(math.approxEqAbs(f64, exp(0.0), 1.0, epsilon));
+    try expect(math.approxEqAbs(f64, exp(0.2), 1.221403, epsilon));
+    try expect(math.approxEqAbs(f64, exp(0.8923), 2.440737, epsilon));
+    try expect(math.approxEqAbs(f64, exp(1.5), 4.481689, epsilon));
 }
 
-test "math.exp32.special" {
-    try expect(math.isPositiveInf(exp32(math.inf(f32))));
-    try expect(math.isNan(exp32(math.nan(f32))));
+test "exp32.special" {
+    try expect(math.isPositiveInf(expf(math.inf(f32))));
+    try expect(math.isNan(expf(math.nan(f32))));
 }
 
-test "math.exp64.special" {
-    try expect(math.isPositiveInf(exp64(math.inf(f64))));
-    try expect(math.isNan(exp64(math.nan(f64))));
+test "exp64.special" {
+    try expect(math.isPositiveInf(exp(math.inf(f64))));
+    try expect(math.isNan(exp(math.nan(f64))));
 }

@@ -4,44 +4,16 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/exp2f.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c
 
-const std = @import("../std.zig");
+const std = @import("std");
 const math = std.math;
 const expect = std.testing.expect;
 
-/// Returns 2 raised to the power of x (2^x).
-///
-/// Special Cases:
-///  - exp2(+inf) = +inf
-///  - exp2(nan)  = nan
-pub fn exp2(x: anytype) @TypeOf(x) {
-    const T = @TypeOf(x);
-    return switch (T) {
-        f32 => exp2_32(x),
-        f64 => exp2_64(x),
-        else => @compileError("exp2 not implemented for " ++ @typeName(T)),
-    };
+pub fn __exp2h(x: f16) callconv(.C) f16 {
+    // TODO: more efficient implementation
+    return @floatCast(f16, exp2f(x));
 }
 
-const exp2ft = [_]f64{
-    0x1.6a09e667f3bcdp-1,
-    0x1.7a11473eb0187p-1,
-    0x1.8ace5422aa0dbp-1,
-    0x1.9c49182a3f090p-1,
-    0x1.ae89f995ad3adp-1,
-    0x1.c199bdd85529cp-1,
-    0x1.d5818dcfba487p-1,
-    0x1.ea4afa2a490dap-1,
-    0x1.0000000000000p+0,
-    0x1.0b5586cf9890fp+0,
-    0x1.172b83c7d517bp+0,
-    0x1.2387a6e756238p+0,
-    0x1.306fe0a31b715p+0,
-    0x1.3dea64c123422p+0,
-    0x1.4bfdad5362a27p+0,
-    0x1.5ab07dd485429p+0,
-};
-
-fn exp2_32(x: f32) f32 {
+pub fn exp2f(x: f32) callconv(.C) f32 {
     const tblsiz = @intCast(u32, exp2ft.len);
     const redux: f32 = 0x1.8p23 / @intToFloat(f32, tblsiz);
     const P1: f32 = 0x1.62e430p-1;
@@ -98,6 +70,104 @@ fn exp2_32(x: f32) f32 {
     return @floatCast(f32, r * uk);
 }
 
+pub fn exp2(x: f64) callconv(.C) f64 {
+    const tblsiz: u32 = @intCast(u32, exp2dt.len / 2);
+    const redux: f64 = 0x1.8p52 / @intToFloat(f64, tblsiz);
+    const P1: f64 = 0x1.62e42fefa39efp-1;
+    const P2: f64 = 0x1.ebfbdff82c575p-3;
+    const P3: f64 = 0x1.c6b08d704a0a6p-5;
+    const P4: f64 = 0x1.3b2ab88f70400p-7;
+    const P5: f64 = 0x1.5d88003875c74p-10;
+
+    const ux = @bitCast(u64, x);
+    const ix = @intCast(u32, ux >> 32) & 0x7FFFFFFF;
+
+    // TODO: This should be handled beneath.
+    if (math.isNan(x)) {
+        return math.nan(f64);
+    }
+
+    // |x| >= 1022 or nan
+    if (ix >= 0x408FF000) {
+        // x >= 1024 or nan
+        if (ix >= 0x40900000 and ux >> 63 == 0) {
+            math.raiseOverflow();
+            return math.inf(f64);
+        }
+        // -inf or -nan
+        if (ix >= 0x7FF00000) {
+            return -1 / x;
+        }
+        // x <= -1022
+        if (ux >> 63 != 0) {
+            // underflow
+            if (x <= -1075 or x - 0x1.0p52 + 0x1.0p52 != x) {
+                math.doNotOptimizeAway(@floatCast(f32, -0x1.0p-149 / x));
+            }
+            if (x <= -1075) {
+                return 0;
+            }
+        }
+    }
+    // |x| < 0x1p-54
+    else if (ix < 0x3C900000) {
+        return 1.0 + x;
+    }
+
+    // NOTE: musl relies on unsafe behaviours which are replicated below
+    // (addition overflow, division truncation, casting). Appears that this
+    // produces the intended result but should confirm how GCC/Clang handle this
+    // to ensure.
+
+    // reduce x
+    var uf: f64 = x + redux;
+    // NOTE: musl performs an implicit 64-bit to 32-bit u32 truncation here
+    var i_0: u32 = @truncate(u32, @bitCast(u64, uf));
+    i_0 +%= tblsiz / 2;
+
+    const k: u32 = i_0 / tblsiz * tblsiz;
+    const ik: i32 = @divTrunc(@bitCast(i32, k), tblsiz);
+    i_0 %= tblsiz;
+    uf -= redux;
+
+    // r = exp2(y) = exp2t[i_0] * p(z - eps[i])
+    var z: f64 = x - uf;
+    const t: f64 = exp2dt[@intCast(usize, 2 * i_0)];
+    z -= exp2dt[@intCast(usize, 2 * i_0 + 1)];
+    const r: f64 = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
+
+    return math.scalbn(r, ik);
+}
+
+pub fn __exp2x(x: f80) callconv(.C) f80 {
+    // TODO: more efficient implementation
+    return @floatCast(f80, exp2q(x));
+}
+
+pub fn exp2q(x: f128) callconv(.C) f128 {
+    // TODO: more correct implementation
+    return exp2(@floatCast(f64, x));
+}
+
+const exp2ft = [_]f64{
+    0x1.6a09e667f3bcdp-1,
+    0x1.7a11473eb0187p-1,
+    0x1.8ace5422aa0dbp-1,
+    0x1.9c49182a3f090p-1,
+    0x1.ae89f995ad3adp-1,
+    0x1.c199bdd85529cp-1,
+    0x1.d5818dcfba487p-1,
+    0x1.ea4afa2a490dap-1,
+    0x1.0000000000000p+0,
+    0x1.0b5586cf9890fp+0,
+    0x1.172b83c7d517bp+0,
+    0x1.2387a6e756238p+0,
+    0x1.306fe0a31b715p+0,
+    0x1.3dea64c123422p+0,
+    0x1.4bfdad5362a27p+0,
+    0x1.5ab07dd485429p+0,
+};
+
 const exp2dt = [_]f64{
     //  exp2(z + eps)          eps
     0x1.6a09e667f3d5dp-1, 0x1.9880p-44,
@@ -358,108 +428,34 @@ const exp2dt = [_]f64{
     0x1.690f4b19e9471p+0, -0x1.9780p-45,
 };
 
-fn exp2_64(x: f64) f64 {
-    const tblsiz: u32 = @intCast(u32, exp2dt.len / 2);
-    const redux: f64 = 0x1.8p52 / @intToFloat(f64, tblsiz);
-    const P1: f64 = 0x1.62e42fefa39efp-1;
-    const P2: f64 = 0x1.ebfbdff82c575p-3;
-    const P3: f64 = 0x1.c6b08d704a0a6p-5;
-    const P4: f64 = 0x1.3b2ab88f70400p-7;
-    const P5: f64 = 0x1.5d88003875c74p-10;
-
-    const ux = @bitCast(u64, x);
-    const ix = @intCast(u32, ux >> 32) & 0x7FFFFFFF;
-
-    // TODO: This should be handled beneath.
-    if (math.isNan(x)) {
-        return math.nan(f64);
-    }
-
-    // |x| >= 1022 or nan
-    if (ix >= 0x408FF000) {
-        // x >= 1024 or nan
-        if (ix >= 0x40900000 and ux >> 63 == 0) {
-            math.raiseOverflow();
-            return math.inf(f64);
-        }
-        // -inf or -nan
-        if (ix >= 0x7FF00000) {
-            return -1 / x;
-        }
-        // x <= -1022
-        if (ux >> 63 != 0) {
-            // underflow
-            if (x <= -1075 or x - 0x1.0p52 + 0x1.0p52 != x) {
-                math.doNotOptimizeAway(@floatCast(f32, -0x1.0p-149 / x));
-            }
-            if (x <= -1075) {
-                return 0;
-            }
-        }
-    }
-    // |x| < 0x1p-54
-    else if (ix < 0x3C900000) {
-        return 1.0 + x;
-    }
-
-    // NOTE: musl relies on unsafe behaviours which are replicated below
-    // (addition overflow, division truncation, casting). Appears that this
-    // produces the intended result but should confirm how GCC/Clang handle this
-    // to ensure.
-
-    // reduce x
-    var uf: f64 = x + redux;
-    // NOTE: musl performs an implicit 64-bit to 32-bit u32 truncation here
-    var i_0: u32 = @truncate(u32, @bitCast(u64, uf));
-    i_0 +%= tblsiz / 2;
-
-    const k: u32 = i_0 / tblsiz * tblsiz;
-    const ik: i32 = @divTrunc(@bitCast(i32, k), tblsiz);
-    i_0 %= tblsiz;
-    uf -= redux;
-
-    // r = exp2(y) = exp2t[i_0] * p(z - eps[i])
-    var z: f64 = x - uf;
-    const t: f64 = exp2dt[@intCast(usize, 2 * i_0)];
-    z -= exp2dt[@intCast(usize, 2 * i_0 + 1)];
-    const r: f64 = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
-
-    return math.scalbn(r, ik);
-}
-
-test "math.exp2" {
-    try expect(exp2(@as(f32, 0.8923)) == exp2_32(0.8923));
-    try expect(exp2(@as(f64, 0.8923)) == exp2_64(0.8923));
-}
-
-test "math.exp2_32" {
+test "exp2_32" {
     const epsilon = 0.000001;
 
-    try expect(exp2_32(0.0) == 1.0);
-    try expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon));
-    try expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon));
-    try expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon));
-    try expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon));
-    try expect(math.approxEqAbs(f32, exp2_32(-1), 0.5, epsilon));
+    try expect(exp2f(0.0) == 1.0);
+    try expect(math.approxEqAbs(f32, exp2f(0.2), 1.148698, epsilon));
+    try expect(math.approxEqAbs(f32, exp2f(0.8923), 1.856133, epsilon));
+    try expect(math.approxEqAbs(f32, exp2f(1.5), 2.828427, epsilon));
+    try expect(math.approxEqAbs(f32, exp2f(37.45), 187747237888, epsilon));
+    try expect(math.approxEqAbs(f32, exp2f(-1), 0.5, epsilon));
 }
 
-test "math.exp2_64" {
+test "exp2_64" {
     const epsilon = 0.000001;
 
-    try expect(exp2_64(0.0) == 1.0);
-    try expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon));
-    try expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon));
-    try expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon));
-    try expect(math.approxEqAbs(f64, exp2_64(-1), 0.5, epsilon));
-    try expect(math.approxEqAbs(f64, exp2_64(-0x1.a05cc754481d1p-2), 0x1.824056efc687cp-1, epsilon));
+    try expect(exp2(0.0) == 1.0);
+    try expect(math.approxEqAbs(f64, exp2(0.2), 1.148698, epsilon));
+    try expect(math.approxEqAbs(f64, exp2(0.8923), 1.856133, epsilon));
+    try expect(math.approxEqAbs(f64, exp2(1.5), 2.828427, epsilon));
+    try expect(math.approxEqAbs(f64, exp2(-1), 0.5, epsilon));
+    try expect(math.approxEqAbs(f64, exp2(-0x1.a05cc754481d1p-2), 0x1.824056efc687cp-1, epsilon));
 }
 
-test "math.exp2_32.special" {
-    try expect(math.isPositiveInf(exp2_32(math.inf(f32))));
-    try expect(math.isNan(exp2_32(math.nan(f32))));
+test "exp2_32.special" {
+    try expect(math.isPositiveInf(exp2f(math.inf(f32))));
+    try expect(math.isNan(exp2f(math.nan(f32))));
 }
 
-test "math.exp2_64.special" {
-    try expect(math.isPositiveInf(exp2_64(math.inf(f64))));
-    try expect(math.isNan(exp2_64(math.nan(f64))));
+test "exp2_64.special" {
+    try expect(math.isPositiveInf(exp2(math.inf(f64))));
+    try expect(math.isNan(exp2(math.nan(f64))));
 }