//

// Lookup data for exp2f

//

// @ts-ignore: decorator

@inline const EXP2F_TABLE_BITS = 5;

// @ts-ignore: decorator

@lazy @inline const EXP2F_DATA_TAB = memory.data<u64>([

// exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)

// used for computing 2^(k/N) for an int |k| < 150 N as

// double(tab[k%N] + (k << 52-BITS))

0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,

0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,

0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,

0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,

0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,

0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,

0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,

0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540

]);

// ULP error: 0.502 (nearest rounding.)

// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)

// Wrong count: 168353 (all nearest rounding wrong results with fma.)

// @ts-ignore: decorator

@inline

export function exp2f_lut(x: f32): f32 {

const

N = 1 << EXP2F_TABLE_BITS,

N_MASK = N - 1,

shift = reinterpret<f64>(0x4338000000000000) / N, // 0x1.8p+52

Ox127f = reinterpret<f32>(0x7F000000);

const

C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5

C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3

C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1

var xd = <f64>x;

var ix = reinterpret<u32>(x);

var ux = ix >> 20 & 0x7FF;

if (ux >= 0x430) {

// |x| >= 128 or x is nan.

if (ix == 0xFF800000) return 0; // x == -Inf -> 0

if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN

if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)

if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)

}

// x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.

var kd = xd + shift;

var ki = reinterpret<u64>(kd);

var r = xd - (kd - shift);

var t: u64, y: f64, s: f64;

// exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)

t = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));

t += ki << (52 - EXP2F_TABLE_BITS);

s = reinterpret<f64>(t);

y = C2 * r + 1;

y += (C0 * r + C1) * (r * r);

y *= s;

return <f32>y;

}

// ULP error: 0.502 (nearest rounding.)

// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)

// Wrong count: 170635 (all nearest rounding wrong results with fma.)

// @ts-ignore: decorator

@inline

export function expf_lut(x: f32): f32 {

const

N = 1 << EXP2F_TABLE_BITS,

N_MASK = N - 1,

shift = reinterpret<f64>(0x4338000000000000), // 0x1.8p+52

InvLn2N = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0

Ox1p127f = reinterpret<f32>(0x7F000000);

const

C0 = reinterpret<f64>(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5

C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3

C2 = reinterpret<f64>(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1

var xd = <f64>x;

var ix = reinterpret<u32>(x);

var ux = ix >> 20 & 0x7FF;

if (ux >= 0x42B) {

// |x| >= 88 or x is nan.

if (ix == 0xFF800000) return 0; // x == -Inf -> 0

if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN

if (x > reinterpret<f32>(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)

if (x < reinterpret<f32>(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)

}

// x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.

var z = InvLn2N * xd;

// Round and convert z to int, the result is in [-150*N, 128*N] and

// ideally ties-to-even rule is used, otherwise the magnitude of r

// can be bigger which gives larger approximation error.

var kd = <f64>(z + shift);

var ki = reinterpret<u64>(kd);

var r = z - (kd - shift);

var s: f64, y: f64, t: u64;

// exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)

t = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));

t += ki << (52 - EXP2F_TABLE_BITS);

s = reinterpret<f64>(t);

z = C0 * r + C1;

y = C2 * r + 1;

y += z * (r * r);

y *= s;

return <f32>y;

}

//

// Lookup data for log2f

//

// @ts-ignore: decorator

@inline const LOG2F_TABLE_BITS = 4;

// @ts-ignore: decorator

@lazy @inline const LOG2F_DATA_TAB = memory.data<f64>([

reinterpret<f64>(0x3FF661EC79F8F3BE), reinterpret<f64>(0xBFDEFEC65B963019), // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,

reinterpret<f64>(0x3FF571ED4AAF883D), reinterpret<f64>(0xBFDB0B6832D4FCA4), // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,

reinterpret<f64>(0x3FF49539F0F010B0), reinterpret<f64>(0xBFD7418B0A1FB77B), // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,

reinterpret<f64>(0x3FF3C995B0B80385), reinterpret<f64>(0xBFD39DE91A6DCF7B), // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,

reinterpret<f64>(0x3FF30D190C8864A5), reinterpret<f64>(0xBFD01D9BF3F2B631), // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,

reinterpret<f64>(0x3FF25E227B0B8EA0), reinterpret<f64>(0xBFC97C1D1B3B7AF0), // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,

reinterpret<f64>(0x3FF1BB4A4A1A343F), reinterpret<f64>(0xBFC2F9E393AF3C9F), // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,

reinterpret<f64>(0x3FF12358F08AE5BA), reinterpret<f64>(0xBFB960CBBF788D5C), // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,

reinterpret<f64>(0x3FF0953F419900A7), reinterpret<f64>(0xBFAA6F9DB6475FCE), // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,

reinterpret<f64>(0x3FF0000000000000), 0, // 0x1p+0, 0x0,

reinterpret<f64>(0x3FEE608CFD9A47AC), reinterpret<f64>(0x3FB338CA9F24F53D), // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,

reinterpret<f64>(0x3FECA4B31F026AA0), reinterpret<f64>(0x3FC476A9543891BA), // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,

reinterpret<f64>(0x3FEB2036576AFCE6), reinterpret<f64>(0x3FCE840B4AC4E4D2), // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,

reinterpret<f64>(0x3FE9C2D163A1AA2D), reinterpret<f64>(0x3FD40645F0C6651C), // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,

reinterpret<f64>(0x3FE886E6037841ED), reinterpret<f64>(0x3FD88E9C2C1B9FF8), // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,

reinterpret<f64>(0x3FE767DCF5534862), reinterpret<f64>(0x3FDCE0A44EB17BCC) // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2

]);

// ULP error: 0.752 (nearest rounding.)

// Relative error: 1.9 * 2^-26 (before rounding.)

// @ts-ignore: decorator

@inline

export function log2f_lut(x: f32): f32 {

const

N_MASK = (1 << LOG2F_TABLE_BITS) - 1,

Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f

const

A0 = reinterpret<f64>(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2

A1 = reinterpret<f64>(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2

A2 = reinterpret<f64>(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1

A3 = reinterpret<f64>(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0

var ux = reinterpret<u32>(x);

// Fix sign of zero with downward rounding when x==1.

// if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;

if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {

// x < 0x1p-126 or inf or nan.

if (ux * 2 == 0) return -Infinity;

if (ux == 0x7F800000) return x; // log2(inf) == inf.

if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);

// x is subnormal, normalize it.

ux = reinterpret<u32>(x * Ox1p23f);

ux -= 23 << 23;

}

// x = 2^k z; where z is in range [OFF,2*OFF] and exact.

// The range is split into N subintervals.

// The ith subinterval contains z and c is near its center.

var tmp = ux - 0x3F330000;

var i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;

var top = tmp & 0xFF800000;

var iz = ux - top;

var k = <i32>tmp >> 23;

var invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());

var logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());

var z = <f64>reinterpret<f32>(iz);

// log2(x) = log1p(z/c-1)/ln2 + log2(c) + k

var r = z * invc - 1;

var y0 = logc + <f64>k;

// Pipelined polynomial evaluation to approximate log1p(r)/ln2.

var y = A1 * r + A2;

var p = A3 * r + y0;

var r2 = r * r;

y += A0 * r2;

y = y * r2 + p;

return <f32>y;

}

//

// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c

//

// @ts-ignore: decorator

@inline const LOGF_TABLE_BITS = 4;

// @ts-ignore: decorator

@lazy @inline const LOGF_DATA_TAB = memory.data<f64>([

reinterpret<f64>(0x3FF661EC79F8F3BE), reinterpret<f64>(0xBFD57BF7808CAADE), // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,

reinterpret<f64>(0x3FF571ED4AAF883D), reinterpret<f64>(0xBFD2BEF0A7C06DDB), // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,

reinterpret<f64>(0x3FF49539F0F010B0), reinterpret<f64>(0xBFD01EAE7F513A67), // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,

reinterpret<f64>(0x3FF3C995B0B80385), reinterpret<f64>(0xBFCB31D8A68224E9), // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,

reinterpret<f64>(0x3FF30D190C8864A5), reinterpret<f64>(0xBFC6574F0AC07758), // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,

reinterpret<f64>(0x3FF25E227B0B8EA0), reinterpret<f64>(0xBFC1AA2BC79C8100), // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,

reinterpret<f64>(0x3FF1BB4A4A1A343F), reinterpret<f64>(0xBFBA4E76CE8C0E5E), // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,

reinterpret<f64>(0x3FF12358F08AE5BA), reinterpret<f64>(0xBFB1973C5A611CCC), // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,

reinterpret<f64>(0x3FF0953F419900A7), reinterpret<f64>(0xBFA252F438E10C1E), // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,

reinterpret<f64>(0x3FF0000000000000), 0, // 0x1p+0, 0,

reinterpret<f64>(0x3FEE608CFD9A47AC), reinterpret<f64>(0x3FAAA5AA5DF25984), // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,

reinterpret<f64>(0x3FECA4B31F026AA0), reinterpret<f64>(0x3FBC5E53AA362EB4), // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,

reinterpret<f64>(0x3FEB2036576AFCE6), reinterpret<f64>(0x3FC526E57720DB08), // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,

reinterpret<f64>(0x3FE9C2D163A1AA2D), reinterpret<f64>(0x3FCBC2860D224770), // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,

reinterpret<f64>(0x3FE886E6037841ED), reinterpret<f64>(0x3FD1058BC8A07EE1), // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,

reinterpret<f64>(0x3FE767DCF5534862), reinterpret<f64>(0x3FD4043057B6EE09) // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2

]);

// ULP error: 0.818 (nearest rounding.)

// Relative error: 1.957 * 2^-26 (before rounding.)

// @ts-ignore: decorator

@inline

export function logf_lut(x: f32): f32 {

const

N_MASK = (1 << LOGF_TABLE_BITS) - 1,

Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f

const

Ln2 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;

A0 = reinterpret<f64>(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2

A1 = reinterpret<f64>(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2

A2 = reinterpret<f64>(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2

var ux = reinterpret<u32>(x);

// Fix sign of zero with downward rounding when x==1.

// if (WANT_ROUNDING && ux == 0x3f800000) return 0;

if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {

// x < 0x1p-126 or inf or nan.

if ((ux << 1) == 0) return -Infinity;

if (ux == 0x7F800000) return x; // log(inf) == inf.

if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);

// x is subnormal, normalize it.

ux = reinterpret<u32>(x * Ox1p23f);

ux -= 23 << 23;

}

// x = 2^k z; where z is in range [OFF,2*OFF] and exact.

// The range is split into N subintervals.

// The ith subinterval contains z and c is near its center.

var tmp = ux - 0x3F330000;

var i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;

var k = <i32>tmp >> 23;

var iz = ux - (tmp & 0x1FF << 23);

var invc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());

var logc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());

var z = <f64>reinterpret<f32>(iz);

// log(x) = log1p(z/c-1) + log(c) + k*Ln2

var r = z * invc - 1;

var y0 = logc + <f64>k * Ln2;

// Pipelined polynomial evaluation to approximate log1p(r).

var r2 = r * r;

var y = A1 * r + A2;

y += A0 * r2;

y = y * r2 + (y0 + r);

return <f32>y;

}

//

// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c

//

// @ts-ignore: decorator

@inline

function zeroinfnanf(ux: u32): bool {

return (ux << 1) - 1 >= (<u32>0x7f800000 << 1) - 1;

}

// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is

// the bit representation of a non-zero finite floating-point value.

// @ts-ignore: decorator

@inline

function checkintf(iy: u32): i32 {

var e = iy >> 23 & 0xFF;

if (e < 0x7F ) return 0;

if (e > 0x7F + 23) return 2;

e = 1 << (0x7F + 23 - e);

if (iy & (e - 1)) return 0;

if (iy & e ) return 1;

return 2;

}

// Subnormal input is normalized so ix has negative biased exponent.

// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.

// @ts-ignore: decorator

@inline

function log2f_inline(ux: u32): f64 {

const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;

const

A0 = reinterpret<f64>(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2

A1 = reinterpret<f64>(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2

A2 = reinterpret<f64>(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2

A3 = reinterpret<f64>(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1

A4 = reinterpret<f64>(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0

// x = 2^k z; where z is in range [OFF,2*OFF] and exact.

// The range is split into N subintervals.

// The ith subinterval contains z and c is near its center.

var tmp = ux - 0x3F330000;

var i = <usize>((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);

var top = tmp & 0xFF800000;

var uz = ux - top;

var k = <i32>(<i32>top >> 23);

var invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());

var logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());

var z = <f64>reinterpret<f32>(uz);

// log2(x) = log1p(z/c-1)/ln2 + log2(c) + k

var r = z * invc - 1;

var y0 = logc + <f64>k;

// Pipelined polynomial evaluation to approximate log1p(r)/ln2.

var y = A0 * r + A1;

var p = A2 * r + A3;

var q = A4 * r + y0;

r *= r;

q += p * r;

y = y * (r * r) + q;

return y;

}

// The output of log2 and thus the input of exp2 is either scaled by N

// (in case of fast toint intrinsics) or not. The unscaled xd must be

// in [-1021,1023], sign_bias sets the sign of the result.

// @ts-ignore: decorator

@inline

function exp2f_inline(xd: f64, signBias: u32): f32 {

const

N = 1 << EXP2F_TABLE_BITS,

N_MASK = N - 1,

shift = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p+52

const

C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5

C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3

C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1

// x = k/N + r with r in [-1/(2N), 1/(2N)]

var kd = <f64>(xd + shift);

var ki = reinterpret<u64>(kd);

var r = xd - (kd - shift);

var t: u64, z: f64, y: f64, s: f64;

// exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)

t = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));

t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);

s = reinterpret<f64>(t);

z = C0 * r + C1;

y = C2 * r + 1;

y += z * (r * r);

y *= s;

return <f32>y;

}

// @ts-ignore: decorator

@inline

function xflowf(sign: u32, y: f32): f32 {

return select<f32>(-y, y, sign) * y;

}

// @ts-ignore: decorator

@inline

function oflowf(sign: u32): f32 {

return xflowf(sign, reinterpret<f32>(0x70000000)); // 0x1p97f

}

// @ts-ignore: decorator

@inline

function uflowf(sign: u32): f32 {

return xflowf(sign, reinterpret<f32>(0x10000000)); // 0x1p-95f

}

// @ts-ignore: decorator

@inline

export function powf_lut(x: f32, y: f32): f32 {

const

Ox1p23f = reinterpret<f32>(0x4B000000), // 0x1p23f

UPPER_LIMIT = reinterpret<f64>(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6

LOWER_LIMIT = -150.0,

SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);

var signBias: u32 = 0;

var ix = reinterpret<u32>(x);

var iy = reinterpret<u32>(y);

var ny = 0;

if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {

// Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).

if (ny) {

if ((iy << 1) == 0) return 1.0;

if (ix == 0x3F800000) return NaN; // original: 1.0

if ((ix << 1) > (<u32>0x7F800000 << 1) || (iy << 1) > (<u32>0x7F800000 << 1)) return x + y;

if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0

if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.

return y * y;

}

if (zeroinfnanf(ix)) {

let x2 = x * x;

if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;

return iy >> 31 ? 1 / x2 : x2;

}

// x and y are non-zero finite.

if (ix >> 31) {

// Finite x < 0.

let yint = checkintf(iy);

if (yint == 0) return (x - x) / (x - x);

if (yint == 1) signBias = SIGN_BIAS;

ix &= 0x7FFFFFFF;

}

if (ix < 0x00800000) {

// Normalize subnormal x so exponent becomes negative.

ix = reinterpret<u32>(x * Ox1p23f);

ix &= 0x7FFFFFFF;

ix -= 23 << 23;

}

}

var logx = log2f_inline(ix);

var ylogx = y * logx; // cannot overflow, y is single prec.

if ((reinterpret<u64>(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret<u64>(126.0) >> 47

// |y * log(x)| >= 126

if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow

if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow

}

return exp2f_inline(ylogx, signBias);

}

//

// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c

//

// @ts-ignore: decorator

@inline const EXP_TABLE_BITS = 7;

// @ts-ignore: decorator

@lazy @inline const EXP_DATA_TAB = memory.data<u64>([

0x0000000000000000, 0x3FF0000000000000,

0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,

0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,

0xBC905E7A108766D1, 0x3FEFE315E86E7F85,

0x3C8CD2523567F613, 0x3FEFD9B0D3158574,

0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,

0x3C60F74E61E6C861, 0x3FEFC74518759BC8,

0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,

0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,

0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,

0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,

0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,

0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,

0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,

0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,

0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,

0xBC801B15EAA59348, 0x3FEF72B83C7D517B,

0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,

0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,

0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,

0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,

0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,

0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,

0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,

0x3C968EFDE3A8A894, 0x3FEF387A6E756238,

0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,

0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,

0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,

0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,

0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,

0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,

0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,

0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,

0x3C864201E2AC744C, 0x3FEF0170FC4CD831,

0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,

0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,

0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,

0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,

0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,

0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,

0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,

0xBC9312607A28698A, 0x3FEEDA4504AC801C,

0xBC58A78F4817895B, 0x3FEED60A21F72E2A,

0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,

0x3C4363ED60C2AC11, 0x3FEECE086061892D,

0x3C9666093B0664EF, 0x3FEECA41ED1D0057,

0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,

0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,

0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,

0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,

0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,

0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,

0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,

0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,

0x3C93350518FDD78E, 0x3FEEAF4736B527DA,

0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,

0x3C9063E1E21C5409, 0x3FEEAB07DD485429,

0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,

0x3C9432E62B64C035, 0x3FEEA76F15AD2148,

0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,

0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,

0xBC845378892BE9AE, 0x3FEEA34634CCC320,

0xBC93CEDD78565858, 0x3FEEA23882552225,

0x3C5710AA807E1964, 0x3FEEA155D44CA973,

0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,

0xBC6A12AD8734B982, 0x3FEEA012750BDABF,

0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,

0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,

0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,

0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,

0xBC8619321E55E68A, 0x3FEE9FEB564267C9,

0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,

0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,

0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,

0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,

0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,

0xBC9369B6F13B3734, 0x3FEEA589994CCE13,

0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,

0xBC94D450D872576E, 0x3FEEA8D99B4492ED,

0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,

0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,

0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,

0x3C7BF68359F35F44, 0x3FEEB1AE99157736,

0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,

0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,

0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,

0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,

0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,

0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,

0x3C6DD235E10A73BB, 0x3FEEC86319E32323,

0xBC87C50422622263, 0x3FEECC667B5DE565,

0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,

0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,

0x3C90CC319CEE31D2, 0x3FEED99E1330B358,

0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,

0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,

0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,

0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,

0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,

0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,

0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,

0xBC91EEE26B588A35, 0x3FEF05B030A1064A,

0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,

0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,

0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,

0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,

0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,

0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,

0x3C676B2C6C921968, 0x3FEF3720DCEF9069,

0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,

0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,

0xBC900DAE3875A949, 0x3FEF4F87080D89F2,

0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,

0xBC82919E2040220F, 0x3FEF60E316C98398,

0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,

0x3C843A59AC016B4B, 0x3FEF7321F301B460,

0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,

0xBC892AB93B470DC9, 0x3FEF864614F5A129,

0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,

0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,

0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,

0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,

0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,

0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,

0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,

0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,

0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,

0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1

]);

// Handle cases that may overflow or underflow when computing the result that

// is scale*(1+TMP) without intermediate rounding. The bit representation of

// scale is in SBITS, however it has a computed exponent that may have

// overflown into the sign bit so that needs to be adjusted before using it as

// a double. (int32_t)KI is the k used in the argument reduction and exponent

// adjustment of scale, positive k here means the result may overflow and

// negative k means the result may underflow.

// @ts-ignore: decorator

@inline

function specialcase(tmp: f64, sbits: u64, ki: u64): f64 {

const

Ox1p_1022 = reinterpret<f64>(0x0010000000000000), // 0x1p-1022

Ox1p1009 = reinterpret<f64>(0x7F00000000000000); // 0x1p1009

var scale: f64;

if (!(ki & 0x80000000)) {

// k > 0, the exponent of scale might have overflowed by <= 460.

sbits -= u64(1009) << 52;

scale = reinterpret<f64>(sbits);

return Ox1p1009 * (scale + scale * tmp); // 0x1p1009

}

// k < 0, need special care in the subnormal range.

sbits += u64(1022) << 52;

// Note: sbits is signed scale.

scale = reinterpret<f64>(sbits);

var y = scale + scale * tmp;

if (abs(y) < 1.0) {

// Round y to the right precision before scaling it into the subnormal

// range to avoid double rounding that can cause 0.5+E/2 ulp error where

// E is the worst-case ulp error outside the subnormal range. So this

// is only useful if the goal is better than 1 ulp worst-case error.

let one = copysign(1.0, y);

let lo = scale - y + scale * tmp;

let hi = one + y;

lo = one - hi + y + lo;

y = (hi + lo) - one;

// Fix the sign of 0.

if (y == 0.0) y = reinterpret<f64>(sbits & 0x8000000000000000);

}

return y * Ox1p_1022;

}

// @ts-ignore: decorator

@inline

export function exp_lut(x: f64): f64 {

const

N = 1 << EXP_TABLE_BITS,

N_MASK = N - 1;

const

InvLn2N = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0

NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8

NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47

shift = reinterpret<f64>(0x4338000000000000); // 0x1.8p52;

const

C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)

C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)

C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)

C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)

var ux = reinterpret<u64>(x);

var abstop = <u32>(ux >> 52 & 0x7FF);

if (abstop - 0x3C9 >= 0x03F) {

if (abstop - 0x3C9 >= 0x80000000) return 1;

if (abstop >= 0x409) {

if (ux == 0xFFF0000000000000) return 0;

if (abstop >= 0x7FF) return 1.0 + x;

return select<f64>(0, Infinity, ux >> 63);

}

// Large x is special cased below.

abstop = 0;

}

// exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]

// x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]

var z = InvLn2N * x;

// #if TOINT_INTRINSICS

// kd = roundtoint(z);

// ki = converttoint(z);

// #elif EXP_USE_TOINT_NARROW

// // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.

// var kd = z + shift;

// var ki = reinterpret<u64>(kd) >> 16;

// var kd = <f64><i32>ki;

// #else

// z - kd is in [-1, 1] in non-nearest rounding modes.

var kd = z + shift;

var ki = reinterpret<u64>(kd);

kd -= shift;

// #endif

var r = x + kd * NegLn2hiN + kd * NegLn2loN;

// 2^(k/N) ~= scale * (1 + tail).

var idx = <usize>((ki & N_MASK) << 1);

var top = ki << (52 - EXP_TABLE_BITS);

var tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()))); // T[idx]

// This is only a valid scale when -1023*N < k < 1024*N

var sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]

// exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).

// Evaluation is optimized assuming superscalar pipelined execution.

var r2 = r * r;

// Without fma the worst case error is 0.25/N ulp larger.

// Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.

var tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);

if (abstop == 0) return specialcase(tmp, sbits, ki);

var scale = reinterpret<f64>(sbits);

// Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there

// is no spurious underflow here even without fma.

return scale + scale * tmp;

}

//

// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c

//

// Handle cases that may overflow or underflow when computing the result that

// is scale*(1+TMP) without intermediate rounding. The bit representation of

// scale is in SBITS, however it has a computed exponent that may have

// overflown into the sign bit so that needs to be adjusted before using it as

// a double. (int32_t)KI is the k used in the argument reduction and exponent

// adjustment of scale, positive k here means the result may overflow and

// negative k means the result may underflow.

// @ts-ignore: decorator

@inline

function specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {

const Ox1p_1022 = reinterpret<f64>(0x10000000000000); // 0x1p-1022

var scale: f64;

if ((ki & 0x80000000) == 0) {

// k > 0, the exponent of scale might have overflowed by 1

sbits -= u64(1) << 52;

scale = reinterpret<f64>(sbits);

return 2 * (scale * tmp + scale);

}

// k < 0, need special care in the subnormal range

sbits += u64(1022) << 52;

scale = reinterpret<f64>(sbits);

var y = scale * tmp + scale;

if (y < 1.0) {

// Round y to the right precision before scaling it into the subnormal

// range to avoid double rounding that can cause 0.5+E/2 ulp error where

// E is the worst-case ulp error outside the subnormal range. So this

// is only useful if the goal is better than 1 ulp worst-case error.

let hi: f64, lo: f64;

lo = scale - y + scale * tmp;

hi = 1.0 + y;

lo = 1.0 - hi + y + lo;

y = (hi + lo) - 1.0;

}

return y * Ox1p_1022;

}

// @ts-ignore: decorator

@inline

export function exp2_lut(x: f64): f64 {

const

N = 1 << EXP_TABLE_BITS,

N_MASK = N - 1,

shift = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p52

const

C1 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1

C2 = reinterpret<f64>(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3

C3 = reinterpret<f64>(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5

C4 = reinterpret<f64>(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7

C5 = reinterpret<f64>(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10

var ux = reinterpret<u64>(x);

var abstop = <u32>(ux >> 52 & 0x7ff);

if (abstop - 0x3C9 >= 0x03F) {

if (abstop - 0x3C9 >= 0x80000000) return 1.0;

if (abstop >= 0x409) {

if (ux == 0xFFF0000000000000) return 0;

if (abstop >= 0x7FF) return 1.0 + x;

if (!(ux >> 63)) return Infinity;

else if (ux >= 0xC090CC0000000000) return 0;

}

if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.

}

// exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].

// x = k/N + r, with int k and r in [-1/2N, 1/2N]

var kd = x + shift;

var ki = reinterpret<u64>(kd);

kd -= shift; // k/N for int k

var r = x - kd;

// 2^(k/N) ~= scale * (1 + tail)

var idx = <usize>((ki & N_MASK) << 1);

var top = ki << (52 - EXP_TABLE_BITS);

var tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 0 << alignof<u64>())); // T[idx])

// This is only a valid scale when -1023*N < k < 1024*N

var sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]

// exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).

// Evaluation is optimized assuming superscalar pipelined execution

var r2 = r * r;

// Without fma the worst case error is 0.5/N ulp larger.

// Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.

var tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);

if (abstop == 0) return specialcase2(tmp, sbits, ki);

var scale = reinterpret<f64>(sbits);

// Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there

// is no spurious underflow here even without fma.

return scale * tmp + scale;

}

//

// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c

//

// @ts-ignore: decorator

@inline const LOG2_TABLE_BITS = 6;

/* Algorithm:

x = 2^k z

log2(x) = k + log2(c) + log2(z/c)

log2(z/c) = poly(z/c - 1)

where z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls

into the ith one, then table entries are computed as

tab[i].invc = 1/c

tab[i].logc = (double)log2(c)

tab2[i].chi = (double)c

tab2[i].clo = (double)(c - (double)c)

where c is near the center of the subinterval and is chosen by trying +-2^29

floating point invc candidates around 1/center and selecting one for which

1) the rounding error in 0x1.8p10 + logc is 0,

2) the rounding error in z - chi - clo is < 0x1p-64 and

3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).

Note: 1) ensures that k + logc can be computed without rounding error, 2)

ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a

single rounding error when there is no fast fma for z*invc - 1, 3) ensures

that logc + poly(z/c - 1) has small error, however near x == 1 when

|log2(x)| < 0x1p-4, this is not enough so that is special cased. */

// @ts-ignore: decorator

@lazy @inline const LOG2_DATA_TAB1 = memory.data<f64>([

// invc , logc

reinterpret<f64>(0x3FF724286BB1ACF8), reinterpret<f64>(0xBFE1095FEECDB000),

reinterpret<f64>(0x3FF6E1F766D2CCA1), reinterpret<f64>(0xBFE08494BD76D000),

reinterpret<f64>(0x3FF6A13D0E30D48A), reinterpret<f64>(0xBFE00143AEE8F800),

reinterpret<f64>(0x3FF661EC32D06C85), reinterpret<f64>(0xBFDEFEC5360B4000),

reinterpret<f64>(0x3FF623FA951198F8), reinterpret<f64>(0xBFDDFDD91AB7E000),

reinterpret<f64>(0x3FF5E75BA4CF026C), reinterpret<f64>(0xBFDCFFAE0CC79000),

reinterpret<f64>(0x3FF5AC055A214FB8), reinterpret<f64>(0xBFDC043811FDA000),

reinterpret<f64>(0x3FF571ED0F166E1E), reinterpret<f64>(0xBFDB0B67323AE000),

reinterpret<f64>(0x3FF53909590BF835), reinterpret<f64>(0xBFDA152F5A2DB000),

reinterpret<f64>(0x3FF5014FED61ADDD), reinterpret<f64>(0xBFD9217F5AF86000),

reinterpret<f64>(0x3FF4CAB88E487BD0), reinterpret<f64>(0xBFD8304DB0719000),

reinterpret<f64>(0x3FF49539B4334FEE), reinterpret<f64>(0xBFD74189F9A9E000),

reinterpret<f64>(0x3FF460CBDFAFD569), reinterpret<f64>(0xBFD6552BB5199000),

reinterpret<f64>(0x3FF42D664EE4B953), reinterpret<f64>(0xBFD56B23A29B1000),

reinterpret<f64>(0x3FF3FB01111DD8A6), reinterpret<f64>(0xBFD483650F5FA000),

reinterpret<f64>(0x3FF3C995B70C5836), reinterpret<f64>(0xBFD39DE937F6A000),

reinterpret<f64>(0x3FF3991C4AB6FD4A), reinterpret<f64>(0xBFD2BAA1538D6000),

reinterpret<f64>(0x3FF3698E0CE099B5), reinterpret<f64>(0xBFD1D98340CA4000),

reinterpret<f64>(0x3FF33AE48213E7B2), reinterpret<f64>(0xBFD0FA853A40E000),

reinterpret<f64>(0x3FF30D191985BDB1), reinterpret<f64>(0xBFD01D9C32E73000),

reinterpret<f64>(0x3FF2E025CAB271D7), reinterpret<f64>(0xBFCE857DA2FA6000),

reinterpret<f64>(0x3FF2B404CF13CD82), reinterpret<f64>(0xBFCCD3C8633D8000),

reinterpret<f64>(0x3FF288B02C7CCB50), reinterpret<f64>(0xBFCB26034C14A000),

reinterpret<f64>(0x3FF25E2263944DE5), reinterpret<f64>(0xBFC97C1C2F4FE000),

reinterpret<f64>(0x3FF234563D8615B1), reinterpret<f64>(0xBFC7D6023F800000),

reinterpret<f64>(0x3FF20B46E33EAF38), reinterpret<f64>(0xBFC633A71A05E000),

reinterpret<f64>(0x3FF1E2EEFDCDA3DD), reinterpret<f64>(0xBFC494F5E9570000),

reinterpret<f64>(0x3FF1BB4A580B3930), reinterpret<f64>(0xBFC2F9E424E0A000),

reinterpret<f64>(0x3FF19453847F2200), reinterpret<f64>(0xBFC162595AFDC000),

reinterpret<f64>(0x3FF16E06C0D5D73C), reinterpret<f64>(0xBFBF9C9A75BD8000),

reinterpret<f64>(0x3FF1485F47B7E4C2), reinterpret<f64>(0xBFBC7B575BF9C000),

reinterpret<f64>(0x3FF12358AD0085D1), reinterpret<f64>(0xBFB960C60FF48000),

reinterpret<f64>(0x3FF0FEF00F532227), reinterpret<f64>(0xBFB64CE247B60000),

reinterpret<f64>(0x3FF0DB2077D03A8F), reinterpret<f64>(0xBFB33F78B2014000),

reinterpret<f64>(0x3FF0B7E6D65980D9), reinterpret<f64>(0xBFB0387D1A42C000),

reinterpret<f64>(0x3FF0953EFE7B408D), reinterpret<f64>(0xBFAA6F9208B50000),

reinterpret<f64>(0x3FF07325CAC53B83), reinterpret<f64>(0xBFA47A954F770000),

reinterpret<f64>(0x3FF05197E40D1B5C), reinterpret<f64>(0xBF9D23A8C50C0000),

reinterpret<f64>(0x3FF03091C1208EA2), reinterpret<f64>(0xBF916A2629780000),

reinterpret<f64>(0x3FF0101025B37E21), reinterpret<f64>(0xBF7720F8D8E80000),

reinterpret<f64>(0x3FEFC07EF9CAA76B), reinterpret<f64>(0x3F86FE53B1500000),

reinterpret<f64>(0x3FEF4465D3F6F184), reinterpret<f64>(0x3FA11CCCE10F8000),

reinterpret<f64>(0x3FEECC079F84107F), reinterpret<f64>(0x3FAC4DFC8C8B8000),

reinterpret<f64>(0x3FEE573A99975AE8), reinterpret<f64>(0x3FB3AA321E574000),

reinterpret<f64>(0x3FEDE5D6F0BD3DE6), reinterpret<f64>(0x3FB918A0D08B8000),

reinterpret<f64>(0x3FED77B681FF38B3), reinterpret<f64>(0x3FBE72E9DA044000),

reinterpret<f64>(0x3FED0CB5724DE943), reinterpret<f64>(0x3FC1DCD2507F6000),

reinterpret<f64>(0x3FECA4B2DC0E7563), reinterpret<f64>(0x3FC476AB03DEA000),

reinterpret<f64>(0x3FEC3F8EE8D6CB51), reinterpret<f64>(0x3FC7074377E22000),

reinterpret<f64>(0x3FEBDD2B4F020C4C), reinterpret<f64>(0x3FC98EDE8BA94000),

reinterpret<f64>(0x3FEB7D6C006015CA), reinterpret<f64>(0x3FCC0DB86AD2E000),

reinterpret<f64>(0x3FEB20366E2E338F), reinterpret<f64>(0x3FCE840AAFCEE000),

reinterpret<f64>(0x3FEAC57026295039), reinterpret<f64>(0x3FD0790AB4678000),

reinterpret<f64>(0x3FEA6D01BC2731DD), reinterpret<f64>(0x3FD1AC056801C000),

reinterpret<f64>(0x3FEA16D3BC3FF18B), reinterpret<f64>(0x3FD2DB11D4FEE000),

reinterpret<f64>(0x3FE9C2D14967FEAD), reinterpret<f64>(0x3FD406464EC58000),

reinterpret<f64>(0x3FE970E4F47C9902), reinterpret<f64>(0x3FD52DBE093AF000),

reinterpret<f64>(0x3FE920FB3982BCF2), reinterpret<f64>(0x3FD651902050D000),

reinterpret<f64>(0x3FE8D30187F759F1), reinterpret<f64>(0x3FD771D2CDEAF000),

reinterpret<f64>(0x3FE886E5EBB9F66D), reinterpret<f64>(0x3FD88E9C857D9000),

reinterpret<f64>(0x3FE83C97B658B994), reinterpret<f64>(0x3FD9A80155E16000),

reinterpret<f64>(0x3FE7F405FFC61022), reinterpret<f64>(0x3FDABE186ED3D000),

reinterpret<f64>(0x3FE7AD22181415CA), reinterpret<f64>(0x3FDBD0F2AEA0E000),

reinterpret<f64>(0x3FE767DCF99EFF8C), reinterpret<f64>(0x3FDCE0A43DBF4000)

]);

// @ts-ignore: decorator

@lazy @inline const LOG2_DATA_TAB2 = memory.data<f64>([

// chi , clo

reinterpret<f64>(0x3FE6200012B90A8E), reinterpret<f64>(0x3C8904AB0644B605),

reinterpret<f64>(0x3FE66000045734A6), reinterpret<f64>(0x3C61FF9BEA62F7A9),

reinterpret<f64>(0x3FE69FFFC325F2C5), reinterpret<f64>(0x3C827ECFCB3C90BA),

reinterpret<f64>(0x3FE6E00038B95A04), reinterpret<f64>(0x3C88FF8856739326),

reinterpret<f64>(0x3FE71FFFE09994E3), reinterpret<f64>(0x3C8AFD40275F82B1),

reinterpret<f64>(0x3FE7600015590E10), reinterpret<f64>(0xBC72FD75B4238341),

reinterpret<f64>(0x3FE7A00012655BD5), reinterpret<f64>(0x3C7808E67C242B76),

reinterpret<f64>(0x3FE7E0003259E9A6), reinterpret<f64>(0xBC6208E426F622B7),

reinterpret<f64>(0x3FE81FFFEDB4B2D2), reinterpret<f64>(0xBC8402461EA5C92F),

reinterpret<f64>(0x3FE860002DFAFCC3), reinterpret<f64>(0x3C6DF7F4A2F29A1F),

reinterpret<f64>(0x3FE89FFFF78C6B50), reinterpret<f64>(0xBC8E0453094995FD),

reinterpret<f64>(0x3FE8E00039671566), reinterpret<f64>(0xBC8A04F3BEC77B45),

reinterpret<f64>(0x3FE91FFFE2BF1745), reinterpret<f64>(0xBC77FA34400E203C),

reinterpret<f64>(0x3FE95FFFCC5C9FD1), reinterpret<f64>(0xBC76FF8005A0695D),

reinterpret<f64>(0x3FE9A0003BBA4767), reinterpret<f64>(0x3C70F8C4C4EC7E03),

reinterpret<f64>(0x3FE9DFFFE7B92DA5), reinterpret<f64>(0x3C8E7FD9478C4602),

reinterpret<f64>(0x3FEA1FFFD72EFDAF), reinterpret<f64>(0xBC6A0C554DCDAE7E),

reinterpret<f64>(0x3FEA5FFFDE04FF95), reinterpret<f64>(0x3C867DA98CE9B26B),

reinterpret<f64>(0x3FEA9FFFCA5E8D2B), reinterpret<f64>(0xBC8284C9B54C13DE),

reinterpret<f64>(0x3FEADFFFDDAD03EA), reinterpret<f64>(0x3C5812C8EA602E3C),

reinterpret<f64>(0x3FEB1FFFF10D3D4D), reinterpret<f64>(0xBC8EFADDAD27789C),

reinterpret<f64>(0x3FEB5FFFCE21165A), reinterpret<f64>(0x3C53CB1719C61237),

reinterpret<f64>(0x3FEB9FFFD950E674), reinterpret<f64>(0x3C73F7D94194CE00),

reinterpret<f64>(0x3FEBE000139CA8AF), reinterpret<f64>(0x3C750AC4215D9BC0),

reinterpret<f64>(0x3FEC20005B46DF99), reinterpret<f64>(0x3C6BEEA653E9C1C9),

reinterpret<f64>(0x3FEC600040B9F7AE), reinterpret<f64>(0xBC7C079F274A70D6),

reinterpret<f64>(0x3FECA0006255FD8A), reinterpret<f64>(0xBC7A0B4076E84C1F),

reinterpret<f64>(0x3FECDFFFD94C095D), reinterpret<f64>(0x3C88F933F99AB5D7),

reinterpret<f64>(0x3FED1FFFF975D6CF), reinterpret<f64>(0xBC582C08665FE1BE),

reinterpret<f64>(0x3FED5FFFA2561C93), reinterpret<f64>(0xBC7B04289BD295F3),

reinterpret<f64>(0x3FED9FFF9D228B0C), reinterpret<f64>(0x3C870251340FA236),

reinterpret<f64>(0x3FEDE00065BC7E16), reinterpret<f64>(0xBC75011E16A4D80C),

reinterpret<f64>(0x3FEE200002F64791), reinterpret<f64>(0x3C89802F09EF62E0),

reinterpret<f64>(0x3FEE600057D7A6D8), reinterpret<f64>(0xBC7E0B75580CF7FA),

reinterpret<f64>(0x3FEEA00027EDC00C), reinterpret<f64>(0xBC8C848309459811),

reinterpret<f64>(0x3FEEE0006CF5CB7C), reinterpret<f64>(0xBC8F8027951576F4),

reinterpret<f64>(0x3FEF2000782B7DCC), reinterpret<f64>(0xBC8F81D97274538F),

reinterpret<f64>(0x3FEF6000260C450A), reinterpret<f64>(0xBC4071002727FFDC),

reinterpret<f64>(0x3FEF9FFFE88CD533), reinterpret<f64>(0xBC581BDCE1FDA8B0),

reinterpret<f64>(0x3FEFDFFFD50F8689), reinterpret<f64>(0x3C87F91ACB918E6E),

reinterpret<f64>(0x3FF0200004292367), reinterpret<f64>(0x3C9B7FF365324681),

reinterpret<f64>(0x3FF05FFFE3E3D668), reinterpret<f64>(0x3C86FA08DDAE957B),

reinterpret<f64>(0x3FF0A0000A85A757), reinterpret<f64>(0xBC57E2DE80D3FB91),

reinterpret<f64>(0x3FF0E0001A5F3FCC), reinterpret<f64>(0xBC91823305C5F014),

reinterpret<f64>(0x3FF11FFFF8AFBAF5), reinterpret<f64>(0xBC8BFABB6680BAC2),

reinterpret<f64>(0x3FF15FFFE54D91AD), reinterpret<f64>(0xBC9D7F121737E7EF),

reinterpret<f64>(0x3FF1A00011AC36E1), reinterpret<f64>(0x3C9C000A0516F5FF),

reinterpret<f64>(0x3FF1E00019C84248), reinterpret<f64>(0xBC9082FBE4DA5DA0),

reinterpret<f64>(0x3FF220000FFE5E6E), reinterpret<f64>(0xBC88FDD04C9CFB43),

reinterpret<f64>(0x3FF26000269FD891), reinterpret<f64>(0x3C8CFE2A7994D182),

reinterpret<f64>(0x3FF2A00029A6E6DA), reinterpret<f64>(0xBC700273715E8BC5),

reinterpret<f64>(0x3FF2DFFFE0293E39), reinterpret<f64>(0x3C9B7C39DAB2A6F9),

reinterpret<f64>(0x3FF31FFFF7DCF082), reinterpret<f64>(0x3C7DF1336EDC5254),

reinterpret<f64>(0x3FF35FFFF05A8B60), reinterpret<f64>(0xBC9E03564CCD31EB),

reinterpret<f64>(0x3FF3A0002E0EAECC), reinterpret<f64>(0x3C75F0E74BD3A477),

reinterpret<f64>(0x3FF3E000043BB236), reinterpret<f64>(0x3C9C7DCB149D8833),

reinterpret<f64>(0x3FF4200002D187FF), reinterpret<f64>(0x3C7E08AFCF2D3D28),

reinterpret<f64>(0x3FF460000D387CB1), reinterpret<f64>(0x3C820837856599A6),

reinterpret<f64>(0x3FF4A00004569F89), reinterpret<f64>(0xBC89FA5C904FBCD2),

reinterpret<f64>(0x3FF4E000043543F3), reinterpret<f64>(0xBC781125ED175329),

reinterpret<f64>(0x3FF51FFFCC027F0F), reinterpret<f64>(0x3C9883D8847754DC),

reinterpret<f64>(0x3FF55FFFFD87B36F), reinterpret<f64>(0xBC8709E731D02807),

reinterpret<f64>(0x3FF59FFFF21DF7BA), reinterpret<f64>(0x3C87F79F68727B02),

reinterpret<f64>(0x3FF5DFFFEBFC3481), reinterpret<f64>(0xBC9180902E30E93E)

]);

// @ts-ignore: decorator

@inline

export function log2_lut(x: f64): f64 {

const N_MASK = (1 << LOG2_TABLE_BITS) - 1;

const

LO: u64 = 0x3FEEA4AF00000000, // reinterpret<u64>(1.0 - 0x1.5b51p-5)

HI: u64 = 0x3FF0B55900000000; // reinterpret<u64>(1.0 + 0x1.6ab2p-5)

const

InvLn2hi = reinterpret<f64>(0x3FF7154765200000), // 0x1.7154765200000p+0

InvLn2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33

Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52

const

B0 = reinterpret<f64>(0xBFE71547652B82FE), // -0x1.71547652b82fep-1

B1 = reinterpret<f64>(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2

B2 = reinterpret<f64>(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2

B3 = reinterpret<f64>(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2

B4 = reinterpret<f64>(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3

B5 = reinterpret<f64>(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3

B6 = reinterpret<f64>(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3

B7 = reinterpret<f64>(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3

B8 = reinterpret<f64>(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3

B9 = reinterpret<f64>(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3

const

A0 = reinterpret<f64>(0xBFE71547652B8339), // -0x1.71547652b8339p-1

A1 = reinterpret<f64>(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2

A2 = reinterpret<f64>(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2

A3 = reinterpret<f64>(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2