Merge pull request #11532 from ziglang/compiler-rt-math

compiler-rt math functions reorg

8 files changed, 62 insertions, 62 deletions

diff --git a/lib/std/math/complex/atan.zig b/lib/std/math/complex/atan.zig
index 484b41edf5..929b98aebd 100644
--- a/lib/std/math/complex/atan.zig
+++ b/lib/std/math/complex/atan.zig
@@ -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;
diff --git a/lib/std/math/complex/cosh.zig b/lib/std/math/complex/cosh.zig
index 46f7a714a2..65cfc4a528 100644
--- a/lib/std/math/complex/cosh.zig
+++ b/lib/std/math/complex/cosh.zig
@@ -38,25 +38,25 @@ fn cosh32(z: Complex(f32)) Complex(f32) {
         }
         // small x: normal case
         if (ix < 0x41100000) {
-            return Complex(f32).init(math.cosh(x) * math.cos(y), math.sinh(x) * math.sin(y));
+            return Complex(f32).init(math.cosh(x) * @cos(y), math.sinh(x) * @sin(y));
         }
 
         // |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;
-            return Complex(f32).init(math.copysign(f32, h, x) * math.cos(y), h * math.sin(y));
+            const h = @exp(@fabs(x)) * 0.5;
+            return Complex(f32).init(math.copysign(f32, h, x) * @cos(y), h * @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));
         }
         // x >= 192.7: result always overflows
         else {
             const h = 0x1p127 * x;
-            return Complex(f32).init(h * h * math.cos(y), h * math.sin(y));
+            return Complex(f32).init(h * h * @cos(y), h * @sin(y));
         }
     }
 
@@ -79,7 +79,7 @@ fn cosh32(z: Complex(f32)) Complex(f32) {
         if (iy >= 0x7f800000) {
             return Complex(f32).init(x * x, x * (y - y));
         }
-        return Complex(f32).init((x * x) * math.cos(y), x * math.sin(y));
+        return Complex(f32).init((x * x) * @cos(y), x * @sin(y));
     }
 
     return Complex(f32).init((x * x) * (y - y), (x + x) * (y - y));
@@ -106,25 +106,25 @@ fn cosh64(z: Complex(f64)) Complex(f64) {
         }
         // small x: normal case
         if (ix < 0x40360000) {
-            return Complex(f64).init(math.cosh(x) * math.cos(y), math.sinh(x) * math.sin(y));
+            return Complex(f64).init(math.cosh(x) * @cos(y), math.sinh(x) * @sin(y));
         }
 
         // |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;
-            return Complex(f64).init(h * math.cos(y), math.copysign(f64, h, x) * math.sin(y));
+            const h = @exp(@fabs(x)) * 0.5;
+            return Complex(f64).init(h * @cos(y), math.copysign(f64, h, x) * @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));
         }
         // x >= 1455: result always overflows
         else {
             const h = 0x1p1023;
-            return Complex(f64).init(h * h * math.cos(y), h * math.sin(y));
+            return Complex(f64).init(h * h * @cos(y), h * @sin(y));
         }
     }
 
@@ -147,7 +147,7 @@ fn cosh64(z: Complex(f64)) Complex(f64) {
         if (iy >= 0x7ff00000) {
             return Complex(f64).init(x * x, x * (y - y));
         }
-        return Complex(f64).init(x * x * math.cos(y), x * math.sin(y));
+        return Complex(f64).init(x * x * @cos(y), x * @sin(y));
     }
 
     return Complex(f64).init((x * x) * (y - y), (x + x) * (y - y));
diff --git a/lib/std/math/complex/exp.zig b/lib/std/math/complex/exp.zig
index ce25025ded..84ee251d0e 100644
--- a/lib/std/math/complex/exp.zig
+++ b/lib/std/math/complex/exp.zig
@@ -33,13 +33,13 @@ 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);
     // cexp(0 + iy) = cos(y) + isin(y)
     if ((hx & 0x7fffffff) == 0) {
-        return Complex(f32).init(math.cos(y), math.sin(y));
+        return Complex(f32).init(@cos(y), @sin(y));
     }
 
     if (hy >= 0x7f800000) {
@@ -63,8 +63,8 @@ fn exp32(z: Complex(f32)) Complex(f32) {
     // - x = +-inf
     // - x = nan
     else {
-        const exp_x = math.exp(x);
-        return Complex(f32).init(exp_x * math.cos(y), exp_x * math.sin(y));
+        const exp_x = @exp(x);
+        return Complex(f32).init(exp_x * @cos(y), exp_x * @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);
@@ -90,7 +90,7 @@ fn exp64(z: Complex(f64)) Complex(f64) {
 
     // cexp(0 + iy) = cos(y) + isin(y)
     if ((hx & 0x7fffffff) | lx == 0) {
-        return Complex(f64).init(math.cos(y), math.sin(y));
+        return Complex(f64).init(@cos(y), @sin(y));
     }
 
     if (hy >= 0x7ff00000) {
@@ -114,13 +114,13 @@ fn exp64(z: Complex(f64)) Complex(f64) {
     // - x = +-inf
     // - x = nan
     else {
-        const exp_x = math.exp(x);
-        return Complex(f64).init(exp_x * math.cos(y), exp_x * math.sin(y));
+        const exp_x = @exp(x);
+        return Complex(f64).init(exp_x * @cos(y), exp_x * @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);
diff --git a/lib/std/math/complex/ldexp.zig b/lib/std/math/complex/ldexp.zig
index db710a0438..c196d4afe6 100644
--- a/lib/std/math/complex/ldexp.zig
+++ b/lib/std/math/complex/ldexp.zig
@@ -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;
@@ -45,8 +45,8 @@ fn ldexp_cexp32(z: Complex(f32), expt: i32) Complex(f32) {
     const scale2 = @bitCast(f32, (0x7f + half_expt2) << 23);
 
     return Complex(f32).init(
-        math.cos(z.im) * exp_x * scale1 * scale2,
-        math.sin(z.im) * exp_x * scale1 * scale2,
+        @cos(z.im) * exp_x * scale1 * scale2,
+        @sin(z.im) * exp_x * scale1 * scale2,
     );
 }
 
@@ -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);
@@ -78,7 +78,7 @@ fn ldexp_cexp64(z: Complex(f64), expt: i32) Complex(f64) {
     const scale2 = @bitCast(f64, (0x3ff + half_expt2) << (20 + 32));
 
     return Complex(f64).init(
-        math.cos(z.im) * exp_x * scale1 * scale2,
-        math.sin(z.im) * exp_x * scale1 * scale2,
+        @cos(z.im) * exp_x * scale1 * scale2,
+        @sin(z.im) * exp_x * scale1 * scale2,
     );
 }
diff --git a/lib/std/math/complex/log.zig b/lib/std/math/complex/log.zig
index 90c51058cf..6d1b06d272 100644
--- a/lib/std/math/complex/log.zig
+++ b/lib/std/math/complex/log.zig
@@ -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;
diff --git a/lib/std/math/complex/sinh.zig b/lib/std/math/complex/sinh.zig
index 851af3e62e..1569565ecc 100644
--- a/lib/std/math/complex/sinh.zig
+++ b/lib/std/math/complex/sinh.zig
@@ -38,25 +38,25 @@ fn sinh32(z: Complex(f32)) Complex(f32) {
         }
         // small x: normal case
         if (ix < 0x41100000) {
-            return Complex(f32).init(math.sinh(x) * math.cos(y), math.cosh(x) * math.sin(y));
+            return Complex(f32).init(math.sinh(x) * @cos(y), math.cosh(x) * @sin(y));
         }
 
         // |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;
-            return Complex(f32).init(math.copysign(f32, h, x) * math.cos(y), h * math.sin(y));
+            const h = @exp(@fabs(x)) * 0.5;
+            return Complex(f32).init(math.copysign(f32, h, x) * @cos(y), h * @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);
         }
         // x >= 192.7: result always overflows
         else {
             const h = 0x1p127 * x;
-            return Complex(f32).init(h * math.cos(y), h * h * math.sin(y));
+            return Complex(f32).init(h * @cos(y), h * h * @sin(y));
         }
     }
 
@@ -79,7 +79,7 @@ fn sinh32(z: Complex(f32)) Complex(f32) {
         if (iy >= 0x7f800000) {
             return Complex(f32).init(x * x, x * (y - y));
         }
-        return Complex(f32).init(x * math.cos(y), math.inf(f32) * math.sin(y));
+        return Complex(f32).init(x * @cos(y), math.inf(f32) * @sin(y));
     }
 
     return Complex(f32).init((x * x) * (y - y), (x + x) * (y - y));
@@ -105,25 +105,25 @@ fn sinh64(z: Complex(f64)) Complex(f64) {
         }
         // small x: normal case
         if (ix < 0x40360000) {
-            return Complex(f64).init(math.sinh(x) * math.cos(y), math.cosh(x) * math.sin(y));
+            return Complex(f64).init(math.sinh(x) * @cos(y), math.cosh(x) * @sin(y));
         }
 
         // |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;
-            return Complex(f64).init(math.copysign(f64, h, x) * math.cos(y), h * math.sin(y));
+            const h = @exp(@fabs(x)) * 0.5;
+            return Complex(f64).init(math.copysign(f64, h, x) * @cos(y), h * @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);
         }
         // x >= 1455: result always overflows
         else {
             const h = 0x1p1023 * x;
-            return Complex(f64).init(h * math.cos(y), h * h * math.sin(y));
+            return Complex(f64).init(h * @cos(y), h * h * @sin(y));
         }
     }
 
@@ -146,7 +146,7 @@ fn sinh64(z: Complex(f64)) Complex(f64) {
         if (iy >= 0x7ff00000) {
             return Complex(f64).init(x * x, x * (y - y));
         }
-        return Complex(f64).init(x * math.cos(y), math.inf(f64) * math.sin(y));
+        return Complex(f64).init(x * @cos(y), math.inf(f64) * @sin(y));
     }
 
     return Complex(f64).init((x * x) * (y - y), (x + x) * (y - y));
diff --git a/lib/std/math/complex/sqrt.zig b/lib/std/math/complex/sqrt.zig
index 4f16e631b8..ab24e2d60d 100644
--- a/lib/std/math/complex/sqrt.zig
+++ b/lib/std/math/complex/sqrt.zig
@@ -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) {
diff --git a/lib/std/math/complex/tanh.zig b/lib/std/math/complex/tanh.zig
index 0960c66679..2ed2cb9609 100644
--- a/lib/std/math/complex/tanh.zig
+++ b/lib/std/math/complex/tanh.zig
@@ -33,7 +33,7 @@ fn tanh32(z: Complex(f32)) Complex(f32) {
             return Complex(f32).init(x, r);
         }
         const xx = @bitCast(f32, hx - 0x40000000);
-        const r = if (math.isInf(y)) y else math.sin(y) * math.cos(y);
+        const r = if (math.isInf(y)) y else @sin(y) * @cos(y);
         return Complex(f32).init(xx, math.copysign(f32, 0, r));
     }
 
@@ -44,15 +44,15 @@ fn tanh32(z: Complex(f32)) Complex(f32) {
 
     // x >= 11
     if (ix >= 0x41300000) {
-        const exp_mx = math.exp(-math.fabs(x));
-        return Complex(f32).init(math.copysign(f32, 1, x), 4 * math.sin(y) * math.cos(y) * exp_mx * exp_mx);
+        const exp_mx = @exp(-@fabs(x));
+        return Complex(f32).init(math.copysign(f32, 1, x), 4 * @sin(y) * @cos(y) * exp_mx * exp_mx);
     }
 
     // Kahan's algorithm
-    const t = math.tan(y);
+    const t = @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);
@@ -76,7 +76,7 @@ fn tanh64(z: Complex(f64)) Complex(f64) {
         }
 
         const xx = @bitCast(f64, (@as(u64, hx - 0x40000000) << 32) | lx);
-        const r = if (math.isInf(y)) y else math.sin(y) * math.cos(y);
+        const r = if (math.isInf(y)) y else @sin(y) * @cos(y);
         return Complex(f64).init(xx, math.copysign(f64, 0, r));
     }
 
@@ -87,15 +87,15 @@ fn tanh64(z: Complex(f64)) Complex(f64) {
 
     // x >= 22
     if (ix >= 0x40360000) {
-        const exp_mx = math.exp(-math.fabs(x));
-        return Complex(f64).init(math.copysign(f64, 1, x), 4 * math.sin(y) * math.cos(y) * exp_mx * exp_mx);
+        const exp_mx = @exp(-@fabs(x));
+        return Complex(f64).init(math.copysign(f64, 1, x), 4 * @sin(y) * @cos(y) * exp_mx * exp_mx);
     }
 
     // Kahan's algorithm
-    const t = math.tan(y);
+    const t = @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);