mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-04-26 07:22:21 +00:00
458 lines
13 KiB
TypeScript
458 lines
13 KiB
TypeScript
export declare namespace JSMath {
|
|
|
|
export const E: f64;
|
|
export const LN2: f64;
|
|
export const LN10: f64;
|
|
export const LOG2E: f64;
|
|
export const LOG10E: f64;
|
|
export const PI: f64;
|
|
export const SQRT1_2: f64;
|
|
export const SQRT2: f64;
|
|
|
|
export function abs(x: f64): f64;
|
|
export function acos(x: f64): f64;
|
|
export function acosh(x: f64): f64;
|
|
export function asin(x: f64): f64;
|
|
export function asinh(x: f64): f64;
|
|
export function atan(x: f64): f64;
|
|
export function atan2(y: f64, x: f64): f64;
|
|
export function atanh(x: f64): f64;
|
|
export function cbrt(x: f64): f64;
|
|
export function ceil(x: f64): f64;
|
|
export function clz32(x: f64): i32;
|
|
export function cos(x: f64): f64;
|
|
export function cosh(x: f64): f64;
|
|
export function exp(x: f64): f64;
|
|
export function expm1(x: f64): f64;
|
|
export function floor(x: f64): f64;
|
|
export function fround(x: f64): f32;
|
|
export function hypot(value1: f64, value2: f64): f64; // hypot(...values: f64[]): f64;
|
|
export function imul(a: f64, b: f64): i32;
|
|
export function log(x: f64): f64;
|
|
export function log10(x: f64): f64;
|
|
export function log1p(x: f64): f64;
|
|
export function log2(x: f64): f64;
|
|
export function max(value1: f64, value2: f64): f64; // max(...values: f64[]): f64;
|
|
export function min(value1: f64, value2: f64): f64; // min(...values: f64[]): f64;
|
|
export function pow(base: f64, exponent: f64): f64;
|
|
export function random(): f64;
|
|
export function round(x: f64): f64;
|
|
export function sign(x: f64): f64;
|
|
export function sin(x: f64): f64;
|
|
export function sinh(x: f64): f64;
|
|
export function sqrt(x: f64): f64;
|
|
export function tan(x: f64): f64;
|
|
export function tanh(x: f64): f64;
|
|
export function trunc(x: f64): f64;
|
|
}
|
|
|
|
import {
|
|
abs as builtin_abs,
|
|
ceil as builtin_ceil,
|
|
clz as builtin_clz,
|
|
floor as builtin_floor,
|
|
max as builtin_max,
|
|
min as builtin_min,
|
|
nearest as builtin_nearest,
|
|
sqrt as builtin_sqrt,
|
|
trunc as builtin_trunc
|
|
} from "./builtins";
|
|
|
|
// Math/Mathf.log/exp
|
|
// 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.
|
|
|
|
export namespace Math {
|
|
|
|
export const E = 2.7182818284590452354;
|
|
export const LN2 = 0.69314718055994530942;
|
|
export const LN10 = 2.30258509299404568402;
|
|
export const LOG2E = 1.4426950408889634074;
|
|
export const LOG10E = 0.43429448190325182765;
|
|
export const PI = 3.14159265358979323846;
|
|
export const SQRT1_2 = 0.70710678118654752440;
|
|
export const SQRT2 = 1.41421356237309504880;
|
|
|
|
export function abs(x: f64): f64 {
|
|
return builtin_abs(x);
|
|
}
|
|
|
|
export function ceil(x: f64): f64 {
|
|
return builtin_ceil(x);
|
|
}
|
|
|
|
export function clz32(x: f64): i32 {
|
|
return builtin_clz(<i32>x);
|
|
}
|
|
|
|
export function exp(x: f64): f64 {
|
|
// based on musl's implementation of exp:
|
|
const
|
|
half = <f64[]>[0.5,-0.5],
|
|
ln2hi = 6.93147180369123816490e-01, // 0x3fe62e42, 0xfee00000
|
|
ln2lo = 1.90821492927058770002e-10, // 0x3dea39ef, 0x35793c76
|
|
invln2 = 1.44269504088896338700e+00, // 0x3ff71547, 0x652b82fe
|
|
P1 = 1.66666666666666019037e-01, // 0x3FC55555, 0x5555553E
|
|
P2 = -2.77777777770155933842e-03, // 0xBF66C16C, 0x16BEBD93
|
|
P3 = 6.61375632143793436117e-05, // 0x3F11566A, 0xAF25DE2C
|
|
P4 = -1.65339022054652515390e-06, // 0xBEBBBD41, 0xC5D26BF1
|
|
P5 = 4.13813679705723846039e-08, // 0x3E663769, 0x72BEA4D0
|
|
Ox1p1023 = 8.98846567431157954e+307;
|
|
|
|
var hx = <u32>(reinterpret<u64>(x) >> 32);
|
|
var sign_ = hx >> 31;
|
|
hx &= 0x7fffffff; // high word of |x|
|
|
|
|
// special cases
|
|
if (hx >= 0x4086232b) { // if |x| >= 708.39...
|
|
if (isNaN(x)) return x;
|
|
if (x > 709.782712893383973096) {
|
|
// overflow if x!=inf
|
|
x *= Ox1p1023;
|
|
return x;
|
|
}
|
|
if (x < -708.39641853226410622) {
|
|
// underflow if x!=-inf
|
|
if (x < -745.13321910194110842) return 0;
|
|
}
|
|
}
|
|
|
|
// argument reduction
|
|
var hi: f64, lo: f64;
|
|
var k: i32;
|
|
if (hx > 0x3fd62e42) { // if |x| > 0.5 ln2
|
|
if (hx >= 0x3ff0a2b2) { // if |x| >= 1.5 ln2
|
|
k = <i32>(invln2 * x + half[sign_]);
|
|
} else {
|
|
k = 1 - sign_ - sign_;
|
|
}
|
|
hi = x - k * ln2hi; // k * ln2hi is exact here
|
|
lo = k * ln2lo;
|
|
x = hi - lo;
|
|
} else if (hx > 0x3e300000) { // if |x| > 2**-28
|
|
k = 0;
|
|
hi = x;
|
|
lo = 0;
|
|
} else {
|
|
// inexact if x != 0
|
|
return 1 + x;
|
|
}
|
|
|
|
// x is now in primary range
|
|
var xx = x * x;
|
|
var c = x - xx * (P1 + xx * (P2 + xx * (P3 + xx * (P4 + xx * P5))));
|
|
var y: f64 = 1 + (x * c / (2 - c) - lo + hi);
|
|
if (k == 0) return y;
|
|
return scalbn(y, k);
|
|
}
|
|
|
|
export function floor(x: f64): f64 {
|
|
return builtin_floor(x);
|
|
}
|
|
|
|
export function fround(x: f64): f32 {
|
|
return <f32>x;
|
|
}
|
|
|
|
export function imul(x: f64, y: f64): i32 {
|
|
return <i32>x * <i32>y;
|
|
}
|
|
|
|
export function log(x: f64): f64 { // based on musl's implementation of log
|
|
const
|
|
ln2_hi = 6.93147180369123816490e-01, // 3fe62e42 fee00000
|
|
ln2_lo = 1.90821492927058770002e-10, // 3dea39ef 35793c76
|
|
Lg1 = 6.666666666666735130e-01, // 3FE55555 55555593
|
|
Lg2 = 3.999999999940941908e-01, // 3FD99999 9997FA04
|
|
Lg3 = 2.857142874366239149e-01, // 3FD24924 94229359
|
|
Lg4 = 2.222219843214978396e-01, // 3FCC71C5 1D8E78AF
|
|
Lg5 = 1.818357216161805012e-01, // 3FC74664 96CB03DE
|
|
Lg6 = 1.531383769920937332e-01, // 3FC39A09 D078C69F
|
|
Lg7 = 1.479819860511658591e-01, // 3FC2F112 DF3E5244
|
|
Ox1p54 = 18014398509481984.0;
|
|
|
|
var Ux = reinterpret<u64>(x);
|
|
var hx = <u32>(Ux >> 32);
|
|
var k = 0;
|
|
if (hx < 0x00100000 || <bool>(hx >> 31)) {
|
|
if (Ux << 1 == 0) return -1 / (x * x); // log(+-0)=-inf
|
|
if (hx >> 31) return (x - x) / 0.0; // log(-#) = NaN
|
|
// subnormal number, scale x up
|
|
k -= 54;
|
|
x *= Ox1p54;
|
|
Ux = reinterpret<u64>(x);
|
|
hx = <u32>(Ux >> 32);
|
|
} else if (hx >= 0x7ff00000) return x;
|
|
else if (hx == 0x3ff00000 && Ux << 32 == 0) return 0;
|
|
|
|
// reduce x into [sqrt(2)/2, sqrt(2)]
|
|
hx += 0x3ff00000 - 0x3fe6a09e;
|
|
k += (<i32>hx >> 20) - 0x3ff;
|
|
hx = (hx & 0x000fffff) + 0x3fe6a09e;
|
|
Ux = <u64>hx << 32 | (Ux & 0xffffffff);
|
|
x = reinterpret<f64>(Ux);
|
|
|
|
var f = x - 1.0;
|
|
var hfsq = 0.5 * f * f;
|
|
var s = f / (2.0 + f);
|
|
var z = s * s;
|
|
var w = z * z;
|
|
var t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
|
|
var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
|
|
var R = t2 + t1;
|
|
var dk = k;
|
|
return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi;
|
|
}
|
|
|
|
// export function log2(x: f64): f64 {
|
|
// return log(x) / LN2;
|
|
// }
|
|
|
|
// export function log10(x: f64): f64 {
|
|
// return log(x) / LN10;
|
|
// }
|
|
|
|
export function max(value1: f64, value2: f64): f64 {
|
|
return builtin_max(value1, value2);
|
|
}
|
|
|
|
export function min(value1: f64, value2: f64): f64 {
|
|
return builtin_min(value1, value2);
|
|
}
|
|
|
|
export function round(x: f64): f64 {
|
|
return builtin_nearest(x);
|
|
}
|
|
|
|
export function sign(x: f64): f64 {
|
|
return x > 0 ? 1 : x < 0 ? -1 : x;
|
|
}
|
|
|
|
export function sqrt(x: f64): f64 {
|
|
return builtin_sqrt(x);
|
|
}
|
|
|
|
export function trunc(x: f64): f64 {
|
|
return builtin_trunc(x);
|
|
}
|
|
}
|
|
|
|
export namespace Mathf {
|
|
|
|
export const E = <f32>Math.E;
|
|
export const LN2 = <f32>Math.LN2;
|
|
export const LN10 = <f32>Math.LN10;
|
|
export const LOG2E = <f32>Math.LOG2E;
|
|
export const LOG10E = <f32>Math.LOG10E;
|
|
export const PI = <f32>Math.PI;
|
|
export const SQRT1_2 = <f32>Math.SQRT1_2;
|
|
export const SQRT2 = <f32>Math.SQRT2;
|
|
|
|
export function abs(x: f32): f32 {
|
|
return builtin_abs(x);
|
|
}
|
|
|
|
export function ceil(x: f32): f32 {
|
|
return builtin_ceil(x);
|
|
}
|
|
|
|
export function clz32(x: f32): i32 {
|
|
return builtin_clz(<i32>x);
|
|
}
|
|
|
|
export function floor(x: f32): f32 {
|
|
return builtin_floor(x);
|
|
}
|
|
|
|
export function exp(x: f32): f32 { // based on musl's implementation of expf
|
|
const
|
|
half = <f32[]>[0.5,-0.5],
|
|
ln2hi = <f32>6.9314575195e-1, // 0x3f317200
|
|
ln2lo = <f32>1.4286067653e-6, // 0x35bfbe8e
|
|
invln2 = <f32>1.4426950216e+0, // 0x3fb8aa3b
|
|
// Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:
|
|
// |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74
|
|
P1 = <f32>1.6666625440e-1, // 0xaaaa8f.0p-26
|
|
P2 = <f32>-2.7667332906e-3, // -0xb55215.0p-32
|
|
Ox1p127f = <f32>1.701411835e+38;
|
|
|
|
var hx = reinterpret<u32>(x);
|
|
var sign_ = <i32>(hx >> 31); // sign bit of x
|
|
hx &= 0x7fffffff; // high word of |x|
|
|
|
|
// special cases
|
|
if (hx >= 0x42aeac50) { // if |x| >= -87.33655f or NaN
|
|
if (hx >= 0x42b17218 && !sign_) { // x >= 88.722839f
|
|
// overflow
|
|
x *= Ox1p127f;
|
|
return x;
|
|
}
|
|
if (sign_) {
|
|
// underflow
|
|
if (hx >= 0x42cff1b5) { // x <= -103.972084f */
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// argument reduction
|
|
var hi: f32, lo: f32;
|
|
var k: i32;
|
|
if (hx > 0x3eb17218) { // if |x| > 0.5 ln2
|
|
if (hx > 0x3f851592) { // if |x| > 1.5 ln2
|
|
k = <i32>(invln2 * x + half[sign_]);
|
|
} else {
|
|
k = 1 - sign_ - sign_;
|
|
}
|
|
hi = x - <f32>k * ln2hi; // k * ln2hi is exact here
|
|
lo = <f32>k * ln2lo;
|
|
x = hi - lo;
|
|
} else if (hx > 0x39000000) { // |x| > 2**-14
|
|
k = 0;
|
|
hi = x;
|
|
lo = 0;
|
|
} else {
|
|
// raise inexact
|
|
return 1 + x;
|
|
}
|
|
|
|
// x is now in primary range
|
|
var xx = x * x;
|
|
var c = x - xx * (P1 + xx * P2);
|
|
var y: f32 = 1 + (x * c / (2 - c) - lo + hi);
|
|
if (k == 0) return y;
|
|
return scalbnf(y, k);
|
|
}
|
|
|
|
export function imul(x: f32, y: f32): i32 {
|
|
return <i32>x * <i32>y;
|
|
}
|
|
|
|
export function log(x: f32): f32 { // based on musl's implementaion of logf
|
|
const
|
|
ln2_hi = <f32>6.9313812256e-01, // 0x3f317180
|
|
ln2_lo = <f32>9.0580006145e-06, // 0x3717f7d1
|
|
Lg1 = <f32>0.66666662693, // 0xaaaaaa.0p-24
|
|
Lg2 = <f32>0.40000972152, // 0xccce13.0p-25
|
|
Lg3 = <f32>0.28498786688, // 0x91e9ee.0p-25
|
|
Lg4 = <f32>0.24279078841, // 0xf89e26.0p-26
|
|
Ox1p25f = <f32>33554432.0;
|
|
|
|
var ux = reinterpret<u32>(x);
|
|
var k = 0;
|
|
if (ux < 0x00800000 || <bool>(ux >> 31)) { // x < 2**-126
|
|
if (ux << 1 == 0) return -1 / (x * x); // log(+-0)=-inf
|
|
if (ux >> 31) return (x - x) / 0; // log(-#) = NaN
|
|
// subnormal number, scale up x
|
|
k -= 25;
|
|
x *= Ox1p25f;
|
|
ux = reinterpret<u32>(x);
|
|
} else if (ux >= 0x7f800000) return x;
|
|
else if (ux == 0x3f800000) return 0;
|
|
|
|
// reduce x into [sqrt(2)/2, sqrt(2)]
|
|
ux += 0x3f800000 - 0x3f3504f3;
|
|
k += <u32>(<i32>ux >> 23) - 0x7f;
|
|
ux = (ux & 0x007fffff) + 0x3f3504f3;
|
|
x = reinterpret<f32>(ux);
|
|
|
|
var f = x - 1.0;
|
|
var s = f / (2.0 + f);
|
|
var z = s * s;
|
|
var w = z * z;
|
|
var t1 = w * (Lg2 + w * Lg4);
|
|
var t2 = z * (Lg1 + w * Lg3);
|
|
var R = t2 + t1;
|
|
var hfsq = <f32>0.5 * f * f;
|
|
var dk = <f32>k;
|
|
return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi;
|
|
}
|
|
|
|
// export function log2(x: f32): f32 {
|
|
// return log(x) / LN2;
|
|
// }
|
|
|
|
// export function log10(x: f32): f32 {
|
|
// return log(x) / LN10;
|
|
// }
|
|
|
|
export function max(value1: f32, value2: f32): f32 {
|
|
return builtin_max(value1, value2);
|
|
}
|
|
|
|
export function min(value1: f32, value2: f32): f32 {
|
|
return builtin_min(value1, value2);
|
|
}
|
|
|
|
export function round(x: f32): f32 {
|
|
return builtin_nearest(x);
|
|
}
|
|
|
|
export function sign(x: f32): f32 {
|
|
return x > 0 ? 1 : x < 0 ? -1 : x;
|
|
}
|
|
|
|
export function sqrt(x: f32): f32 {
|
|
return builtin_sqrt(x);
|
|
}
|
|
|
|
export function trunc(x: f32): f32 {
|
|
return builtin_trunc(x);
|
|
}
|
|
}
|
|
|
|
function scalbn(x: f64, n: i32): f64 { // based on musl's implementation of scalbn
|
|
const
|
|
Ox1p1023 = 8.98846567431157954e+307,
|
|
Ox1p_1022 = 2.22507385850720138e-308;
|
|
|
|
var y = x;
|
|
if (n > 1023) {
|
|
y *= Ox1p1023;
|
|
n -= 1023;
|
|
if (n > 1023) {
|
|
y *= Ox1p1023;
|
|
n -= 1023;
|
|
if (n > 1023) n = 1023;
|
|
}
|
|
} else if (n < -1022) {
|
|
y *= Ox1p_1022;
|
|
n += 1022;
|
|
if (n < -1022) {
|
|
y *= Ox1p_1022;
|
|
n += 1022;
|
|
if (n < -1022) n = -1022;
|
|
}
|
|
}
|
|
return y * reinterpret<f64>(<u64>(0x3ff + n) << 52);
|
|
}
|
|
|
|
function scalbnf(x: f32, n: i32): f32 { // based on musl's implementation of scalbnf
|
|
const
|
|
Ox1p127f = <f32>1.701411835e+38,
|
|
Ox1p_126f = <f32>1.175494351e-38;
|
|
|
|
var y = x;
|
|
if (n > 127) {
|
|
y *= Ox1p127f;
|
|
n -= 127;
|
|
if (n > 127) {
|
|
y *= Ox1p127f;
|
|
n -= 127;
|
|
if (n > 127) n = 127;
|
|
}
|
|
} else if (n < -126) {
|
|
y *= Ox1p_126f;
|
|
n += 126;
|
|
if (n < -126) {
|
|
y *= Ox1p_126f;
|
|
n += 126;
|
|
if (n < -126) n = -126;
|
|
}
|
|
}
|
|
return y * reinterpret<f32>(<u32>(0x7f + n) << 23);
|
|
}
|