std: add the "elusive eight" special functions to std.math

lib/std/math.zig

@@ -18,6 +18,19 @@ pub const phi = 1.6180339887498948482045868343656381177203091798057628621;
 /// Circle constant (τ)
 pub const tau = 2 * pi;
 
+/// π/4
+pub const pi_4 = 0.785398163397448309616; // Cephes lift; expand
+
+/// π/2
+pub const pi_2 = 1.57079632679489661923; // Cephes lift; expand
+
+/// 2/π
+pub const two_pi = 0.636619772367581343075535; // Cephes lift; expand
+// This won't get confusing at all, I swear!
+
+/// 3π/4
+pub const threepi_4 = 2.35619449019234492885; // Cephes lift; expand
+
 /// log2(e)
 pub const log2e = 1.442695040888963407359924681001892137;
 
@@ -27,18 +40,42 @@ pub const log10e = 0.434294481903251827651128918916605082;
 /// ln(2)
 pub const ln2 = 0.693147180559945309417232121458176568;
 
+/// ln(2)/2
+pub const lnsqrt2 = 0.346573590279972654709; // Cephes lift; expand
+
 /// ln(10)
 pub const ln10 = 2.302585092994045684017991454684364208;
 
+/// ln(π)
+pub const lnpi = 1.14472988584940017414; // Cephes lift; expand
+
+/// ln(sqrt(τ))
+pub const lnsqrttau = 0.91893853320467274178; // Cephes lift; expand
+
+/// sqrt(τ)
+pub const sqrttau = 2.50662827463100050242; // Cephes lift; expand
+
 /// 2/sqrt(π)
 pub const two_sqrtpi = 1.128379167095512573896158903121545172;
 
+/// sqrt(2/π)
+pub const sqrt2_pi = 0.79788456080286535587989; // Cephes lift; expand
+
+/// sqrt(1/π)
+pub const sqrt1_pi = 0.564189583547756286948; // Cephes lift; expand
+
 /// sqrt(2)
 pub const sqrt2 = 1.414213562373095048801688724209698079;
 
 /// 1/sqrt(2)
 pub const sqrt1_2 = 0.707106781186547524400844362104849039;
 
+/// sqrt(3)
+pub const sqrt3 = 1.732050807568877293527; // Cephes lift; expand
+
+/// cbrt(2)
+pub const cbrt2 = std.math.cbrt(@as(f64, 2.0)); // Cephes lift; expand
+
 /// pi/180.0
 pub const rad_per_deg = 0.0174532925199432957692369076848861271344287188854172545609719144;
 
@@ -279,18 +316,18 @@ test radiansToDegrees {
     const half_pi: f32 = pi / 2.0;
     const neg_quart_pi: f32 = -pi / 4.0;
     const one_pi: f32 = pi;
-    const two_pi: f32 = 2.0 * pi;
+    const _two_pi: f32 = 2.0 * pi;
     try std.testing.expectApproxEqAbs(@as(f32, 0), radiansToDegrees(zero), 1e-6);
     try std.testing.expectApproxEqAbs(@as(f32, 90), radiansToDegrees(half_pi), 1e-6);
     try std.testing.expectApproxEqAbs(@as(f32, -45), radiansToDegrees(neg_quart_pi), 1e-6);
     try std.testing.expectApproxEqAbs(@as(f32, 180), radiansToDegrees(one_pi), 1e-6);
-    try std.testing.expectApproxEqAbs(@as(f32, 360), radiansToDegrees(two_pi), 1e-6);
+    try std.testing.expectApproxEqAbs(@as(f32, 360), radiansToDegrees(_two_pi), 1e-6);
 
     const result = radiansToDegrees(@Vector(4, f32){
         half_pi,
         neg_quart_pi,
         one_pi,
-        two_pi,
+        _two_pi,
     });
     try std.testing.expectApproxEqAbs(@as(f32, 90), result[0], 1e-6);
     try std.testing.expectApproxEqAbs(@as(f32, -45), result[1], 1e-6);
@@ -344,6 +381,8 @@ pub inline fn exp2(value: anytype) @TypeOf(value) {
 pub const complex = @import("math/complex.zig");
 pub const Complex = complex.Complex;
 
+pub const prob = @import("math/prob.zig");
+
 pub const big = @import("math/big.zig");
 
 test {

lib/std/math/prob.zig

@@ -0,0 +1,47 @@
+// Copyright (c) 2015-2021 Zig Contributors
+// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
+// The MIT license requires this copyright notice to be included in all copies
+// and substantial portions of the software.
+const std = @import("std");
+const testing = std.testing;
+const math = std.math;
+
+pub const normalDist = @import("prob/normal_dist.zig").normalDist;
+pub const inverseNormalDist = @import("prob/normal_dist.zig").inverseNormalDist;
+pub const erfc = @import("prob/normal_dist.zig").erfc;
+pub const erf = @import("prob/normal_dist.zig").erf;
+
+pub const besselj0 = @import("prob/besselj0.zig").besselj0;
+pub const bessely0 = @import("prob/besselj0.zig").bessely0;
+pub const besselj1 = @import("prob/besselj1.zig").besselj1;
+pub const bessely1 = @import("prob/besselj1.zig").bessely1;
+pub const besselj = @import("prob/besseljn.zig").besselj;
+
+pub const airy = @import("prob/airy.zig").airy;
+
+pub const incompleteGamma = @import("prob/incomplete_gamma.zig").incompleteGamma;
+pub const complementedIncompleteGamma = @import("prob/incomplete_gamma.zig").complementedIncompleteGamma;
+pub const inverseComplementedIncompleteGamma = @import("prob/incomplete_gamma.zig").inverseComplementedIncompleteGamma;
+
+pub const gamma = @import("prob/gamma.zig").gamma;
+pub const lnGamma = @import("prob/gamma.zig").lnGamma;
+
+pub const incompleteBeta = @import("prob/incomplete_beta.zig").incompleteBeta;
+pub const inverseIncompleteBeta = @import("prob/incomplete_beta.zig").inverseIncompleteBeta;
+
+pub const polevl = @import("prob/polevl.zig").polevl;
+pub const p1evl = @import("prob/polevl.zig").p1evl;
+
+test "math.prob" {
+    _ = @import("prob/expx2.zig");
+    _ = @import("prob/polevl.zig");
+
+    _ = @import("prob/airy.zig");
+    _ = @import("prob/gamma.zig");
+    _ = @import("prob/incomplete_gamma.zig");
+    _ = @import("prob/incomplete_beta.zig");
+    _ = @import("prob/besselj0.zig");
+    _ = @import("prob/besselj1.zig");
+    _ = @import("prob/besseljn.zig");
+    _ = @import("prob/normal_dist.zig");
+}