mirror of
https://github.com/ziglang/zig.git
synced 2024-11-16 00:57:04 +00:00
329 lines
11 KiB
Zig
329 lines
11 KiB
Zig
// 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/tgamma.c
|
|
|
|
const std = @import("../std.zig");
|
|
|
|
/// Returns the gamma function of x,
|
|
/// gamma(x) = factorial(x - 1) for integer x.
|
|
///
|
|
/// Special Cases:
|
|
/// - gamma(+-nan) = nan
|
|
/// - gamma(-inf) = nan
|
|
/// - gamma(n) = nan for negative integers
|
|
/// - gamma(-0.0) = -inf
|
|
/// - gamma(+0.0) = +inf
|
|
/// - gamma(+inf) = +inf
|
|
pub fn gamma(comptime T: type, x: T) T {
|
|
if (T != f32 and T != f64) {
|
|
@compileError("gamma not implemented for " ++ @typeName(T));
|
|
}
|
|
// common integer case first
|
|
if (x == @trunc(x)) {
|
|
// gamma(-inf) = nan
|
|
// gamma(n) = nan for negative integers
|
|
if (x < 0) {
|
|
return std.math.nan(T);
|
|
}
|
|
// gamma(-0.0) = -inf
|
|
// gamma(+0.0) = +inf
|
|
if (x == 0) {
|
|
return 1 / x;
|
|
}
|
|
if (x < integer_result_table.len) {
|
|
const i = @as(u8, @intFromFloat(x));
|
|
return @floatCast(integer_result_table[i]);
|
|
}
|
|
}
|
|
// below this, result underflows, but has a sign
|
|
// negative for (-1, 0)
|
|
// positive for (-2, -1)
|
|
// negative for (-3, -2)
|
|
// ...
|
|
const lower_bound = if (T == f64) -184 else -42;
|
|
if (x < lower_bound) {
|
|
return if (@mod(x, 2) > 1) -0.0 else 0.0;
|
|
}
|
|
// above this, result overflows
|
|
// gamma(+inf) = +inf
|
|
const upper_bound = if (T == f64) 172 else 36;
|
|
if (x > upper_bound) {
|
|
return std.math.inf(T);
|
|
}
|
|
|
|
const abs = @abs(x);
|
|
// perfect precision here
|
|
if (abs < 0x1p-54) {
|
|
return 1 / x;
|
|
}
|
|
|
|
const base = abs + lanczos_minus_half;
|
|
const exponent = abs - 0.5;
|
|
// error of y for correction, see
|
|
// https://github.com/python/cpython/blob/5dc79e3d7f26a6a871a89ce3efc9f1bcee7bb447/Modules/mathmodule.c#L286-L324
|
|
const e = if (abs > lanczos_minus_half)
|
|
base - abs - lanczos_minus_half
|
|
else
|
|
base - lanczos_minus_half - abs;
|
|
const correction = lanczos * e / base;
|
|
const initial = series(T, abs) * @exp(-base);
|
|
|
|
// use reflection formula for negatives
|
|
if (x < 0) {
|
|
const reflected = -std.math.pi / (abs * sinpi(T, abs) * initial);
|
|
const corrected = reflected - reflected * correction;
|
|
const half_pow = std.math.pow(T, base, -0.5 * exponent);
|
|
return corrected * half_pow * half_pow;
|
|
} else {
|
|
const corrected = initial + initial * correction;
|
|
const half_pow = std.math.pow(T, base, 0.5 * exponent);
|
|
return corrected * half_pow * half_pow;
|
|
}
|
|
}
|
|
|
|
/// Returns the natural logarithm of the absolute value of the gamma function.
|
|
///
|
|
/// Special Cases:
|
|
/// - lgamma(+-nan) = nan
|
|
/// - lgamma(+-inf) = +inf
|
|
/// - lgamma(n) = +inf for negative integers
|
|
/// - lgamma(+-0.0) = +inf
|
|
/// - lgamma(1) = +0.0
|
|
/// - lgamma(2) = +0.0
|
|
pub fn lgamma(comptime T: type, x: T) T {
|
|
if (T != f32 and T != f64) {
|
|
@compileError("gamma not implemented for " ++ @typeName(T));
|
|
}
|
|
// common integer case first
|
|
if (x == @trunc(x)) {
|
|
// lgamma(-inf) = +inf
|
|
// lgamma(n) = +inf for negative integers
|
|
// lgamma(+-0.0) = +inf
|
|
if (x <= 0) {
|
|
return std.math.inf(T);
|
|
}
|
|
// lgamma(1) = +0.0
|
|
// lgamma(2) = +0.0
|
|
if (x < integer_result_table.len) {
|
|
const i = @as(u8, @intFromFloat(x));
|
|
return @log(@as(T, @floatCast(integer_result_table[i])));
|
|
}
|
|
// lgamma(+inf) = +inf
|
|
if (std.math.isPositiveInf(x)) {
|
|
return x;
|
|
}
|
|
}
|
|
|
|
const abs = @abs(x);
|
|
// perfect precision here
|
|
if (abs < 0x1p-54) {
|
|
return -@log(abs);
|
|
}
|
|
// obvious approach when overflow is not a problem
|
|
const upper_bound = if (T == f64) 128 else 26;
|
|
if (abs < upper_bound) {
|
|
return @log(@abs(gamma(T, x)));
|
|
}
|
|
|
|
const log_base = @log(abs + lanczos_minus_half) - 1;
|
|
const exponent = abs - 0.5;
|
|
const log_series = @log(series(T, abs));
|
|
const initial = exponent * log_base + log_series - lanczos;
|
|
|
|
// use reflection formula for negatives
|
|
if (x < 0) {
|
|
const reflected = std.math.pi / (abs * sinpi(T, abs));
|
|
return @log(@abs(reflected)) - initial;
|
|
}
|
|
return initial;
|
|
}
|
|
|
|
// table of factorials for integer early return
|
|
// stops at 22 because 23 isn't representable with full precision on f64
|
|
const integer_result_table = [_]f64{
|
|
std.math.inf(f64), // gamma(+0.0)
|
|
1, // gamma(1)
|
|
1, // ...
|
|
2,
|
|
6,
|
|
24,
|
|
120,
|
|
720,
|
|
5040,
|
|
40320,
|
|
362880,
|
|
3628800,
|
|
39916800,
|
|
479001600,
|
|
6227020800,
|
|
87178291200,
|
|
1307674368000,
|
|
20922789888000,
|
|
355687428096000,
|
|
6402373705728000,
|
|
121645100408832000,
|
|
2432902008176640000,
|
|
51090942171709440000, // gamma(22)
|
|
};
|
|
|
|
// "g" constant, arbitrary
|
|
const lanczos = 6.024680040776729583740234375;
|
|
const lanczos_minus_half = lanczos - 0.5;
|
|
|
|
fn series(comptime T: type, abs: T) T {
|
|
const numerator = [_]T{
|
|
23531376880.410759688572007674451636754734846804940,
|
|
42919803642.649098768957899047001988850926355848959,
|
|
35711959237.355668049440185451547166705960488635843,
|
|
17921034426.037209699919755754458931112671403265390,
|
|
6039542586.3520280050642916443072979210699388420708,
|
|
1439720407.3117216736632230727949123939715485786772,
|
|
248874557.86205415651146038641322942321632125127801,
|
|
31426415.585400194380614231628318205362874684987640,
|
|
2876370.6289353724412254090516208496135991145378768,
|
|
186056.26539522349504029498971604569928220784236328,
|
|
8071.6720023658162106380029022722506138218516325024,
|
|
210.82427775157934587250973392071336271166969580291,
|
|
2.5066282746310002701649081771338373386264310793408,
|
|
};
|
|
const denominator = [_]T{
|
|
0,
|
|
39916800,
|
|
120543840,
|
|
150917976,
|
|
105258076,
|
|
45995730,
|
|
13339535,
|
|
2637558,
|
|
357423,
|
|
32670,
|
|
1925,
|
|
66,
|
|
1,
|
|
};
|
|
var num: T = 0;
|
|
var den: T = 0;
|
|
// split to avoid overflow
|
|
if (abs < 8) {
|
|
// big abs would overflow here
|
|
for (0..numerator.len) |i| {
|
|
num = num * abs + numerator[numerator.len - 1 - i];
|
|
den = den * abs + denominator[numerator.len - 1 - i];
|
|
}
|
|
} else {
|
|
// small abs would overflow here
|
|
for (0..numerator.len) |i| {
|
|
num = num / abs + numerator[i];
|
|
den = den / abs + denominator[i];
|
|
}
|
|
}
|
|
return num / den;
|
|
}
|
|
|
|
// precise sin(pi * x)
|
|
// but not for integer x or |x| < 2^-54, we handle those already
|
|
fn sinpi(comptime T: type, x: T) T {
|
|
const xmod2 = @mod(x, 2); // [0, 2]
|
|
const n = (@as(u8, @intFromFloat(4 * xmod2)) + 1) / 2; // {0, 1, 2, 3, 4}
|
|
const y = xmod2 - 0.5 * @as(T, @floatFromInt(n)); // [-0.25, 0.25]
|
|
return switch (n) {
|
|
0, 4 => @sin(std.math.pi * y),
|
|
1 => @cos(std.math.pi * y),
|
|
2 => -@sin(std.math.pi * y),
|
|
3 => -@cos(std.math.pi * y),
|
|
else => unreachable,
|
|
};
|
|
}
|
|
|
|
const expect = std.testing.expect;
|
|
const expectEqual = std.testing.expectEqual;
|
|
const expectApproxEqRel = std.testing.expectApproxEqRel;
|
|
|
|
test gamma {
|
|
inline for (&.{ f32, f64 }) |T| {
|
|
const eps = @sqrt(std.math.floatEps(T));
|
|
try expectApproxEqRel(@as(T, 120), gamma(T, 6), eps);
|
|
try expectApproxEqRel(@as(T, 362880), gamma(T, 10), eps);
|
|
try expectApproxEqRel(@as(T, 6402373705728000), gamma(T, 19), eps);
|
|
|
|
try expectApproxEqRel(@as(T, 332.7590766955334570), gamma(T, 0.003), eps);
|
|
try expectApproxEqRel(@as(T, 1.377260301981044573), gamma(T, 0.654), eps);
|
|
try expectApproxEqRel(@as(T, 1.025393882573518478), gamma(T, 0.959), eps);
|
|
|
|
try expectApproxEqRel(@as(T, 7.361898021467681690), gamma(T, 4.16), eps);
|
|
try expectApproxEqRel(@as(T, 198337.2940287730753), gamma(T, 9.73), eps);
|
|
try expectApproxEqRel(@as(T, 113718145797241.1666), gamma(T, 17.6), eps);
|
|
|
|
try expectApproxEqRel(@as(T, -1.13860211111081424930673), gamma(T, -2.80), eps);
|
|
try expectApproxEqRel(@as(T, 0.00018573407931875070158), gamma(T, -7.74), eps);
|
|
try expectApproxEqRel(@as(T, -0.00000001647990903942825), gamma(T, -12.1), eps);
|
|
}
|
|
}
|
|
|
|
test "gamma.special" {
|
|
inline for (&.{ f32, f64 }) |T| {
|
|
try expect(std.math.isNan(gamma(T, -std.math.nan(T))));
|
|
try expect(std.math.isNan(gamma(T, std.math.nan(T))));
|
|
try expect(std.math.isNan(gamma(T, -std.math.inf(T))));
|
|
|
|
try expect(std.math.isNan(gamma(T, -4)));
|
|
try expect(std.math.isNan(gamma(T, -11)));
|
|
try expect(std.math.isNan(gamma(T, -78)));
|
|
|
|
try expectEqual(-std.math.inf(T), gamma(T, -0.0));
|
|
try expectEqual(std.math.inf(T), gamma(T, 0.0));
|
|
|
|
try expect(std.math.isNegativeZero(gamma(T, -200.5)));
|
|
try expect(std.math.isPositiveZero(gamma(T, -201.5)));
|
|
try expect(std.math.isNegativeZero(gamma(T, -202.5)));
|
|
|
|
try expectEqual(std.math.inf(T), gamma(T, 200));
|
|
try expectEqual(std.math.inf(T), gamma(T, 201));
|
|
try expectEqual(std.math.inf(T), gamma(T, 202));
|
|
|
|
try expectEqual(std.math.inf(T), gamma(T, std.math.inf(T)));
|
|
}
|
|
}
|
|
|
|
test lgamma {
|
|
inline for (&.{ f32, f64 }) |T| {
|
|
const eps = @sqrt(std.math.floatEps(T));
|
|
try expectApproxEqRel(@as(T, @log(24.0)), lgamma(T, 5), eps);
|
|
try expectApproxEqRel(@as(T, @log(20922789888000.0)), lgamma(T, 17), eps);
|
|
try expectApproxEqRel(@as(T, @log(2432902008176640000.0)), lgamma(T, 21), eps);
|
|
|
|
try expectApproxEqRel(@as(T, 2.201821590438859327), lgamma(T, 0.105), eps);
|
|
try expectApproxEqRel(@as(T, 1.275416975248413231), lgamma(T, 0.253), eps);
|
|
try expectApproxEqRel(@as(T, 0.130463884049976732), lgamma(T, 0.823), eps);
|
|
|
|
try expectApproxEqRel(@as(T, 43.24395772148497989), lgamma(T, 21.3), eps);
|
|
try expectApproxEqRel(@as(T, 110.6908958012102623), lgamma(T, 41.1), eps);
|
|
try expectApproxEqRel(@as(T, 215.2123266224689711), lgamma(T, 67.4), eps);
|
|
|
|
try expectApproxEqRel(@as(T, -122.605958469563489), lgamma(T, -43.6), eps);
|
|
try expectApproxEqRel(@as(T, -278.633885462703133), lgamma(T, -81.4), eps);
|
|
try expectApproxEqRel(@as(T, -333.247676253238363), lgamma(T, -93.6), eps);
|
|
}
|
|
}
|
|
|
|
test "lgamma.special" {
|
|
inline for (&.{ f32, f64 }) |T| {
|
|
try expect(std.math.isNan(lgamma(T, -std.math.nan(T))));
|
|
try expect(std.math.isNan(lgamma(T, std.math.nan(T))));
|
|
|
|
try expectEqual(std.math.inf(T), lgamma(T, -std.math.inf(T)));
|
|
try expectEqual(std.math.inf(T), lgamma(T, std.math.inf(T)));
|
|
|
|
try expectEqual(std.math.inf(T), lgamma(T, -5));
|
|
try expectEqual(std.math.inf(T), lgamma(T, -8));
|
|
try expectEqual(std.math.inf(T), lgamma(T, -15));
|
|
|
|
try expectEqual(std.math.inf(T), lgamma(T, -0.0));
|
|
try expectEqual(std.math.inf(T), lgamma(T, 0.0));
|
|
|
|
try expect(std.math.isPositiveZero(lgamma(T, 1)));
|
|
try expect(std.math.isPositiveZero(lgamma(T, 2)));
|
|
}
|
|
}
|