math.ts

import{MathasJSMath}from"./bindings/dom";
export{JSMath};

import{
pow_lut,exp_lut,exp2_lut,log_lut,log2_lut,
powf_lut,expf_lut,exp2f_lut,logf_lut,log2f_lut
}from"./util/math";

import{
absasbuiltin_abs,
ceilasbuiltin_ceil,
clzasbuiltin_clz,
copysignasbuiltin_copysign,
floorasbuiltin_floor,
maxasbuiltin_max,
minasbuiltin_min,
sqrtasbuiltin_sqrt,
truncasbuiltin_trunc
}from"./builtins";

// SUN COPYRIGHT NOTICE
//
// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
// Developed at SunPro, a Sun Microsystems, Inc. business.
// Permission to use, copy, modify, and distribute this software
// is freely granted, provided that this notice is preserved.
//
// Applies to all functions marked with a comment referring here.

/** @internal */
// @ts-ignore: decorator
@lazyletrempio2_y0: f64,rempio2_y1: f64,res128_hi: u64;

/** @internal */
// @ts-ignore: decorator
@lazy @inlineconstPIO2_TABLE=memory.data<u64>([
0x00000000A2F9836E,0x4E441529FC2757D1,0xF534DDC0DB629599,0x3C439041FE5163AB,
0xDEBBC561B7246E3A,0x424DD2E006492EEA,0x09D1921CFE1DEB1C,0xB129A73EE88235F5,
0x2EBB4484E99C7026,0xB45F7E413991D639,0x835339F49C845F8B,0xBDF9283B1FF897FF,
0xDE05980FEF2F118B,0x5A0A6D1F6D367ECF,0x27CB09B74F463F66,0x9E5FEA2D7527BAC7,
0xEBE5F17B3D0739F7,0x8A5292EA6BFB5FB1,0x1F8D5D0856033046,0xFC7B6BABF0CFBC20,
0x9AF4361DA9E39161,0x5EE61B086599855F,0x14A068408DFFD880,0x4D73273106061557
]);

/** @internal */
functionR(z: f64): f64{// Rational approximation of (asin(x)-x)/x^3
const// see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above
pS0=reinterpret<f64>(0x3FC5555555555555),// 1.66666666666666657415e-01
pS1=reinterpret<f64>(0xBFD4D61203EB6F7D),// -3.25565818622400915405e-01
pS2=reinterpret<f64>(0x3FC9C1550E884455),// 2.01212532134862925881e-01
pS3=reinterpret<f64>(0xBFA48228B5688F3B),// -4.00555345006794114027e-02
pS4=reinterpret<f64>(0x3F49EFE07501B288),// 7.91534994289814532176e-04
pS5=reinterpret<f64>(0x3F023DE10DFDF709),// 3.47933107596021167570e-05
qS1=reinterpret<f64>(0xC0033A271C8A2D4B),// -2.40339491173441421878e+00
qS2=reinterpret<f64>(0x40002AE59C598AC8),// 2.02094576023350569471e+00
qS3=reinterpret<f64>(0xBFE6066C1B8D0159),// -6.88283971605453293030e-01
qS4=reinterpret<f64>(0x3FB3B8C5B12E9282);// 7.70381505559019352791e-02

letp=z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
letq=1.0+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
returnp/q;
}

/** @internal */
// @ts-ignore: decorator
@inline
functionexpo2(x: f64,sign: f64): f64{// exp(x)/2 for x >= log(DBL_MAX)
const// see: musl/src/math/__expo2.c
k=<u32>2043,
kln2=reinterpret<f64>(0x40962066151ADD8B);// 0x1.62066151add8bp+10
letscale=reinterpret<f64>(<u64>((<u32>0x3FF+k/2)<<20)<<32);
// in directed rounding correct sign before rounding or overflow is important
returnNativeMath.exp(x-kln2)*(sign*scale)*scale;
}

/** @internal */
/* Helper function to eventually get bits of π/2 * |x|
 *
 * y = π/4 * (frac << clz(frac) >> 11)
 * return clz(frac)
 *
 * Right shift 11 bits to make upper half fit in `double`
 */
// @ts-ignore: decorator
@inline
functionpio2_right(q0: u64,q1: u64): u64{// see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c
// Bits of π/4
constp0: u64=0xC4C6628B80DC1CD1;
constp1: u64=0xC90FDAA22168C234;

constOx1p_64=reinterpret<f64>(0x3BF0000000000000);// 0x1p-64
constOx1p_75=reinterpret<f64>(0x3B40000000000000);// 0x1p-75

letshift=clz(q1);

q1=q1<<shift|q0>>(64-shift);
q0<<=shift;

letlo=umuldi(p1,q1);
lethi=res128_hi;

letahi=hi>>11;
letalo=lo>>11|hi<<53;
letblo=<u64>(Ox1p_75*<f64>p0*<f64>q1+Ox1p_75*<f64>p1*<f64>q0);

rempio2_y0=<f64>(ahi+u64(lo<blo));
rempio2_y1=Ox1p_64*<f64>(alo+blo);

returnshift;
}

/** @internal */
// @ts-ignore: decorator
@inline
functionumuldi(u: u64,v: u64): u64{
letu1: u64,v1: u64,w0: u64,w1: u64,t: u64;

u1=u&0xFFFFFFFF;
v1=v&0xFFFFFFFF;

u>>=32;
v>>=32;

t=u1*v1;
w0=t&0xFFFFFFFF;
t=u*v1+(t>>32);
w1=t>>32;
t=u1*v+(t&0xFFFFFFFF);

res128_hi=u*v+w1+(t>>32);
return(t<<32)+w0;
}

/** @internal */
functionpio2_large_quot(x: f64,u: i64): i32{// see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c
letmagnitude=u&0x7FFFFFFFFFFFFFFF;
letoffset=(magnitude>>52)-1045;
letshift=offset&63;
lettblPtr=PIO2_TABLE+(<i32>(offset>>6)<<3);
lets0: u64,s1: u64,s2: u64;

letb0=load<u64>(tblPtr,0<<3);
letb1=load<u64>(tblPtr,1<<3);
letb2=load<u64>(tblPtr,2<<3);

// Get 192 bits of 0x1p-31 / π with `offset` bits skipped
if(shift){
letrshift=64-shift;
letb3=load<u64>(tblPtr,3<<3);
s0=b1>>rshift|b0<<shift;
s1=b2>>rshift|b1<<shift;
s2=b3>>rshift|b2<<shift;
}else{
s0=b0;
s1=b1;
s2=b2;
}

letsignificand=(u&0x000FFFFFFFFFFFFF)|0x0010000000000000;

// First 128 bits of fractional part of x/(2π)
letblo=umuldi(s1,significand);
letbhi=res128_hi;

letahi=s0*significand;
letclo=(s2>>32)*(significand>>32);
letplo=blo+clo;
letphi=ahi+bhi+u64(plo<clo);

// r: u128 = p << 2
letrlo=plo<<2;
letrhi=phi<<2|plo>>62;

// s: i128 = r >> 127
letslo=<i64>rhi>>63;
letshi=slo>>1;
letq=(<i64>phi>>62)-slo;

letshifter=0x3CB0000000000000-(pio2_right(rlo^slo,rhi^shi)<<52);
letsignbit=(u^rhi)&0x8000000000000000;
letcoeff=reinterpret<f64>(shifter|signbit);

rempio2_y0*=coeff;
rempio2_y1*=coeff;

return<i32>q;
}

/** @internal */
// @ts-ignore: decorator
@inline
functionrempio2(x: f64,u: u64,sign: i32): i32{
const
pio2_1=reinterpret<f64>(0x3FF921FB54400000),// 1.57079632673412561417e+00
pio2_1t=reinterpret<f64>(0x3DD0B4611A626331),// 6.07710050650619224932e-11
pio2_2=reinterpret<f64>(0x3DD0B4611A600000),// 6.07710050630396597660e-11
pio2_2t=reinterpret<f64>(0x3BA3198A2E037073),// 2.02226624879595063154e-21
pio2_3=reinterpret<f64>(0x3BA3198A2E000000),// 2.02226624871116645580e-21
pio2_3t=reinterpret<f64>(0x397B839A252049C1),// 8.47842766036889956997e-32
invpio2=reinterpret<f64>(0x3FE45F306DC9C883);// 0.63661977236758134308

letix=<u32>(u>>32)&0x7FFFFFFF;

if(ASC_SHRINK_LEVEL<1){
if(ix<0x4002D97C){// |x| < 3pi/4, special case with n=+-1
letq=1,z: f64,y0: f64,y1: f64;
if(!sign){
z=x-pio2_1;
if(ix!=0x3FF921FB){// 33+53 bit pi is good enough
y0=z-pio2_1t;
y1=(z-y0)-pio2_1t;
}else{// near pi/2, use 33+33+53 bit pi
z-=pio2_2;
y0=z-pio2_2t;
y1=(z-y0)-pio2_2t;
}
}else{// negative x
z=x+pio2_1;
if(ix!=0x3FF921FB){// 33+53 bit pi is good enough
y0=z+pio2_1t;
y1=(z-y0)+pio2_1t;
}else{// near pi/2, use 33+33+53 bit pi
z+=pio2_2;
y0=z+pio2_2t;
y1=(z-y0)+pio2_2t;
}
q=-1;
}
rempio2_y0=y0;
rempio2_y1=y1;
returnq;
}
}

if(ix<0x413921FB){// |x| ~< 2^20*pi/2 (1647099)
// Use precise Cody Waite scheme
letq=nearest(x*invpio2);
letr=x-q*pio2_1;
letw=q*pio2_1t;// 1st round good to 85 bit
letj=ix>>20;
lety0=r-w;
lethi=<u32>(reinterpret<u64>(y0)>>32);
leti=j-((hi>>20)&0x7FF);

if(i>16){// 2nd iteration needed, good to 118
lett=r;
w=q*pio2_2;
r=t-w;
w=q*pio2_2t-((t-r)-w);
y0=r-w;
hi=<u32>(reinterpret<u64>(y0)>>32);
i=j-((hi>>20)&0x7FF);
if(i>49){// 3rd iteration need, 151 bits acc
lett=r;
w=q*pio2_3;
r=t-w;
w=q*pio2_3t-((t-r)-w);
y0=r-w;
}
}
lety1=(r-y0)-w;
rempio2_y0=y0;
rempio2_y1=y1;
return<i32>q;
}
letq=pio2_large_quot(x,u);
returnselect(-q,q,sign);
}

/** @internal */
// @ts-ignore: decorator
@inline
functionsin_kern(x: f64,y: f64,iy: i32): f64{// see: musl/tree/src/math/__sin.c
const
S1=reinterpret<f64>(0xBFC5555555555549),// -1.66666666666666324348e-01
S2=reinterpret<f64>(0x3F8111111110F8A6),// 8.33333333332248946124e-03
S3=reinterpret<f64>(0xBF2A01A019C161D5),// -1.98412698298579493134e-04
S4=reinterpret<f64>(0x3EC71DE357B1FE7D),// 2.75573137070700676789e-06
S5=reinterpret<f64>(0xBE5AE5E68A2B9CEB),// -2.50507602534068634195e-08
S6=reinterpret<f64>(0x3DE5D93A5ACFD57C);// 1.58969099521155010221e-10

letz=x*x;
letw=z*z;
letr=S2+z*(S3+z*S4)+z*w*(S5+z*S6);
letv=z*x;
if(!iy){
returnx+v*(S1+z*r);
}else{
returnx-((z*(0.5*y-v*r)-y)-v*S1);
}
}

/** @internal */
// @ts-ignore: decorator
@inline
functioncos_kern(x: f64,y: f64): f64{// see: musl/tree/src/math/__cos.c
const
C1=reinterpret<f64>(0x3FA555555555554C),// 4.16666666666666019037e-02
C2=reinterpret<f64>(0xBF56C16C16C15177),// -1.38888888888741095749e-03
C3=reinterpret<f64>(0x3EFA01A019CB1590),// 2.48015872894767294178e-05
C4=reinterpret<f64>(0xBE927E4F809C52AD),// -2.75573143513906633035e-07
C5=reinterpret<f64>(0x3E21EE9EBDB4B1C4),// 2.08757232129817482790e-09
C6=reinterpret<f64>(0xBDA8FAE9BE8838D4);// -1.13596475577881948265e-11

letz=x*x;
letw=z*z;
letr=z*(C1+z*(C2+z*C3))+w*w*(C4+z*(C5+z*C6));
lethz=0.5*z;
w=1.0-hz;
returnw+(((1.0-w)-hz)+(z*r-x*y));
}

/** @internal */
functiontan_kern(x: f64,y: f64,iy: i32): f64{// see: src/lib/msun/src/k_tan.c
const
T0=reinterpret<f64>(0x3FD5555555555563),// 3.33333333333334091986e-01
T1=reinterpret<f64>(0x3FC111111110FE7A),// 1.33333333333201242699e-01
T2=reinterpret<f64>(0x3FABA1BA1BB341FE),// 5.39682539762260521377e-02
T3=reinterpret<f64>(0x3F9664F48406D637),// 2.18694882948595424599e-02
T4=reinterpret<f64>(0x3F8226E3E96E8493),// 8.86323982359930005737e-03
T5=reinterpret<f64>(0x3F6D6D22C9560328),// 3.59207910759131235356e-03
T6=reinterpret<f64>(0x3F57DBC8FEE08315),// 1.45620945432529025516e-03
T7=reinterpret<f64>(0x3F4344D8F2F26501),// 5.88041240820264096874e-04
T8=reinterpret<f64>(0x3F3026F71A8D1068),// 2.46463134818469906812e-04
T9=reinterpret<f64>(0x3F147E88A03792A6),// 7.81794442939557092300e-05
T10=reinterpret<f64>(0x3F12B80F32F0A7E9),// 7.14072491382608190305e-05
T11=reinterpret<f64>(0xBEF375CBDB605373),// -1.85586374855275456654e-05
T12=reinterpret<f64>(0x3EFB2A7074BF7AD4);// 2.59073051863633712884e-05

const
one=reinterpret<f64>(0x3FF0000000000000),// 1.00000000000000000000e+00
pio4=reinterpret<f64>(0x3FE921FB54442D18),// 7.85398163397448278999e-01
pio4lo=reinterpret<f64>(0x3C81A62633145C07);// 3.06161699786838301793e-17

letz: f64,r: f64,v: f64,w: f64,s: f64;
lethx=<i32>(reinterpret<u64>(x)>>32);// high word of x
letix=hx&0x7FFFFFFF;// high word of |x|
letbig=ix>=0x3FE59428;
if(big){// |x| >= 0.6744
if(hx<0){x=-x,y=-y;}
z=pio4-x;
w=pio4lo-y;
x=z+w;
y=0.0;
}
z=x*x;
w=z*z;
r=T1+w*(T3+w*(T5+w*(T7+w*(T9+w*T11))));
v=z*(T2+w*(T4+w*(T6+w*(T8+w*(T10+w*T12)))));
s=z*x;
r=y+z*(s*(r+v)+y);
r+=T0*s;
w=x+r;
if(big){
v=iy;
return(1-((hx>>30)&2))*(v-2.0*(x-(w*w/(w+v)-r)));
}
if(iy==1)returnw;
leta: f64,t: f64;
z=w;
z=reinterpret<f64>(reinterpret<u64>(z)&0xFFFFFFFF00000000);
v=r-(z-x);// z + v = r + x
t=a=-one/w;// a = -1.0 / w
t=reinterpret<f64>(reinterpret<u64>(t)&0xFFFFFFFF00000000);
s=one+t*z;
returnt+a*(s+t*v);
}

/** @internal */
functiondtoi32(x: f64): i32{
if(ASC_SHRINK_LEVEL>0){
constinv32=1.0/4294967296;
return<i32><i64>(x-4294967296*floor(x*inv32));
}else{
letresult=0;
letu=reinterpret<u64>(x);
lete=(u>>52)&0x7FF;
if(e<=1023+30){
result=<i32>x;
}elseif(e<=1023+30+53){
letv=(u&((<u64>1<<52)-1))|(<u64>1<<52);
v=v<<e-1023-52+32;
result=<i32>(v>>32);
result=select<i32>(-result,result,<i64>u<0);
}
returnresult;
}
}

// @ts-ignore: decorator
@lazyletrandom_seeded=false;

// @ts-ignore: decorator
@lazyletrandom_state0_64: u64,random_state1_64: u64;

// @ts-ignore: decorator
@lazyletrandom_state0_32: u32,random_state1_32: u32;

functionmurmurHash3(h: u64): u64{// Force all bits of a hash block to avalanche
h^=h>>33;// see: https://github.com/aappleby/smhasher
h*=0xFF51AFD7ED558CCD;
h^=h>>33;
h*=0xC4CEB9FE1A85EC53;
h^=h>>33;
returnh;
}

functionsplitMix32(h: u32): u32{
h+=0x6D2B79F5;
h=(h^(h>>15))*(h|1);
h^=h+(h^(h>>7))*(h|61);
returnh^(h>>14);
}

exportnamespaceNativeMath{

// @ts-ignore: decorator
 @lazy
exportconstE=reinterpret<f64>(0x4005BF0A8B145769);// 2.7182818284590452354

// @ts-ignore: decorator
 @lazy
exportconstLN2=reinterpret<f64>(0x3FE62E42FEFA39EF);// 0.69314718055994530942

// @ts-ignore: decorator
 @lazy
exportconstLN10=reinterpret<f64>(0x40026BB1BBB55516);// 2.30258509299404568402

// @ts-ignore: decorator
 @lazy
exportconstLOG2E=reinterpret<f64>(0x3FF71547652B82FE);// 1.4426950408889634074

// @ts-ignore: decorator
 @lazy
exportconstLOG10E=reinterpret<f64>(0x3FDBCB7B1526E50E);// 0.43429448190325182765

// @ts-ignore: decorator
 @lazy
exportconstPI=reinterpret<f64>(0x400921FB54442D18);// 3.14159265358979323846

// @ts-ignore: decorator
 @lazy
exportconstSQRT1_2=reinterpret<f64>(0x3FE6A09E667F3BCD);// 0.70710678118654752440

// @ts-ignore: decorator
 @lazy
exportconstSQRT2=reinterpret<f64>(0x3FF6A09E667F3BCD);// 1.41421356237309504880

// @ts-ignore: decorator
 @lazy
exportletsincos_sin: f64=0;

// @ts-ignore: decorator
 @lazy
exportletsincos_cos: f64=0;

// @ts-ignore: decorator
 @inlineexportfunctionabs(x: f64): f64{
returnbuiltin_abs<f64>(x);
}

exportfunctionacos(x: f64): f64{// see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above
const
pio2_hi=reinterpret<f64>(0x3FF921FB54442D18),// 1.57079632679489655800e+00
pio2_lo=reinterpret<f64>(0x3C91A62633145C07),// 6.12323399573676603587e-17
Ox1p_120f=reinterpret<f32>(0x03800000);

lethx=<u32>(reinterpret<u64>(x)>>32);
letix=hx&0x7FFFFFFF;
if(ix>=0x3FF00000){
letlx=<u32>reinterpret<u64>(x);
if((ix-0x3FF00000|lx)==0){
if(<i32>hx<0)return2*pio2_hi+Ox1p_120f;
return0;
}
return0/(x-x);
}
if(ix<0x3FE00000){
if(ix<=0x3C600000)returnpio2_hi+Ox1p_120f;
returnpio2_hi-(x-(pio2_lo-x*R(x*x)));
}
lets: f64,w: f64,z: f64;
if(<i32>hx<0){
// z = (1.0 + x) * 0.5;
z=0.5+x*0.5;
s=builtin_sqrt<f64>(z);
w=R(z)*s-pio2_lo;
return2*(pio2_hi-(s+w));
}
// z = (1.0 - x) * 0.5;
z=0.5-x*0.5;
s=builtin_sqrt<f64>(z);
letdf=reinterpret<f64>(reinterpret<u64>(s)&0xFFFFFFFF00000000);
letc=(z-df*df)/(s+df);
w=R(z)*s+c;
return2*(df+w);
}

exportfunctionacosh(x: f64): f64{// see: musl/src/math/acosh.c
consts=reinterpret<f64>(0x3FE62E42FEFA39EF);
letu=reinterpret<u64>(x);
// Prevent propagation for all input values less than 1.0.
// Note musl lib didn't fix this yet.
if(<i64>u<0x3FF0000000000000)return(x-x)/0.0;
lete=u>>52&0x7FF;
if(e<0x3FF+1)returnlog1p(x-1+builtin_sqrt<f64>((x-1)*(x-1)+2*(x-1)));
if(e<0x3FF+26)returnlog(2*x-1/(x+builtin_sqrt<f64>(x*x-1)));
returnlog(x)+s;
}

exportfunctionasin(x: f64): f64{// see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above
const
pio2_hi=reinterpret<f64>(0x3FF921FB54442D18),// 1.57079632679489655800e+00
pio2_lo=reinterpret<f64>(0x3C91A62633145C07),// 6.12323399573676603587e-17
Ox1p_120f=reinterpret<f32>(0x03800000);

lethx=<u32>(reinterpret<u64>(x)>>32);
letix=hx&0x7FFFFFFF;
if(ix>=0x3FF00000){
letlx=<u32>reinterpret<u64>(x);
if((ix-0x3FF00000|lx)==0)returnx*pio2_hi+Ox1p_120f;
return0/(x-x);
}
if(ix<0x3FE00000){
if(ix<0x3E500000&&ix>=0x00100000)returnx;
returnx+x*R(x*x);
}
// let z = (1.0 - builtin_abs<f64>(x)) * 0.5;
letz=0.5-builtin_abs<f64>(x)*0.5;
lets=builtin_sqrt<f64>(z);
letr=R(z);
if(ix>=0x3FEF3333)x=pio2_hi-(2*(s+s*r)-pio2_lo);
else{
letf=reinterpret<f64>(reinterpret<u64>(s)&0xFFFFFFFF00000000);
letc=(z-f*f)/(s+f);
x=0.5*pio2_hi-(2*s*r-(pio2_lo-2*c)-(0.5*pio2_hi-2*f));
}
returnselect(-x,x,<i32>hx<0);
}

exportfunctionasinh(x: f64): f64{// see: musl/src/math/asinh.c
constc=reinterpret<f64>(0x3FE62E42FEFA39EF);// 0.693147180559945309417232121458176568
letu=reinterpret<u64>(x);
lete=u>>52&0x7FF;
lety=reinterpret<f64>(u&0x7FFFFFFFFFFFFFFF);
if(e>=0x3FF+26)y=log(y)+c;
elseif(e>=0x3FF+1)y=log(2*y+1/(builtin_sqrt<f64>(y*y+1)+y));
elseif(e>=0x3FF-26)y=log1p(y+y*y/(builtin_sqrt<f64>(y*y+1)+1));
returnbuiltin_copysign(y,x);
}

exportfunctionatan(x: f64): f64{// see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above
const
atanhi0=reinterpret<f64>(0x3FDDAC670561BB4F),// 4.63647609000806093515e-01
atanhi1=reinterpret<f64>(0x3FE921FB54442D18),// 7.85398163397448278999e-01
atanhi2=reinterpret<f64>(0x3FEF730BD281F69B),// 9.82793723247329054082e-01
atanhi3=reinterpret<f64>(0x3FF921FB54442D18),// 1.57079632679489655800e+00
atanlo0=reinterpret<f64>(0x3C7A2B7F222F65E2),// 2.26987774529616870924e-17
atanlo1=reinterpret<f64>(0x3C81A62633145C07),// 3.06161699786838301793e-17
atanlo2=reinterpret<f64>(0x3C7007887AF0CBBD),// 1.39033110312309984516e-17
atanlo3=reinterpret<f64>(0x3C91A62633145C07),// 6.12323399573676603587e-17
aT0=reinterpret<f64>(0x3FD555555555550D),// 3.33333333333329318027e-01
aT1=reinterpret<f64>(0xBFC999999998EBC4),// -1.99999999998764832476e-01
aT2=reinterpret<f64>(0x3FC24924920083FF),// 1.42857142725034663711e-01
aT3=reinterpret<f64>(0xBFBC71C6FE231671),// -1.11111104054623557880e-01,
aT4=reinterpret<f64>(0x3FB745CDC54C206E),// 9.09088713343650656196e-02
aT5=reinterpret<f64>(0xBFB3B0F2AF749A6D),// -7.69187620504482999495e-02
aT6=reinterpret<f64>(0x3FB10D66A0D03D51),// 6.66107313738753120669e-02
aT7=reinterpret<f64>(0xBFADDE2D52DEFD9A),// -5.83357013379057348645e-02
aT8=reinterpret<f64>(0x3FA97B4B24760DEB),// 4.97687799461593236017e-02
aT9=reinterpret<f64>(0xBFA2B4442C6A6C2F),// -3.65315727442169155270e-02
aT10=reinterpret<f64>(0x3F90AD3AE322DA11),// 1.62858201153657823623e-02
Ox1p_120f=reinterpret<f32>(0x03800000);

letix=<u32>(reinterpret<u64>(x)>>32);
letsx=x;
ix&=0x7FFFFFFF;
letz: f64;
if(ix>=0x44100000){
if(isNaN(x))returnx;
z=atanhi3+Ox1p_120f;
returnbuiltin_copysign<f64>(z,sx);
}
letid: i32;
if(ix<0x3FDC0000){
if(ix<0x3E400000)returnx;
id=-1;
}else{
x=builtin_abs<f64>(x);
if(ix<0x3FF30000){
if(ix<0x3FE60000){
id=0;
x=(2.0*x-1.0)/(2.0+x);
}else{
id=1;
x=(x-1.0)/(x+1.0);
}
}else{
if(ix<0x40038000){
id=2;
x=(x-1.5)/(1.0+1.5*x);
}else{
id=3;
x=-1.0/x;
}
}
}
z=x*x;
letw=z*z;
lets1=z*(aT0+w*(aT2+w*(aT4+w*(aT6+w*(aT8+w*aT10)))));
lets2=w*(aT1+w*(aT3+w*(aT5+w*(aT7+w*aT9))));
lets3=x*(s1+s2);
if(id<0)returnx-s3;
switch(id){
case0: {z=atanhi0-((s3-atanlo0)-x);break;}
case1: {z=atanhi1-((s3-atanlo1)-x);break;}
case2: {z=atanhi2-((s3-atanlo2)-x);break;}
case3: {z=atanhi3-((s3-atanlo3)-x);break;}
default: unreachable();
}
returnbuiltin_copysign<f64>(z,sx);
}

exportfunctionatanh(x: f64): f64{// see: musl/src/math/atanh.c
letu=reinterpret<u64>(x);
lete=u>>52&0x7FF;
lety=builtin_abs(x);
if(e<0x3FF-1){
if(e>=0x3FF-32)y=0.5*log1p(2*y+2*y*y/(1-y));
}else{
y=0.5*log1p(2*(y/(1-y)));
}
returnbuiltin_copysign<f64>(y,x);
}

exportfunctionatan2(y: f64,x: f64): f64{// see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above
constpi_lo=reinterpret<f64>(0x3CA1A62633145C07);// 1.2246467991473531772E-16
if(isNaN(x)||isNaN(y))returnx+y;
letu=reinterpret<u64>(x);
letix=<u32>(u>>32);
letlx=<u32>u;
u=reinterpret<u64>(y);
letiy=<u32>(u>>32);
letly=<u32>u;
if((ix-0x3FF00000|lx)==0)returnatan(y);
letm=((iy>>31)&1)|((ix>>30)&2);
ix=ix&0x7FFFFFFF;
iy=iy&0x7FFFFFFF;
if((iy|ly)==0){
switch(m){
case0:
case1: returny;
case2: returnPI;
case3: return-PI;
}
}
if((ix|lx)==0)returnm&1 ? -PI/2 : PI/2;
if(ix==0x7FF00000){
if(iy==0x7FF00000){
lett=m&2 ? 3*PI/4 : PI/4;
returnm&1 ? -t : t;
}else{
lett=m&2 ? PI : 0;
returnm&1 ? -t : t;
}
}
letz: f64;
if(ix+(64<<20)<iy||iy==0x7FF00000)returnm&1 ? -PI/2 : PI/2;
if((m&2)&&iy+(64<<20)<ix)z=0;
elsez=atan(builtin_abs<f64>(y/x));
switch(m){
case0: returnz;
case1: return-z;
case2: returnPI-(z-pi_lo);
case3: return(z-pi_lo)-PI;
}
unreachable();
return0;
}

exportfunctioncbrt(x: f64): f64{// see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above
const
B1=<u32>715094163,
B2=<u32>696219795,
P0=reinterpret<f64>(0x3FFE03E60F61E692),// 1.87595182427177009643
P1=reinterpret<f64>(0xBFFE28E092F02420),// -1.88497979543377169875
P2=reinterpret<f64>(0x3FF9F1604A49D6C2),// 1.621429720105354466140
P3=reinterpret<f64>(0xBFE844CBBEE751D9),// -0.758397934778766047437
P4=reinterpret<f64>(0x3FC2B000D4E4EDD7),// 0.145996192886612446982
Ox1p54=reinterpret<f64>(0x4350000000000000);// 0x1p54

letu=reinterpret<u64>(x);
lethx=<u32>(u>>32)&0x7FFFFFFF;
if(hx>=0x7FF00000)returnx+x;
if(hx<0x00100000){
u=reinterpret<u64>(x*Ox1p54);
hx=<u32>(u>>32)&0x7FFFFFFF;
if(hx==0)returnx;
hx=hx/3+B2;
}else{
hx=hx/3+B1;
}
u&=1<<63;
u|=<u64>hx<<32;
lett=reinterpret<f64>(u);
letr=(t*t)*(t/x);
t=t*((P0+r*(P1+r*P2))+((r*r)*r)*(P3+r*P4));
t=reinterpret<f64>((reinterpret<u64>(t)+0x80000000)&0xFFFFFFFFC0000000);
lets=t*t;
r=x/s;
r=(r-t)/(2*t+r);
t=t+t*r;
returnt;
}

// @ts-ignore: decorator
 @inline
exportfunctionceil(x: f64): f64{
returnbuiltin_ceil<f64>(x);
}

exportfunctionclz32(x: f64): f64{
if(!isFinite(x))return32;
/*
 * Wasm (MVP) and JS have different approaches for double->int conversions.
 *
 * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT
 * our float-point arguments before actual convertion to integers.
 */
returnbuiltin_clz(dtoi32(x));
}

exportfunctioncos(x: f64): f64{// see: musl/src/math/cos.c
letu=reinterpret<u64>(x);
letux=u32(u>>32);
letsign=ux>>31;

ux&=0x7FFFFFFF;

// |x| ~< pi/4
if(ux<=0x3FE921FB){
if(ux<0x3E46A09E){// |x| < 2**-27 * sqrt(2)
return1.0;
}
returncos_kern(x,0);
}

// sin(Inf or NaN) is NaN
if(ux>=0x7FF00000)returnx-x;

// argument reduction needed
letn=rempio2(x,u,sign);
lety0=rempio2_y0;
lety1=rempio2_y1;

x=n&1 ? sin_kern(y0,y1,1) : cos_kern(y0,y1);
return(n+1)&2 ? -x : x;
}

exportfunctioncosh(x: f64): f64{// see: musl/src/math/cosh.c
letu=reinterpret<u64>(x);
u&=0x7FFFFFFFFFFFFFFF;
x=reinterpret<f64>(u);
letw=<u32>(u>>32);
lett: f64;
if(w<0x3FE62E42){
if(w<0x3FF00000-(26<<20))return1;
t=expm1(x);
// return 1 + t * t / (2 * (1 + t));
return1+t*t/(2+2*t);
}
if(w<0x40862E42){
t=exp(x);
return0.5*(t+1/t);
}
t=expo2(x,1);
returnt;
}

exportfunctionexp(x: f64): f64{// see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above
if(ASC_SHRINK_LEVEL<1){
returnexp_lut(x);
}else{
const
ln2hi=reinterpret<f64>(0x3FE62E42FEE00000),// 6.93147180369123816490e-01
ln2lo=reinterpret<f64>(0x3DEA39EF35793C76),// 1.90821492927058770002e-10
invln2=reinterpret<f64>(0x3FF71547652B82FE),// 1.44269504088896338700e+00
P1=reinterpret<f64>(0x3FC555555555553E),// 1.66666666666666019037e-01
P2=reinterpret<f64>(0xBF66C16C16BEBD93),// -2.77777777770155933842e-03
P3=reinterpret<f64>(0x3F11566AAF25DE2C),// 6.61375632143793436117e-05
P4=reinterpret<f64>(0xBEBBBD41C5D26BF1),// -1.65339022054652515390e-06
P5=reinterpret<f64>(0x3E66376972BEA4D0),// 4.13813679705723846039e-08
overflow=reinterpret<f64>(0x40862E42FEFA39EF),// 709.782712893383973096
underflow=reinterpret<f64>(0xC0874910D52D3051),// -745.13321910194110842
Ox1p1023=reinterpret<f64>(0x7FE0000000000000);// 0x1p1023

lethx=u32(reinterpret<u64>(x)>>32);
letsign=hx>>31;
hx&=0x7FFFFFFF;
if(hx>=0x4086232B){
if(isNaN(x))returnx;
if(x>overflow)returnx*Ox1p1023;
if(x<underflow)return0;
}
lethi: f64,lo: f64=0;
letk=0;
if(hx>0x3FD62E42){
if(hx>=0x3FF0A2B2){
k=i32(invln2*x+builtin_copysign<f64>(0.5,x));
}else{
k=1-(sign<<1);
}
hi=x-k*ln2hi;
lo=k*ln2lo;
x=hi-lo;
}elseif(hx>0x3E300000){
hi=x;
}elsereturn1.0+x;
letxs=x*x;
// let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));
letxq=xs*xs;
letc=x-(xs*P1+xq*((P2+xs*P3)+xq*(P4+xs*P5)));
lety=1.0+(x*c/(2-c)-lo+hi);
returnk==0 ? y : scalbn(y,k);
}
}

exportfunctionexp2(x: f64): f64{
returnexp2_lut(x);
}

exportfunctionexpm1(x: f64): f64{// see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above
const
o_threshold=reinterpret<f64>(0x40862E42FEFA39EF),// 7.09782712893383973096e+02
ln2_hi=reinterpret<f64>(0x3FE62E42FEE00000),// 6.93147180369123816490e-01
ln2_lo=reinterpret<f64>(0x3DEA39EF35793C76),// 1.90821492927058770002e-10
invln2=reinterpret<f64>(0x3FF71547652B82FE),// 1.44269504088896338700e+00
Q1=reinterpret<f64>(0xBFA11111111110F4),// -3.33333333333331316428e-02
Q2=reinterpret<f64>(0x3F5A01A019FE5585),// 1.58730158725481460165e-03
Q3=reinterpret<f64>(0xBF14CE199EAADBB7),// -7.93650757867487942473e-05
Q4=reinterpret<f64>(0x3ED0CFCA86E65239),// 4.00821782732936239552e-06
Q5=reinterpret<f64>(0xBE8AFDB76E09C32D),// -2.01099218183624371326e-07
Ox1p1023=reinterpret<f64>(0x7FE0000000000000);// 0x1p1023

letu=reinterpret<u64>(x);
lethx=u32(u>>32)&0x7FFFFFFF;
letsign=u32(u>>63);
letk=0;
if(hx>=0x4043687A){
if(isNaN(x))returnx;
if(sign)return-1;
if(x>o_threshold)returnx*Ox1p1023;
}
letc=0.0,t: f64;
if(hx>0x3FD62E42){
k=select<i32>(
1-(sign<<1),
i32(invln2*x+builtin_copysign<f64>(0.5,x)),
hx<0x3FF0A2B2
);
t=<f64>k;
lethi=x-t*ln2_hi;
letlo=t*ln2_lo;
x=hi-lo;
c=(hi-x)-lo;
}elseif(hx<0x3C900000)returnx;
lethfx=0.5*x;
lethxs=x*hfx;
// let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));
lethxq=hxs*hxs;
letr1=(1.0+hxs*Q1)+hxq*((Q2+hxs*Q3)+hxq*(Q4+hxs*Q5));
t=3.0-r1*hfx;
lete=hxs*((r1-t)/(6.0-x*t));
if(k==0)returnx-(x*e-hxs);
e=x*(e-c)-c;
e-=hxs;
if(k==-1)return0.5*(x-e)-0.5;
if(k==1){
if(x<-0.25)return-2.0*(e-(x+0.5));
return1.0+2.0*(x-e);
}
u=(0x3FF+k)<<52;
lettwopk=reinterpret<f64>(u);
lety: f64;
if(k<0||k>56){
y=x-e+1.0;
if(k==1024)y=y*2.0*Ox1p1023;
elsey=y*twopk;
returny-1.0;
}
u=(0x3FF-k)<<52;
y=reinterpret<f64>(u);
if(k<20)y=(1-y)-e;
elsey=1-(e+y);
return(x+y)*twopk;
}

// @ts-ignore: decorator
 @inline
exportfunctionfloor(x: f64): f64{
returnbuiltin_floor<f64>(x);
}

// @ts-ignore: decorator
 @inline
exportfunctionfround(x: f64): f64{
return<f32>x;
}

exportfunctionhypot(x: f64,y: f64): f64{// see: musl/src/math/hypot.c
const
SPLIT=reinterpret<f64>(0x41A0000000000000)+1,// 0x1p27 + 1
Ox1p700=reinterpret<f64>(0x6BB0000000000000),
Ox1p_700=reinterpret<f64>(0x1430000000000000);

letux=reinterpret<u64>(x);
letuy=reinterpret<u64>(y);
ux&=0x7FFFFFFFFFFFFFFF;
uy&=0x7FFFFFFFFFFFFFFF;
if(ux<uy){
letut=ux;
ux=uy;
uy=ut;
}
letex=i32(ux>>52);
letey=i32(uy>>52);
y=reinterpret<f64>(uy);
if(ey==0x7FF)returny;
x=reinterpret<f64>(ux);
if(ex==0x7FF||uy==0)returnx;
if(ex-ey>64)returnx+y;
letz=1.0;
if(ex>0x3FF+510){
z=Ox1p700;
x*=Ox1p_700;
y*=Ox1p_700;
}elseif(ey<0x3FF-450){
z=Ox1p_700;
x*=Ox1p700;
y*=Ox1p700;
}
letc=x*SPLIT;
leth=x-c+c;
letl=x-h;
lethx=x*x;
letlx=h*h-hx+(2*h+l)*l;
c=y*SPLIT;
h=y-c+c;
l=y-h;
lethy=y*y;
letly=h*h-hy+(2*h+l)*l;
returnz*builtin_sqrt(ly+lx+hy+hx);
}

exportfunctionimul(x: f64,y: f64): f64{
/*
 * Wasm (MVP) and JS have different approaches for double->int conversions.
 *
 * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT
 * our float-point arguments before actual convertion to integers.
 */
if(!isFinite(x+y))return0;
returndtoi32(x)*dtoi32(y);
}

exportfunctionlog(x: f64): f64{// see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above
if(ASC_SHRINK_LEVEL<1){
returnlog_lut(x);
}else{
const
ln2_hi=reinterpret<f64>(0x3FE62E42FEE00000),// 6.93147180369123816490e-01
ln2_lo=reinterpret<f64>(0x3DEA39EF35793C76),// 1.90821492927058770002e-10
Lg1=reinterpret<f64>(0x3FE5555555555593),// 6.666666666666735130e-01
Lg2=reinterpret<f64>(0x3FD999999997FA04),// 3.999999999940941908e-01
Lg3=reinterpret<f64>(0x3FD2492494229359),// 2.857142874366239149e-01
Lg4=reinterpret<f64>(0x3FCC71C51D8E78AF),// 2.222219843214978396e-01
Lg5=reinterpret<f64>(0x3FC7466496CB03DE),// 1.818357216161805012e-01
Lg6=reinterpret<f64>(0x3FC39A09D078C69F),// 1.531383769920937332e-01
Lg7=reinterpret<f64>(0x3FC2F112DF3E5244),// 1.479819860511658591e-01
Ox1p54=reinterpret<f64>(0x4350000000000000);// 0x1p54

letu=reinterpret<u64>(x);
lethx=u32(u>>32);
letk=0;
letsign=hx>>31;
if(sign||hx<0x00100000){
if(u<<1==0)return-1/(x*x);
if(sign)return(x-x)/0.0;
k-=54;
x*=Ox1p54;
u=reinterpret<u64>(x);
hx=u32(u>>32);
}elseif(hx>=0x7FF00000){
returnx;
}elseif(hx==0x3FF00000&&u<<32==0){
return0;
}
hx+=0x3FF00000-0x3FE6A09E;
k+=(<i32>hx>>20)-0x3FF;
hx=(hx&0x000FFFFF)+0x3FE6A09E;