1 | 'use strict';
|
2 |
|
3 | function is(x) {
|
4 | return typeof x === "bigint";
|
5 | }
|
6 | function compare(x, y) {
|
7 | return Number(x - y);
|
8 | }
|
9 | function abs(x) {
|
10 | return x < 0n ? -x : x;
|
11 | }
|
12 | function sign(x) {
|
13 | return x < 0n ? -1n : (x > 0n ? 1n : 0n);
|
14 | }
|
15 | function floorDiv(x, y) {
|
16 | if (y < 0n) {
|
17 | x = -x;
|
18 | y = -y;
|
19 | }
|
20 | return x >= 0n ? x / y : (x - y + 1n) / y;
|
21 | }
|
22 | function ceilDiv(x, y) {
|
23 | if (y < 0n) {
|
24 | x = -x;
|
25 | y = -y;
|
26 | }
|
27 | return x >= 0n ? (x + y - 1n) / y : x / y;
|
28 | }
|
29 | function roundDiv(x, y) {
|
30 | if (y < 0n) {
|
31 | x = -x;
|
32 | y = -y;
|
33 | }
|
34 | return x >= 0n ? (x + y / 2n) / y : (x - y / 2n) / y;
|
35 | }
|
36 | function rem(x, y) {
|
37 | return x % y;
|
38 | }
|
39 | function mod(x, y) {
|
40 | return x - y * floorDiv(x, y);
|
41 | }
|
42 | function modp(x, y) {
|
43 | return x - abs(y) * floorDiv(x, abs(y));
|
44 | }
|
45 | function constrain(x, minv, maxv) {
|
46 | return min(max(x, minv), maxv);
|
47 | }
|
48 | function remap(x, r, R, t, T) {
|
49 | return t + (x - r) * (T - t) / (R - r);
|
50 | }
|
51 | function lerp(x, y, t) {
|
52 | return x + BigInt(Math.floor(t * Number(y - x)));
|
53 | }
|
54 | function isPow2(x) {
|
55 | return /^10*$/.test(x.toString(2));
|
56 | }
|
57 | function isPow10(x) {
|
58 | return /^10*$/.test(x.toString());
|
59 | }
|
60 | function prevPow2(x) {
|
61 | if (x <= 1n)
|
62 | return 0n;
|
63 | var n = x.toString(2).length;
|
64 | return BigInt("0b1" + "0".repeat(n - 1));
|
65 | }
|
66 | function prevPow10(x) {
|
67 | if (x <= 1n)
|
68 | return 0n;
|
69 | var n = x.toString(10).length;
|
70 | return BigInt("1" + "0".repeat(n - 1));
|
71 | }
|
72 | function nextPow2(x) {
|
73 | if (x <= 0n)
|
74 | return 1n;
|
75 | var n = (x - 1n).toString(2).length;
|
76 | return BigInt("0b1" + "0".repeat(n));
|
77 | }
|
78 | function nextPow10(x) {
|
79 | if (x <= 0n)
|
80 | return 1n;
|
81 | var n = (x - 1n).toString(10).length;
|
82 | return BigInt("1" + "0".repeat(n));
|
83 | }
|
84 | function log2(x) {
|
85 | var n = x.toString(2).length - 1;
|
86 | return x <= 0n ? 0n : BigInt(n);
|
87 | }
|
88 | function log10(x) {
|
89 | var n = x.toString().length - 1;
|
90 | return x <= 0n ? 0n : BigInt(n);
|
91 | }
|
92 | function sqrt(x) {
|
93 | if (x === 0n)
|
94 | return 0n;
|
95 | return x > 0n ? sqrtPos(x) : null;
|
96 | }
|
97 | function sqrtPos(x) {
|
98 | var a = 1n << (log2(x) / 2n + 1n);
|
99 | var b = 1n + a;
|
100 | while (a < b) {
|
101 | b = a;
|
102 | a = (b + x / b) / 2n;
|
103 | }
|
104 | return b;
|
105 | }
|
106 | function cbrt(x) {
|
107 | return root(x, 3n);
|
108 | }
|
109 | function root(x, n = 1n) {
|
110 | if (x === 0n)
|
111 | return 0n;
|
112 | else if (x > 0n)
|
113 | return rootPos(x, n);
|
114 | return n % 2n !== 0n ? -rootPos(-x, n) : null;
|
115 | }
|
116 | function rootPos(x, n) {
|
117 | var a = 1n << (log2(x) / n + 1n);
|
118 | var b = 1n + a, m = n - 1n;
|
119 | if (a === 2n)
|
120 | return 1n;
|
121 | while (a < b) {
|
122 | b = a;
|
123 | a = (m * b + x / b ** m) / n;
|
124 | }
|
125 | return b;
|
126 | }
|
127 | function properDivisors(x) {
|
128 | var x = abs(x), a = [];
|
129 | for (var i = 1n; i < x; i++)
|
130 | if (x % i === 0n)
|
131 | a.push(i);
|
132 | return a;
|
133 | }
|
134 | function aliquotSum(x) {
|
135 | var x = abs(x), a = 0n;
|
136 | for (var i = 1n; i < x; i++)
|
137 | if (x % i === 0n)
|
138 | a += i;
|
139 | return a;
|
140 | }
|
141 | function minPrimeFactor(x) {
|
142 | var x = abs(x);
|
143 | if (x <= 1n)
|
144 | return 0n;
|
145 | if (x <= 3n)
|
146 | return x;
|
147 | if (x % 2n === 0n)
|
148 | return 2n;
|
149 | if (x % 3n === 0n)
|
150 | return 3n;
|
151 | for (var i = 6n, I = sqrt(x) + 1n; i <= I; i += 6n) {
|
152 | if (x % (i - 1n) === 0n)
|
153 | return i - 1n;
|
154 | if (x % (i + 1n) === 0n)
|
155 | return i + 1n;
|
156 | }
|
157 | return x;
|
158 | }
|
159 | function maxPrimeFactor(x) {
|
160 | var x = abs(x), a = 0n;
|
161 | if (x <= 1n)
|
162 | return 0n;
|
163 | if (x <= 3n)
|
164 | return x;
|
165 | for (; x % 2n === 0n; a = 2n)
|
166 | x /= 2n;
|
167 | for (; x % 3n === 0n; a = 3n)
|
168 | x /= 3n;
|
169 | for (var i = 6n, I = sqrt(x) + 1n; x > 1n && i <= I; i += 6n) {
|
170 | for (; x % (i - 1n) == 0n; a = i - 1n)
|
171 | x /= i - 1n;
|
172 | for (; x % (i + 1n) == 0n; a = i + 1n)
|
173 | x /= i + 1n;
|
174 | }
|
175 | if (x <= 1n)
|
176 | return a;
|
177 | return x;
|
178 | }
|
179 | function primeFactors(x) {
|
180 | var x = abs(x), a = [];
|
181 | if (x <= 1n)
|
182 | return [];
|
183 | if (x <= 3n)
|
184 | return [x];
|
185 | x = pushPrimeFactorTo$(a, x, 2n);
|
186 | x = pushPrimeFactorTo$(a, x, 3n);
|
187 | for (var i = 6n, I = sqrt(x) + 1n; x > 1n && i <= I; i += 6n) {
|
188 | x = pushPrimeFactorTo$(a, x, i - 1n);
|
189 | x = pushPrimeFactorTo$(a, x, i + 1n);
|
190 | }
|
191 | if (x > 1n)
|
192 | a.push(x);
|
193 | return a;
|
194 | }
|
195 | function pushPrimeFactorTo$(a, x, f) {
|
196 | if (x % f !== 0n)
|
197 | return x;
|
198 | do {
|
199 | x /= f;
|
200 | } while (x % f === 0n);
|
201 | a.push(f);
|
202 | return x;
|
203 | }
|
204 | function primeExponentials(x) {
|
205 | var x = abs(x), a = [];
|
206 | if (x <= 1n)
|
207 | return [];
|
208 | if (x <= 3n)
|
209 | return [[x, 1n]];
|
210 | x = pushPrimeExponentialTo$(a, x, 2n);
|
211 | x = pushPrimeExponentialTo$(a, x, 3n);
|
212 | for (var i = 6n, I = sqrt(x) + 1n; x > 1n && i <= I; i += 6n) {
|
213 | x = pushPrimeExponentialTo$(a, x, i - 1n);
|
214 | x = pushPrimeExponentialTo$(a, x, i + 1n);
|
215 | }
|
216 | if (x > 1n)
|
217 | a.push([x, 1n]);
|
218 | return a;
|
219 | }
|
220 | function pushPrimeExponentialTo$(a, x, f) {
|
221 | if (x % f !== 0n)
|
222 | return x;
|
223 | var e = 0n;
|
224 | do {
|
225 | x /= f;
|
226 | ++e;
|
227 | } while (x % f === 0n);
|
228 | a.push([f, e]);
|
229 | return x;
|
230 | }
|
231 | function isPrime(x) {
|
232 | return x !== 0n && minPrimeFactor(x) === abs(x);
|
233 | }
|
234 | function gcd(...xs) {
|
235 | var a = xs[0] || 1n;
|
236 | for (var i = 1, I = xs.length; i < I; i++)
|
237 | a = gcdPair(a, xs[i]);
|
238 | return a;
|
239 | }
|
240 | function gcdPair(x, y) {
|
241 | while (y !== 0n) {
|
242 | var t = y;
|
243 | y = x % y;
|
244 | x = t;
|
245 | }
|
246 | return x;
|
247 | }
|
248 | function lcm(...xs) {
|
249 | var a = xs[0] || 1n;
|
250 | for (var i = 1, I = xs.length; i < I; i++)
|
251 | a = a * xs[i] / gcdPair(a, xs[i]);
|
252 | return a;
|
253 | }
|
254 | function factorial(n, k = 0n) {
|
255 | if (n < 0n)
|
256 | return 0n;
|
257 | for (var i = k + 1n, a = 1n; i <= n; i++)
|
258 | a *= i;
|
259 | return a;
|
260 | }
|
261 | function binomial(n, k) {
|
262 | if (k < 0n || k > abs(n))
|
263 | return 0n;
|
264 | if (n < 0n)
|
265 | return ((-1n) ** k) * binomial(-n, k);
|
266 | k = k > n - k ? n - k : k;
|
267 | for (var a = 1n, b = 1n, i = 1n; i <= k; i++, n--) {
|
268 | a *= n;
|
269 | b *= i;
|
270 | }
|
271 | return a / b;
|
272 | }
|
273 | function multinomial(...ks) {
|
274 | var n = sum(...ks), a = 1n, b = 1n;
|
275 | for (var i = 0, j = 0n, I = ks.length; i < I;) {
|
276 | if (j <= 0n)
|
277 | j = ks[i++];
|
278 | else {
|
279 | a *= n--;
|
280 | b *= j--;
|
281 | }
|
282 | }
|
283 | return a / b;
|
284 | }
|
285 | function hypot(...xs) {
|
286 | var a = 0n;
|
287 | for (var x of xs)
|
288 | a += x * x;
|
289 | return sqrt(a);
|
290 | }
|
291 | function sum(...xs) {
|
292 | var a = 0n;
|
293 | for (var x of xs)
|
294 | a += x;
|
295 | return a;
|
296 | }
|
297 | function product(...xs) {
|
298 | var a = 1n;
|
299 | for (var x of xs)
|
300 | a *= x;
|
301 | return a;
|
302 | }
|
303 | function median(...xs) {
|
304 | if (xs.length === 0)
|
305 | return 0n;
|
306 | xs.sort(compare);
|
307 | var i = xs.length >> 1;
|
308 | if ((xs.length & 1) === 1)
|
309 | return xs[i];
|
310 | return (xs[i - 1] + xs[i]) / 2n;
|
311 | }
|
312 | function modes(...xs) {
|
313 | xs.sort(compare);
|
314 | var r = maxRepeat(xs);
|
315 | return getRepeats(xs, r);
|
316 | }
|
317 | function maxRepeat(xs) {
|
318 | var count = Math.min(xs.length, 1), max = count;
|
319 | for (var i = 1, I = xs.length; i < I; i++) {
|
320 | if (xs[i - 1] === xs[i])
|
321 | count++;
|
322 | else {
|
323 | max = Math.max(max, count);
|
324 | count = 1;
|
325 | }
|
326 | }
|
327 | return Math.max(max, count);
|
328 | }
|
329 | function getRepeats(xs, r) {
|
330 | var a = [];
|
331 | r--;
|
332 | for (var i = 0, I = xs.length - r; i < I; i++)
|
333 | if (xs[i] === xs[i + r])
|
334 | a.push(xs[i += r]);
|
335 | return a;
|
336 | }
|
337 | function min(...xs) {
|
338 | if (xs.length === 0)
|
339 | return 0n;
|
340 | var a = xs[0];
|
341 | for (var x of xs)
|
342 | a = x < a ? x : a;
|
343 | return a;
|
344 | }
|
345 | function max(...xs) {
|
346 | if (xs.length === 0)
|
347 | return 0n;
|
348 | var a = xs[0];
|
349 | for (var x of xs)
|
350 | a = x > a ? x : a;
|
351 | return a;
|
352 | }
|
353 | function range(...xs) {
|
354 | if (xs.length === 0)
|
355 | return [0n, 0n];
|
356 | var a = xs[0], b = a;
|
357 | for (var x of xs) {
|
358 | a = x < a ? x : a;
|
359 | b = x > b ? x : b;
|
360 | }
|
361 | return [a, b];
|
362 | }
|
363 | function variance(...xs) {
|
364 | if (xs.length === 0)
|
365 | return 0n;
|
366 | var m = arithmeticMean(...xs), a = 0n;
|
367 | for (var x of xs)
|
368 | a += (x - m) ** 2n;
|
369 | return a / BigInt(xs.length);
|
370 | }
|
371 | function arithmeticMean(...xs) {
|
372 | var n = BigInt(xs.length);
|
373 | return sum(...xs) / n;
|
374 | }
|
375 | function geometricMean(...xs) {
|
376 | var n = BigInt(xs.length);
|
377 | return root(product(...xs), n);
|
378 | }
|
379 | function harmonicMean(...xs) {
|
380 | var n = BigInt(xs.length);
|
381 | var p = product(...xs), q = 0n;
|
382 | for (var x of xs)
|
383 | q += p / x;
|
384 | return n * p / q;
|
385 | }
|
386 | function quadriaticMean(...xs) {
|
387 | var n = BigInt(xs.length);
|
388 | var a = 0n;
|
389 | for (var x of xs)
|
390 | a += x * x;
|
391 | return sqrt(a / n);
|
392 | }
|
393 | function cubicMean(...xs) {
|
394 | var n = BigInt(xs.length);
|
395 | var a = 0n;
|
396 | for (var x of xs)
|
397 | a += x ** 3n;
|
398 | return cbrt(a / n);
|
399 | }
|
400 |
|
401 | exports.abs = abs;
|
402 | exports.aliquotParts = properDivisors;
|
403 | exports.aliquotSum = aliquotSum;
|
404 | exports.arithmeticMean = arithmeticMean;
|
405 | exports.binomial = binomial;
|
406 | exports.cbrt = cbrt;
|
407 | exports.ceilDiv = ceilDiv;
|
408 | exports.clamp = constrain;
|
409 | exports.compare = compare;
|
410 | exports.constrain = constrain;
|
411 | exports.cubicMean = cubicMean;
|
412 | exports.factorial = factorial;
|
413 | exports.floorDiv = floorDiv;
|
414 | exports.gcd = gcd;
|
415 | exports.geometricMean = geometricMean;
|
416 | exports.greatestPrimeFactor = maxPrimeFactor;
|
417 | exports.harmonicMean = harmonicMean;
|
418 | exports.hcf = gcd;
|
419 | exports.hypot = hypot;
|
420 | exports.is = is;
|
421 | exports.isPow10 = isPow10;
|
422 | exports.isPow2 = isPow2;
|
423 | exports.isPrime = isPrime;
|
424 | exports.lcm = lcm;
|
425 | exports.leastPrimeFactor = minPrimeFactor;
|
426 | exports.lerp = lerp;
|
427 | exports.log10 = log10;
|
428 | exports.log2 = log2;
|
429 | exports.map = remap;
|
430 | exports.max = max;
|
431 | exports.maxPrimeFactor = maxPrimeFactor;
|
432 | exports.mean = arithmeticMean;
|
433 | exports.median = median;
|
434 | exports.min = min;
|
435 | exports.minPrimeFactor = minPrimeFactor;
|
436 | exports.mod = mod;
|
437 | exports.modes = modes;
|
438 | exports.modp = modp;
|
439 | exports.multinomial = multinomial;
|
440 | exports.nextPow10 = nextPow10;
|
441 | exports.nextPow2 = nextPow2;
|
442 | exports.prevPow10 = prevPow10;
|
443 | exports.prevPow2 = prevPow2;
|
444 | exports.primeExponentials = primeExponentials;
|
445 | exports.primeFactors = primeFactors;
|
446 | exports.product = product;
|
447 | exports.properDivisors = properDivisors;
|
448 | exports.quadriaticMean = quadriaticMean;
|
449 | exports.range = range;
|
450 | exports.rem = rem;
|
451 | exports.remap = remap;
|
452 | exports.root = root;
|
453 | exports.rootMeanSquare = quadriaticMean;
|
454 | exports.roundDiv = roundDiv;
|
455 | exports.sign = sign;
|
456 | exports.sqrt = sqrt;
|
457 | exports.sum = sum;
|
458 | exports.variance = variance;
|