@fncts/test 0.0.1

package/_cjs/util/math.cjs

@@ -0,0 +1,673 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Zero64 = exports.Unit64 = exports.MIN_VALUE_32 = exports.MAX_VALUE_32 = exports.EPSILON_32 = void 0;
+exports.add64 = add64;
+exports.clamp = clamp;
+exports.clone64 = clone64;
+exports.computeArrayInt64GenerateRange = computeArrayInt64GenerateRange;
+exports.computeBiasedRanges = computeBiasedRanges;
+exports.decomposeDouble = decomposeDouble;
+exports.decomposeFloat = decomposeFloat;
+exports.doubleToIndex = doubleToIndex;
+exports.floatToIndex = floatToIndex;
+exports.halve64 = halve64;
+exports.indexInFloatFromDecomp = indexInFloatFromDecomp;
+exports.indexToDouble = indexToDouble;
+exports.indexToFloat = indexToFloat;
+exports.isEqual64 = isEqual64;
+exports.isStrictlyNegative64 = isStrictlyNegative64;
+exports.isStrictlyPositive64 = isStrictlyPositive64;
+exports.isStrictlySmaller64 = isStrictlySmaller64;
+exports.isZero64 = isZero64;
+exports.logLike64 = logLike64;
+exports.negative64 = negative64;
+exports.nextAfter = nextAfter;
+exports.nextUp = nextUp;
+exports.safeDoubleToIndex = safeDoubleToIndex;
+exports.safeFloatToIndex = safeFloatToIndex;
+exports.substract64 = substract64;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Random/api"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const fileName_1 = "(@fncts/test) src/util/math.ts";
+
+/** @internal */
+const MIN_VALUE_32 = 2 ** -126 * 2 ** -23;
+/** @internal */
+
+exports.MIN_VALUE_32 = MIN_VALUE_32;
+const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
+/** @internal */
+
+exports.MAX_VALUE_32 = MAX_VALUE_32;
+const EPSILON_32 = 2 ** -23;
+/** @internal */
+
+exports.EPSILON_32 = EPSILON_32;
+const INDEX_POSITIVE_INFINITY_32 = 2139095040; // floatToIndex(MAX_VALUE_32) + 1;
+
+/** @internal */
+
+const INDEX_NEGATIVE_INFINITY_32 = -2139095041; // floatToIndex(-MAX_VALUE_32) - 1
+
+function safeFloatToIndex(f, label) {
+  const conversionTrick = "you can convert any double to a 32-bit float by using `new Float32Array([myDouble])[0]`";
+  const errorMessage = "fc.floatNext constraints." + label + " must be a 32-bit float - " + conversionTrick;
+
+  if (Number.isNaN(f) || Number.isFinite(f) && (f < -MAX_VALUE_32 || f > MAX_VALUE_32)) {
+    return tsplus_module_1.haltNow(new Error(errorMessage), fileName_1 + ":17:22");
+  }
+
+  const index = floatToIndex(f);
+
+  if (!Number.isInteger(index)) {
+    return tsplus_module_1.haltNow(new Error(errorMessage), fileName_1 + ":21:22");
+  }
+
+  return tsplus_module_1.succeedNow(index, fileName_1 + ":23:23");
+}
+
+function decomposeFloat(f) {
+  // 1 => significand 0b1   - exponent 1 (will be preferred)
+  //   => significand 0b0.1 - exponent 2
+  const maxSignificand = 1 + (2 ** 23 - 1) / 2 ** 23;
+
+  for (let exponent = -126; exponent !== 128; ++exponent) {
+    const powExponent = 2 ** exponent;
+    const maxForExponent = maxSignificand * powExponent;
+
+    if (Math.abs(f) <= maxForExponent) {
+      return {
+        exponent,
+        significand: f / powExponent
+      };
+    }
+  }
+
+  return {
+    exponent: Number.NaN,
+    significand: Number.NaN
+  };
+}
+
+function floatToIndex(f) {
+  if (f === Number.POSITIVE_INFINITY) {
+    return INDEX_POSITIVE_INFINITY_32;
+  }
+
+  if (f === Number.NEGATIVE_INFINITY) {
+    return INDEX_NEGATIVE_INFINITY_32;
+  }
+
+  const {
+    exponent,
+    significand
+  } = decomposeFloat(f);
+
+  if (Number.isNaN(exponent) || Number.isNaN(significand) || !Number.isInteger(significand * 0x800000)) {
+    return Number.NaN;
+  }
+
+  if (f > 0 || f === 0 && 1 / f === Number.POSITIVE_INFINITY) {
+    return indexInFloatFromDecomp(exponent, significand);
+  } else {
+    return -indexInFloatFromDecomp(exponent, -significand) - 1;
+  }
+}
+/** @internal */
+
+
+function indexInFloatFromDecomp(exponent, significand) {
+  // WARNING: significand >= 0
+  // By construct of significand in decomposeFloat,
+  // significand is always max-ed.
+  // The float close to zero are the only one having a significand <1, they also have an exponent of -126.
+  // They are in range: [2**(-126) * 2**(-23), 2**(-126) * (2 - 2 ** 23)]
+  // In other words there are 2**24 elements in that range if we include zero.
+  // All other ranges (other exponents) have a length of 2**23 elements.
+  if (exponent === -126) {
+    return significand * 0x800000; // significand * 2**23
+  } // Offset due to exp = -126 + Offset of previous exp (excl. -126) + Offset in current exp
+  // 2**24 + (exponent - (-126) -1) * 2**23 + (significand - 1) * 2**23
+
+
+  return (exponent + 127) * 0x800000 + (significand - 1) * 0x800000;
+}
+/**
+ * Compute the 32-bit floating point number corresponding to the provided indexes
+ *
+ * @param n - index of the float
+ *
+ * @internal
+ */
+
+
+function indexToFloat(index) {
+  if (index < 0) {
+    return -indexToFloat(-index - 1);
+  }
+
+  if (index === INDEX_POSITIVE_INFINITY_32) {
+    return Number.POSITIVE_INFINITY;
+  }
+
+  if (index < 0x1000000) {
+    // The first 2**24 elements correspond to values having
+    // exponent = -126 and significand = index * 2**(-23)
+    return index * 2 ** -149;
+  }
+
+  const postIndex = index - 0x1000000; // Math.floor(postIndex / 0x800000) = Math.floor(postIndex / 2**23) = (postIndex >> 23)
+
+  const exponent = -125 + (postIndex >> 23); // (postIndex % 0x800000) / 0x800000 = (postIndex & 0x7fffff) / 0x800000
+
+  const significand = 1 + (postIndex & 0x7fffff) / 0x800000;
+  return significand * 2 ** exponent;
+}
+/** @internal */
+
+
+const Zero64 = {
+  sign: 1,
+  data: [0, 0]
+};
+/** @internal */
+
+exports.Zero64 = Zero64;
+const Unit64 = {
+  sign: 1,
+  data: [0, 1]
+};
+/** @internal */
+
+exports.Unit64 = Unit64;
+
+function isZero64(a) {
+  return a.data[0] === 0 && a.data[1] === 0;
+}
+/** @internal */
+
+
+function isStrictlyNegative64(a) {
+  return a.sign === -1 && !isZero64(a);
+}
+/** @internal */
+
+
+function isStrictlyPositive64(a) {
+  return a.sign === 1 && !isZero64(a);
+}
+/** @internal */
+
+
+function isEqual64(a, b) {
+  if (a.data[0] === b.data[0] && a.data[1] === b.data[1]) {
+    return a.sign === b.sign || a.data[0] === 0 && a.data[1] === 0; // either the same or both zero
+  }
+
+  return false;
+}
+/** @internal */
+
+
+function isStrictlySmaller64Internal(a, b) {
+  return a[0] < b[0] || a[0] === b[0] && a[1] < b[1];
+}
+/** @internal */
+
+
+function isStrictlySmaller64(a, b) {
+  if (a.sign === b.sign) {
+    return a.sign === 1 ? isStrictlySmaller64Internal(a.data, b.data) // a.sign = +1, b.sign = +1
+    : isStrictlySmaller64Internal(b.data, a.data); // a.sign = -1, b.sign = -1
+  } // a.sign = +1, b.sign = -1 is always false
+
+
+  return a.sign === -1 && (!isZero64(a) || !isZero64(b)); // a.sign = -1, b.sign = +1
+}
+/** @internal */
+
+
+function clone64(a) {
+  return {
+    sign: a.sign,
+    data: [a.data[0], a.data[1]]
+  };
+}
+/** @internal */
+
+
+function substract64DataInternal(a, b) {
+  let reminderLow = 0;
+  let low = a[1] - b[1];
+
+  if (low < 0) {
+    reminderLow = 1;
+    low = low >>> 0;
+  }
+
+  return [a[0] - b[0] - reminderLow, low];
+}
+/**
+ * Expects a >= b
+ * @internal
+ */
+
+
+function substract64Internal(a, b) {
+  if (a.sign === 1 && b.sign === -1) {
+    // Operation is a simple sum of a + abs(b)
+    const low = a.data[1] + b.data[1];
+    const high = a.data[0] + b.data[0] + (low > 0xffffffff ? 1 : 0);
+    return {
+      sign: 1,
+      data: [high >>> 0, low >>> 0]
+    };
+  } // a.sign === -1 with b.sign === 1 is impossible given: a - b >= 0, except for a = 0 and b = 0
+  // Operation is a substraction
+
+
+  return {
+    sign: 1,
+    data: a.sign === 1 ? substract64DataInternal(a.data, b.data) : substract64DataInternal(b.data, a.data)
+  };
+}
+/**
+ * Substract two ArrayInt64
+ * @returns When result is zero always with sign=1
+ * @internal
+ */
+
+
+function substract64(arrayIntA, arrayIntB) {
+  if (isStrictlySmaller64(arrayIntA, arrayIntB)) {
+    const out = substract64Internal(arrayIntB, arrayIntA);
+    out.sign = -1;
+    return out;
+  }
+
+  return substract64Internal(arrayIntA, arrayIntB);
+}
+/**
+ * Negative version of an ArrayInt64
+ * @internal
+ */
+
+
+function negative64(arrayIntA) {
+  return {
+    sign: -arrayIntA.sign,
+    data: [arrayIntA.data[0], arrayIntA.data[1]]
+  };
+}
+/**
+ * Add two ArrayInt64
+ * @returns When result is zero always with sign=1
+ * @internal
+ */
+
+
+function add64(arrayIntA, arrayIntB) {
+  if (isZero64(arrayIntB)) {
+    if (isZero64(arrayIntA)) {
+      return clone64(Zero64);
+    }
+
+    return clone64(arrayIntA);
+  }
+
+  return substract64(arrayIntA, negative64(arrayIntB));
+}
+/**
+ * Halve an ArrayInt64
+ * @internal
+ */
+
+
+function halve64(a) {
+  return {
+    sign: a.sign,
+    data: [Math.floor(a.data[0] / 2), (a.data[0] % 2 === 1 ? 0x80000000 : 0) + Math.floor(a.data[1] / 2)]
+  };
+}
+/**
+ * Apply log2 to an ArrayInt64 (preserve sign)
+ * @internal
+ */
+
+
+function logLike64(a) {
+  // Math.floor(Math.log(hi * 2**32 + low) / Math.log(2)) <= Math.floor(Math.log(2**64) / Math.log(2)) = 64
+  return {
+    sign: a.sign,
+    data: [0, Math.floor(Math.log(a.data[0] * 0x100000000 + a.data[1]) / Math.log(2))]
+  };
+}
+/** @internal */
+
+
+const INDEX_POSITIVE_INFINITY = {
+  sign: 1,
+  data: [2146435072, 0]
+}; // doubleToIndex(Number.MAX_VALUE) + 1;
+
+/** @internal */
+
+const INDEX_NEGATIVE_INFINITY = {
+  sign: -1,
+  data: [2146435072, 1]
+}; // doubleToIndex(-Number.MAX_VALUE) - 1
+
+/**
+ * Decompose a 64-bit floating point number into a significand and exponent
+ * such that:
+ * - significand over 53 bits including sign (also referred as fraction)
+ * - exponent over 11 bits including sign
+ * - whenever there are multiple possibilities we take the one having the highest significand (in abs)
+ * - Number.MAX_VALUE = 2**1023    * (1 + (2**52-1)/2**52)
+ *                    = 2**1023    * (2 - Number.EPSILON)
+ * - Number.MIN_VALUE = 2**(-1022) * 2**(-52)
+ * - Number.EPSILON   = 2**(-52)
+ *
+ * @param d - 64-bit floating point number to be decomposed into (significand, exponent)
+ *
+ * @internal
+ */
+
+function decomposeDouble(d) {
+  // 1 => significand 0b1   - exponent 1 (will be preferred)
+  //   => significand 0b0.1 - exponent 2
+  const maxSignificand = 2 - Number.EPSILON;
+
+  for (let exponent = -1022; exponent !== 1024; ++exponent) {
+    const powExponent = 2 ** exponent;
+    const maxForExponent = maxSignificand * powExponent;
+
+    if (Math.abs(d) <= maxForExponent) {
+      return {
+        exponent,
+        significand: d / powExponent
+      };
+    }
+  }
+
+  return {
+    exponent: Number.NaN,
+    significand: Number.NaN
+  };
+}
+/** @internal */
+
+
+function positiveNumberToInt64(n) {
+  return [~~(n / 0x100000000), n >>> 0];
+}
+/** @internal */
+
+
+function indexInDoubleFromDecomp(exponent, significand) {
+  // WARNING: significand >= 0
+  // By construct of significand in decomposeDouble,
+  // significand is always max-ed.
+  // The double close to zero are the only one having a significand <1, they also have an exponent of -1022.
+  // They are in range: [2**(-1022) * 2**(-52), 2**(-1022) * (2 - 2 ** 52)]
+  // In other words there are 2**53 elements in that range if we include zero.
+  // All other ranges (other exponents) have a length of 2**52 elements.
+  if (exponent === -1022) {
+    // We want the significand to be an integer value (like an index)
+    const rescaledSignificand = significand * 2 ** 52; // significand * 2**52
+
+    return positiveNumberToInt64(rescaledSignificand);
+  } // Offset due to exp = -1022 + Offset of previous exp (excl. -1022) + Offset in current exp
+  // 2**53 + (exponent - (-1022) -1) * 2**52 + (significand - 1) * 2**52
+  // (exponent + 1023) * 2**52 + (significand - 1) * 2**52
+
+
+  const rescaledSignificand = (significand - 1) * 2 ** 52; // (significand-1) * 2**52
+
+  const exponentOnlyHigh = (exponent + 1023) * 2 ** 20; // (exponent + 1023) * 2**52 => [high: (exponent + 1023) * 2**20, low: 0]
+
+  const index = positiveNumberToInt64(rescaledSignificand);
+  index[0] += exponentOnlyHigh;
+  return index;
+}
+/**
+ * Compute the index of d relative to other available 64-bit floating point numbers
+ * Rq: Produces negative indexes for negative doubles
+ *
+ * @param d - 64-bit floating point number, anything except NaN
+ *
+ * @internal
+ */
+
+
+function doubleToIndex(d) {
+  if (d === Number.POSITIVE_INFINITY) {
+    return clone64(INDEX_POSITIVE_INFINITY);
+  }
+
+  if (d === Number.NEGATIVE_INFINITY) {
+    return clone64(INDEX_NEGATIVE_INFINITY);
+  }
+
+  const decomp = decomposeDouble(d);
+  const exponent = decomp.exponent;
+  const significand = decomp.significand;
+
+  if (d > 0 || d === 0 && 1 / d === Number.POSITIVE_INFINITY) {
+    return {
+      sign: 1,
+      data: indexInDoubleFromDecomp(exponent, significand)
+    };
+  } else {
+    const indexOpposite = indexInDoubleFromDecomp(exponent, -significand);
+
+    if (indexOpposite[1] === 0xffffffff) {
+      indexOpposite[0] += 1;
+      indexOpposite[1] = 0;
+    } else {
+      indexOpposite[1] += 1;
+    }
+
+    return {
+      sign: -1,
+      data: indexOpposite
+    }; // -indexInDoubleFromDecomp(exponent, -significand) - 1
+  }
+}
+/**
+ * Compute the 64-bit floating point number corresponding to the provided indexes
+ *
+ * @param n - index of the double
+ *
+ * @internal
+ */
+
+
+function indexToDouble(index) {
+  if (index.sign === -1) {
+    const indexOpposite = {
+      sign: 1,
+      data: [index.data[0], index.data[1]]
+    };
+
+    if (indexOpposite.data[1] === 0) {
+      indexOpposite.data[0] -= 1;
+      indexOpposite.data[1] = 0xffffffff;
+    } else {
+      indexOpposite.data[1] -= 1;
+    }
+
+    return -indexToDouble(indexOpposite); // -indexToDouble(-index - 1);
+  }
+
+  if (isEqual64(index, INDEX_POSITIVE_INFINITY)) {
+    return Number.POSITIVE_INFINITY;
+  }
+
+  if (index.data[0] < 0x200000) {
+    // if: index < 2 ** 53  <--> index[0] < 2 ** (53-32) = 0x20_0000
+    // The first 2**53 elements correspond to values having
+    // exponent = -1022 and significand = index * Number.EPSILON
+    // double value = index * 2 ** -1022 * Number.EPSILON
+    //              = index * 2 ** -1022 * 2 ** -52
+    //              = index * 2 ** -1074
+    return (index.data[0] * 0x100000000 + index.data[1]) * 2 ** -1074;
+  }
+
+  const postIndexHigh = index.data[0] - 0x200000; // postIndex = index - 2 ** 53
+  // exponent = -1021 + Math.floor(postIndex / 2**52)
+  //          = -1021 + Math.floor(postIndexHigh / 2**(52-32))
+  //          = -1021 + Math.floor(postIndexHigh / 2**20)
+  //          = -1021 + (postIndexHigh >> 20)
+
+  const exponent = -1021 + (postIndexHigh >> 20); // significand = 1 + (postIndex % 2**52) / 2**52
+  //             = 1 + ((postIndexHigh * 2**32 + postIndexLow) % 2**52) / 2**52
+  //             = 1 + ((postIndexHigh % 2**20) * 2**32 + postIndexLow) / 2**52
+  //             = 1 + ((postIndexHigh & 0xfffff) * 2**32 + postIndexLow) / 2**52
+  //             = 1 + ((postIndexHigh & 0xfffff) * 2**32 + postIndexLow) * Number.EPSILON
+
+  const significand = 1 + ((postIndexHigh & 0xfffff) * 2 ** 32 + index.data[1]) * Number.EPSILON;
+  return significand * 2 ** exponent;
+}
+/**
+ * Same as {@link doubleToIndex} except it throws in case of invalid double
+ *
+ * @internal
+ */
+
+
+function safeDoubleToIndex(d, label) {
+  if (Number.isNaN(d)) {
+    // Number.NaN does not have any associated index in the current implementation
+    return tsplus_module_1.haltNow(new Error("fc.doubleNext constraints." + label + " must be a 32-bit float"), fileName_1 + ":403:22");
+  }
+
+  return tsplus_module_1.succeedNow(doubleToIndex(d), fileName_1 + ":405:23");
+}
+
+const EPSILON = /*#__PURE__*/Math.pow(2, -52);
+const MAX_VALUE = (2 - EPSILON) * /*#__PURE__*/Math.pow(2, 1023);
+const MIN_VALUE = /*#__PURE__*/Math.pow(2, -1022);
+
+function nextUp(x) {
+  if (x !== x) {
+    return x;
+  }
+
+  if (x === -1 / 0) {
+    return -MAX_VALUE;
+  }
+
+  if (x === +1 / 0) {
+    return +1 / 0;
+  }
+
+  if (x === +MAX_VALUE) {
+    return +1 / 0;
+  }
+
+  let y = x * (x < 0 ? 1 - EPSILON / 2 : 1 + EPSILON);
+
+  if (y === x) {
+    y = MIN_VALUE * EPSILON > 0 ? x + MIN_VALUE * EPSILON : x + MIN_VALUE;
+  }
+
+  if (y === +1 / 0) {
+    y = +MAX_VALUE;
+  }
+
+  const b = x + (y - x) / 2;
+
+  if (x < b && b < y) {
+    y = b;
+  }
+
+  const c = (y + x) / 2;
+
+  if (x < c && c < y) {
+    y = c;
+  }
+
+  return y === 0 ? -0 : y;
+}
+
+function nextAfter(x, y) {
+  return y < x ? -nextUp(-x) : y > x ? nextUp(x) : x !== x ? x : y;
+}
+
+function computeBiasedRanges(min, max, biasedRanges) {
+  if (biasedRanges != null) {
+    return biasedRanges;
+  }
+
+  if (isEqual64(min, max)) {
+    return [{
+      min,
+      max
+    }];
+  }
+
+  const minStrictlySmallerThanZero = isStrictlyNegative64(min);
+  const maxStrictlyGreaterThanZero = isStrictlyPositive64(max);
+
+  if (minStrictlySmallerThanZero && maxStrictlyGreaterThanZero) {
+    const logMin = logLike64(min);
+    const logMax = logLike64(max);
+    return [{
+      min: logMin,
+      max: logMax
+    }, {
+      min: substract64(max, logMax),
+      max
+    }, {
+      min,
+      max: substract64(min, logMin)
+    }];
+  } else {
+    const logGap = logLike64(substract64(max, min));
+    const closeToMin = {
+      min,
+      max: add64(min, logGap)
+    };
+    const closeToMax = {
+      min: substract64(max, logGap),
+      max
+    };
+    return minStrictlySmallerThanZero ? [closeToMax, closeToMin] : [closeToMin, closeToMax];
+  }
+}
+
+function computeArrayInt64GenerateRange(min, max, biasFactor, biasedRanges) {
+  return tsplus_module_1.gen(function* (_) {
+    if (biasFactor === undefined || (yield* _(tsplus_module_2.nextIntBetween(1, biasFactor), fileName_1 + ":483:46")) !== 1) {
+      return {
+        min,
+        max
+      };
+    }
+
+    const ranges = computeBiasedRanges(min, max, biasedRanges);
+
+    if (ranges.length === 1) {
+      return ranges[0];
+    }
+
+    const id = yield* _(tsplus_module_2.nextIntBetween(-2 * (ranges.length - 1), ranges.length - 2), fileName_1 + ":490:24");
+    return id < 0 ? ranges[0] : ranges[id + 1];
+  });
+}
+
+function clamp(n, min, max) {
+  return n < min ? min : n > max ? max : n;
+}
+//# sourceMappingURL=math.cjs.map

package/_cjs/util/math.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.cjs","mappings":"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","names":["MIN_VALUE_32","MAX_VALUE_32","EPSILON_32","INDEX_POSITIVE_INFINITY_32","INDEX_NEGATIVE_INFINITY_32","safeFloatToIndex","f","label","conversionTrick","errorMessage","Number","isNaN","isFinite","tsplus_module_1","Error","fileName_1","index","floatToIndex","isInteger","decomposeFloat","maxSignificand","exponent","powExponent","maxForExponent","Math","abs","significand","NaN","POSITIVE_INFINITY","NEGATIVE_INFINITY","indexInFloatFromDecomp","indexToFloat","postIndex","Zero64","sign","data","Unit64","isZero64","a","isStrictlyNegative64","isStrictlyPositive64","isEqual64","b","isStrictlySmaller64Internal","isStrictlySmaller64","clone64","substract64DataInternal","reminderLow","low","substract64Internal","high","substract64","arrayIntA","arrayIntB","out","negative64","add64","halve64","floor","logLike64","log","INDEX_POSITIVE_INFINITY","INDEX_NEGATIVE_INFINITY","decomposeDouble","d","EPSILON","positiveNumberToInt64","n","indexInDoubleFromDecomp","rescaledSignificand","exponentOnlyHigh","doubleToIndex","decomp","indexOpposite","indexToDouble","postIndexHigh","safeDoubleToIndex","pow","MAX_VALUE","MIN_VALUE","nextUp","x","y","c","nextAfter","computeBiasedRanges","min","max","biasedRanges","minStrictlySmallerThanZero","maxStrictlyGreaterThanZero","logMin","logMax","logGap","closeToMin","closeToMax","computeArrayInt64GenerateRange","biasFactor","_","undefined","tsplus_module_2","ranges","length","id","clamp"],"sourceRoot":"","sources":["../../_src/util/math.ts"],"sourcesContent":[null]}