log10.zig (9499B) - Raw
1 //! Ported from musl, which is licensed under the MIT license: 2 //! https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT 3 //! 4 //! https://git.musl-libc.org/cgit/musl/tree/src/math/log10f.c 5 //! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c 6 7 const std = @import("std"); 8 const builtin = @import("builtin"); 9 const math = std.math; 10 const expect = std.testing.expect; 11 const expectEqual = std.testing.expectEqual; 12 const maxInt = std.math.maxInt; 13 const arch = builtin.cpu.arch; 14 const common = @import("common.zig"); 15 16 pub const panic = common.panic; 17 18 comptime { 19 @export(&__log10h, .{ .name = "__log10h", .linkage = common.linkage, .visibility = common.visibility }); 20 @export(&log10f, .{ .name = "log10f", .linkage = common.linkage, .visibility = common.visibility }); 21 @export(&log10, .{ .name = "log10", .linkage = common.linkage, .visibility = common.visibility }); 22 @export(&__log10x, .{ .name = "__log10x", .linkage = common.linkage, .visibility = common.visibility }); 23 if (common.want_ppc_abi) { 24 @export(&log10q, .{ .name = "log10f128", .linkage = common.linkage, .visibility = common.visibility }); 25 } 26 @export(&log10q, .{ .name = "log10q", .linkage = common.linkage, .visibility = common.visibility }); 27 @export(&log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility }); 28 } 29 30 pub fn __log10h(a: f16) callconv(.c) f16 { 31 // TODO: more efficient implementation 32 return @floatCast(log10f(a)); 33 } 34 35 pub fn log10f(x_: f32) callconv(.c) f32 { 36 const ivln10hi: f32 = 4.3432617188e-01; 37 const ivln10lo: f32 = -3.1689971365e-05; 38 const log10_2hi: f32 = 3.0102920532e-01; 39 const log10_2lo: f32 = 7.9034151668e-07; 40 const Lg1: f32 = 0xaaaaaa.0p-24; 41 const Lg2: f32 = 0xccce13.0p-25; 42 const Lg3: f32 = 0x91e9ee.0p-25; 43 const Lg4: f32 = 0xf89e26.0p-26; 44 45 var x = x_; 46 var u: u32 = @bitCast(x); 47 var ix = u; 48 var k: i32 = 0; 49 50 // x < 2^(-126) 51 if (ix < 0x00800000 or ix >> 31 != 0) { 52 // log(+-0) = -inf 53 if (ix << 1 == 0) { 54 return -math.inf(f32); 55 } 56 // log(-#) = nan 57 if (ix >> 31 != 0) { 58 return math.nan(f32); 59 } 60 61 k -= 25; 62 x *= 0x1.0p25; 63 ix = @bitCast(x); 64 } else if (ix >= 0x7F800000) { 65 return x; 66 } else if (ix == 0x3F800000) { 67 return 0; 68 } 69 70 // x into [sqrt(2) / 2, sqrt(2)] 71 ix += 0x3F800000 - 0x3F3504F3; 72 k += @as(i32, @intCast(ix >> 23)) - 0x7F; 73 ix = (ix & 0x007FFFFF) + 0x3F3504F3; 74 x = @bitCast(ix); 75 76 const f = x - 1.0; 77 const s = f / (2.0 + f); 78 const z = s * s; 79 const w = z * z; 80 const t1 = w * (Lg2 + w * Lg4); 81 const t2 = z * (Lg1 + w * Lg3); 82 const R = t2 + t1; 83 const hfsq = 0.5 * f * f; 84 85 var hi = f - hfsq; 86 u = @bitCast(hi); 87 u &= 0xFFFFF000; 88 hi = @bitCast(u); 89 const lo = f - hi - hfsq + s * (hfsq + R); 90 const dk: f32 = @floatFromInt(k); 91 92 return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi; 93 } 94 95 pub fn log10(x_: f64) callconv(.c) f64 { 96 const ivln10hi: f64 = 4.34294481878168880939e-01; 97 const ivln10lo: f64 = 2.50829467116452752298e-11; 98 const log10_2hi: f64 = 3.01029995663611771306e-01; 99 const log10_2lo: f64 = 3.69423907715893078616e-13; 100 const Lg1: f64 = 6.666666666666735130e-01; 101 const Lg2: f64 = 3.999999999940941908e-01; 102 const Lg3: f64 = 2.857142874366239149e-01; 103 const Lg4: f64 = 2.222219843214978396e-01; 104 const Lg5: f64 = 1.818357216161805012e-01; 105 const Lg6: f64 = 1.531383769920937332e-01; 106 const Lg7: f64 = 1.479819860511658591e-01; 107 108 var x = x_; 109 var ix: u64 = @bitCast(x); 110 var hx: u32 = @intCast(ix >> 32); 111 var k: i32 = 0; 112 113 if (hx < 0x00100000 or hx >> 31 != 0) { 114 // log(+-0) = -inf 115 if (ix << 1 == 0) { 116 return -math.inf(f64); 117 } 118 // log(-#) = nan 119 if (hx >> 31 != 0) { 120 return math.nan(f64); 121 } 122 123 // subnormal, scale x 124 k -= 54; 125 x *= 0x1.0p54; 126 hx = @intCast(@as(u64, @bitCast(x)) >> 32); 127 } else if (hx >= 0x7FF00000) { 128 return x; 129 } else if (hx == 0x3FF00000 and ix << 32 == 0) { 130 return 0; 131 } 132 133 // x into [sqrt(2) / 2, sqrt(2)] 134 hx += 0x3FF00000 - 0x3FE6A09E; 135 k += @as(i32, @intCast(hx >> 20)) - 0x3FF; 136 hx = (hx & 0x000FFFFF) + 0x3FE6A09E; 137 ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF); 138 x = @bitCast(ix); 139 140 const f = x - 1.0; 141 const hfsq = 0.5 * f * f; 142 const s = f / (2.0 + f); 143 const z = s * s; 144 const w = z * z; 145 const t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); 146 const t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); 147 const R = t2 + t1; 148 149 // hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f) 150 var hi = f - hfsq; 151 var hii: u64 = @bitCast(hi); 152 hii &= @as(u64, maxInt(u64)) << 32; 153 hi = @bitCast(hii); 154 const lo = f - hi - hfsq + s * (hfsq + R); 155 156 // val_hi + val_lo ~ log10(1 + f) + k * log10(2) 157 var val_hi = hi * ivln10hi; 158 const dk: f64 = @floatFromInt(k); 159 const y = dk * log10_2hi; 160 var val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi; 161 162 // Extra precision multiplication 163 const ww = y + val_hi; 164 val_lo += (y - ww) + val_hi; 165 val_hi = ww; 166 167 return val_lo + val_hi; 168 } 169 170 pub fn __log10x(a: f80) callconv(.c) f80 { 171 // TODO: more efficient implementation 172 return @floatCast(log10q(a)); 173 } 174 175 pub fn log10q(a: f128) callconv(.c) f128 { 176 // TODO: more correct implementation 177 return log10(@floatCast(a)); 178 } 179 180 pub fn log10l(x: c_longdouble) callconv(.c) c_longdouble { 181 switch (@typeInfo(c_longdouble).float.bits) { 182 16 => return __log10h(x), 183 32 => return log10f(x), 184 64 => return log10(x), 185 80 => return __log10x(x), 186 128 => return log10q(x), 187 else => @compileError("unreachable"), 188 } 189 } 190 191 test "log10f() special" { 192 try expectEqual(log10f(0.0), -math.inf(f32)); 193 try expectEqual(log10f(-0.0), -math.inf(f32)); 194 try expect(math.isPositiveZero(log10f(1.0))); 195 try expectEqual(log10f(10.0), 1.0); 196 try expectEqual(log10f(0.1), -1.0); 197 try expectEqual(log10f(math.inf(f32)), math.inf(f32)); 198 try expect(math.isNan(log10f(-1.0))); 199 try expect(math.isNan(log10f(-math.inf(f32)))); 200 try expect(math.isNan(log10f(math.nan(f32)))); 201 try expect(math.isNan(log10f(math.snan(f32)))); 202 } 203 204 test "log10f() sanity" { 205 try expect(math.isNan(log10f(-0x1.0223a0p+3))); 206 try expectEqual(log10f(0x1.161868p+2), 0x1.46a9bcp-1); 207 try expect(math.isNan(log10f(-0x1.0c34b4p+3))); 208 try expect(math.isNan(log10f(-0x1.a206f0p+2))); 209 try expectEqual(log10f(0x1.288bbcp+3), 0x1.ef1300p-1); 210 try expectEqual(log10f(0x1.52efd0p-1), -0x1.6ee6dcp-3); // Disagrees with GCC in last bit 211 try expect(math.isNan(log10f(-0x1.a05cc8p-2))); 212 try expectEqual(log10f(0x1.1f9efap-1), -0x1.0075ccp-2); 213 try expectEqual(log10f(0x1.8c5db0p-1), -0x1.c75df8p-4); 214 try expect(math.isNan(log10f(-0x1.5b86eap-1))); 215 } 216 217 test "log10f() boundary" { 218 try expectEqual(log10f(0x1.fffffep+127), 0x1.344136p+5); // Max input value 219 try expectEqual(log10f(0x1p-149), -0x1.66d3e8p+5); // Min positive input value 220 try expect(math.isNan(log10f(-0x1p-149))); // Min negative input value 221 try expectEqual(log10f(0x1.000002p+0), 0x1.bcb7b0p-25); // Last value before result reaches +0 222 try expectEqual(log10f(0x1.fffffep-1), -0x1.bcb7b2p-26); // Last value before result reaches -0 223 try expectEqual(log10f(0x1p-126), -0x1.2f7030p+5); // First subnormal 224 try expect(math.isNan(log10f(-0x1p-126))); // First negative subnormal 225 } 226 227 test "log10() special" { 228 try expectEqual(log10(0.0), -math.inf(f64)); 229 try expectEqual(log10(-0.0), -math.inf(f64)); 230 try expect(math.isPositiveZero(log10(1.0))); 231 try expectEqual(log10(10.0), 1.0); 232 try expectEqual(log10(0.1), -1.0); 233 try expectEqual(log10(math.inf(f64)), math.inf(f64)); 234 try expect(math.isNan(log10(-1.0))); 235 try expect(math.isNan(log10(-math.inf(f64)))); 236 try expect(math.isNan(log10(math.nan(f64)))); 237 try expect(math.isNan(log10(math.snan(f64)))); 238 } 239 240 test "log10() sanity" { 241 try expect(math.isNan(log10(-0x1.02239f3c6a8f1p+3))); 242 try expectEqual(log10(0x1.161868e18bc67p+2), 0x1.46a9bd1d2eb87p-1); 243 try expect(math.isNan(log10(-0x1.0c34b3e01e6e7p+3))); 244 try expect(math.isNan(log10(-0x1.a206f0a19dcc4p+2))); 245 try expectEqual(log10(0x1.288bbb0d6a1e6p+3), 0x1.ef12fff994862p-1); 246 try expectEqual(log10(0x1.52efd0cd80497p-1), -0x1.6ee6db5a155cbp-3); 247 try expect(math.isNan(log10(-0x1.a05cc754481d1p-2))); 248 try expectEqual(log10(0x1.1f9ef934745cbp-1), -0x1.0075cda79d321p-2); 249 try expectEqual(log10(0x1.8c5db097f7442p-1), -0x1.c75df6442465ap-4); 250 try expect(math.isNan(log10(-0x1.5b86ea8118a0ep-1))); 251 } 252 253 test "log10() boundary" { 254 try expectEqual(log10(0x1.fffffffffffffp+1023), 0x1.34413509f79ffp+8); // Max input value 255 try expectEqual(log10(0x1p-1074), -0x1.434e6420f4374p+8); // Min positive input value 256 try expect(math.isNan(log10(-0x1p-1074))); // Min negative input value 257 try expectEqual(log10(0x1.0000000000001p+0), 0x1.bcb7b1526e50dp-54); // Last value before result reaches +0 258 try expectEqual(log10(0x1.fffffffffffffp-1), -0x1.bcb7b1526e50fp-55); // Last value before result reaches -0 259 try expectEqual(log10(0x1p-1022), -0x1.33a7146f72a42p+8); // First subnormal 260 try expect(math.isNan(log10(-0x1p-1022))); // First negative subnormal 261 }