openalgo-script 0.6.0 → 0.7.0

package/src/core/stdlib/averages/exponential.ts

@@ -27,8 +27,7 @@ export function emaStep(
   value: Value,
   len: number | null,
 ): Value {
-  if (len === null) return NONE;
-  const weight = 2 / (len + 1);
+  const weight = len === null ? 0 : 2 / (len + 1);
   const rest = 1 - weight;
   return smoothed(state, key, len, value, (previous, next) => next * weight + previous * rest);
 }
@@ -50,8 +49,8 @@ export function rmaStep(
   value: Value,
   len: number | null,
 ): Value {
-  if (len === null) return NONE;
-  return smoothed(state, key, len, value, (previous, next) => (previous * (len - 1) + next) / len);
+  const span = len ?? 1;
+  return smoothed(state, key, len, value, (previous, next) => (previous * (span - 1) + next) / span);
 }
 
 /** `rma(src, len)` as a tail. */

package/src/core/stdlib/averages/gaussian.ts

@@ -0,0 +1,52 @@
+/** Pure immutable Gaussian coefficients, outside all checkpoint state. */
+import { exp } from '../maths/index.js';
+
+interface Kernel { readonly weights: readonly number[]; readonly norm: number }
+const view = new DataView(new ArrayBuffer(8));
+function keyOf(value: number): string {
+  view.setFloat64(0, value);
+  return view.getBigUint64(0).toString(16);
+}
+
+/** Internal cache with independently bounded entry and coefficient counts. */
+export class GaussianCache {
+  private readonly entries = new Map<string, Kernel>();
+  private count = 0;
+  get size(): number { return this.entries.size; }
+  get coefficients(): number { return this.count; }
+
+  get(length: number, offset: number, sigma: number): Kernel | null {
+    if (!Number.isFinite(offset) || !Number.isFinite(sigma) || !(sigma > 0)) return null;
+    const key = `${keyOf(length)}/${keyOf(offset)}/${keyOf(sigma)}`;
+    const held = this.entries.get(key);
+    if (held !== undefined) return held;
+    const peak = offset * (length - 1), spread = length / sigma;
+    const denominator = (2 * spread) * spread;
+    if (denominator === 0) return null;
+    const weights: number[] = [];
+    let norm = 0;
+    for (let position = 0; position < length; position++) {
+      const gap = position - peak, exponent = -(gap * gap) / denominator;
+      // Internal limiting weight; the public exp still rejects infinities.
+      const weight = exponent === -Infinity ? 0 : exp(exponent);
+      if (typeof weight !== 'number') return null;
+      weights.push(weight); norm += weight;
+    }
+    if (norm === 0) return null;
+    const computed = Object.freeze({ weights: Object.freeze(weights), norm });
+    if (length <= 4096) {
+      while (this.entries.size >= 8 || this.count + length > 4096) {
+        const oldest = this.entries.keys().next().value as string;
+        this.count -= (this.entries.get(oldest) as Kernel).weights.length;
+        this.entries.delete(oldest);
+      }
+      this.entries.set(key, computed); this.count += length;
+    }
+    return computed;
+  }
+}
+
+const cache = new GaussianCache();
+export function gaussianWeights(length: number, offset: number, sigma: number): Kernel | null {
+  return cache.get(length, offset, sigma);
+}

package/src/core/stdlib/averages/shaped.ts

@@ -17,6 +17,7 @@ import {
 import { roundHalfAway } from '../maths/index.js';
 
 import { wmaStep } from './simple.js';
+import { gaussianWeights } from './gaussian.js';
 
 /**
  * `hma(src, len)`: from bar `len + round(sqrt(len)) - 2`.
@@ -37,9 +38,8 @@ export function hmaStep(
   value: Value,
   len: number | null,
 ): Value {
-  if (len === null) return NONE;
-  const half = Math.max(1, Math.floor(len / 2));
-  const outer = Math.max(1, roundHalfAway(Math.sqrt(len)));
+  const half = len === null ? null : Math.max(1, Math.floor(len / 2));
+  const outer = len === null ? null : Math.max(1, roundHalfAway(Math.sqrt(len)));
   const near = wmaStep(state, `${key}f`, value, half);
   const far = wmaStep(state, `${key}s`, value, len);
   const raw = isPresent(near) && isPresent(far) ? result(2 * near - far) : NONE;
@@ -62,12 +62,8 @@ export function hma(src: Series, len: number): Value[] {
  * `offset` slides the kernel's peak between lag and smoothness and `sigma` sets
  * how sharply it falls away.
  *
- * The kernel depends only on the position in the lookback, so it could be built
- * once; it is rebuilt each bar instead, because the region 2.11 requires holds
- * numbers and queues and not a cached array of weights, and a step that reads
- * its own arguments every bar is the only form an engine can drive. The
- * accumulation is over the lookback in index order either way, so the number is
- * the same one.
+ * A bounded pure cache holds immutable coefficients keyed by the current
+ * parameters. Source observations remain exclusively in the copyable region.
  */
 export function almaStep(
   state: StateRecord,
@@ -82,18 +78,9 @@ export function almaStep(
   if (len === null || offset === null || sigma === null) return NONE;
   if (!lookback.complete()) return NONE;
   if (!(sigma > 0) || !isLength(len)) return NONE;
-  const peak = offset * (len - 1);
-  const spread = len / sigma;
-  const weights: number[] = [];
-  let norm = 0;
-  // Index order: position 0 is the oldest bar in the lookback.
-  for (let position = 0; position < len; position += 1) {
-    const gap = position - peak;
-    const weight = Math.exp(-(gap * gap) / (2 * spread * spread));
-    weights.push(weight);
-    norm += weight;
-  }
-  if (norm === 0) return NONE;
+  const kernel = gaussianWeights(len, offset, sigma);
+  if (kernel === null) return NONE;
+  const { weights, norm } = kernel;
   let total = 0;
   for (let position = 0; position < len; position += 1) {
     total += (lookback.at(len - 1 - position) as number) * (weights[position] as number);

package/src/core/stdlib/maths/arithmetic.ts

@@ -65,7 +65,8 @@ export function isNone(x: Value): boolean {
 
 /** `x` when present, `fallback` when absent. */
 export function orElse(x: Value, fallback: Value): Value {
-  return isPresent(x) ? x : fallback;
+  const value = isPresent(x) ? x : fallback;
+  return value === 0 ? 0 : value;
 }
 
 /** `toBool(x)`: absence to false, a bool to itself. Numbers are a type error. */

package/src/core/stdlib/maths/elementary.ts

@@ -1,27 +1,14 @@
 /**
- * Square root, the logarithms, the powers and the trigonometry.
- *
- * **A gap, stated here rather than discovered later.**
- * `compiled-program.md` section 8.3 requires that the transcendental functions
- * not use the platform's own maths library, because a platform implementation
- * is correct to within an ulp or so and differs between platforms in the last
- * bit, which this project has declared a release blocker. It names the portable
- * reference algorithm as living in the library manifest. **That manifest does
- * not exist yet**, so there is nothing to implement against, and the functions
- * below call the host until it does. Everything in this file except `sqrt` is
- * therefore portable in value but not yet guaranteed in the last bit.
- *
- * `sqrt` is the exception and is not affected: IEEE-754 requires it to be
- * correctly rounded, so every conforming platform returns the same bits.
- *
- * The consequence is worth stating plainly, because it decides what is safe to
- * gate on today. Of the five gate studies, EMA, RSI, MACD, Bollinger Bands and
- * Supertrend, four use only addition, subtraction, multiplication and division,
- * and Bollinger Bands adds `sqrt`. None of them reaches this file's uncertain
- * half. The functions that do are `alma` (exp), `hv` (log) and `chop` (log10).
+ * Elementary functions. Hypotenuse and exp/log use sections 20.10.1 and
+ * 20.10.2; power and trigonometry use sections 20.10.3 and 20.10.4.
+ * Square root uses its correctly rounded host operation.
  */
 import type { Value } from '../values/index.js';
 import { NONE, isPresent, result } from '../values/index.js';
+import { hypotenuse } from './hypot.js';
+import { transcendental } from './transcendental.js';
+import { power } from './power.js';
+import { trigonometric } from './trigonometric.js';
 
 /**
  * `sqrt(x)`: square root, absent below zero.
@@ -37,30 +24,30 @@ export function sqrt(x: Value): Value {
 /** `pow(x, y)`: absent where the result is not a finite real. */
 export function pow(x: Value, y: Value): Value {
   if (!isPresent(x) || !isPresent(y)) return NONE;
-  return result(Math.pow(x, y));
+  return power(x, y);
 }
 
 /** `exp(x)`: e to the power x. */
 export function exp(x: Value): Value {
-  return isPresent(x) ? result(Math.exp(x)) : NONE;
+  return isPresent(x) ? transcendental('exp', x) : NONE;
 }
 
 /** `log(x)`: natural logarithm, absent at or below zero. */
 export function log(x: Value): Value {
   if (!isPresent(x) || x <= 0) return NONE;
-  return result(Math.log(x));
+  return transcendental('log', x);
 }
 
 /** `log10(x)`: base ten logarithm, absent at or below zero. */
 export function log10(x: Value): Value {
   if (!isPresent(x) || x <= 0) return NONE;
-  return result(Math.log10(x));
+  return transcendental('log10', x);
 }
 
 /** `math.log2(x)`: base two logarithm, absent at or below zero. */
 export function log2(x: Value): Value {
   if (!isPresent(x) || x <= 0) return NONE;
-  return result(Math.log2(x));
+  return transcendental('log2', x);
 }
 
 /** The circle constant. */
@@ -72,7 +59,7 @@ export const E: number = Math.E;
 /** `math.hypot(x, y)`: `sqrt(x * x + y * y)` without intermediate overflow. */
 export function hypot(x: Value, y: Value): Value {
   if (!isPresent(x) || !isPresent(y)) return NONE;
-  return result(Math.hypot(x, y));
+  return hypotenuse(x, y);
 }
 
 /** `math.toDegrees(x)`: radians to degrees. */
@@ -87,38 +74,38 @@ export function toRadians(x: Value): Value {
 
 /** `math.sin(x)`: sine of an angle in radians. */
 export function sin(x: Value): Value {
-  return isPresent(x) ? result(Math.sin(x)) : NONE;
+  return isPresent(x) ? trigonometric('sin', x) : NONE;
 }
 
 /** `math.cos(x)`: cosine. */
 export function cos(x: Value): Value {
-  return isPresent(x) ? result(Math.cos(x)) : NONE;
+  return isPresent(x) ? trigonometric('cos', x) : NONE;
 }
 
 /** `math.tan(x)`: tangent. */
 export function tan(x: Value): Value {
-  return isPresent(x) ? result(Math.tan(x)) : NONE;
+  return isPresent(x) ? trigonometric('tan', x) : NONE;
 }
 
 /** `math.asin(x)`: inverse sine, absent outside -1 to 1. */
 export function asin(x: Value): Value {
   if (!isPresent(x) || x < -1 || x > 1) return NONE;
-  return result(Math.asin(x));
+  return trigonometric('asin', x);
 }
 
 /** `math.acos(x)`: inverse cosine, absent outside -1 to 1. */
 export function acos(x: Value): Value {
   if (!isPresent(x) || x < -1 || x > 1) return NONE;
-  return result(Math.acos(x));
+  return trigonometric('acos', x);
 }
 
 /** `math.atan(x)`: inverse tangent. */
 export function atan(x: Value): Value {
-  return isPresent(x) ? result(Math.atan(x)) : NONE;
+  return isPresent(x) ? trigonometric('atan', x) : NONE;
 }
 
 /** `math.atan2(y, x)`: angle of a vector, correct in all four quadrants. */
 export function atan2(y: Value, x: Value): Value {
   if (!isPresent(y) || !isPresent(x)) return NONE;
-  return result(Math.atan2(y, x));
+  return trigonometric('atan2', y, x);
 }

package/src/core/stdlib/maths/hypot.ts

@@ -0,0 +1,63 @@
+/** Exact two-argument hypotenuse, `stdlib.md` section 20.10.1. */
+const view = new DataView(new ArrayBuffer(8));
+const LEADING = 1n << 52n;
+const FRACTION = LEADING - 1n;
+
+function parts(value: number): { significand: bigint; exponent: number } {
+  view.setFloat64(0, Math.abs(value), false);
+  const encoded = view.getBigUint64(0, false);
+  const exponent = Number(encoded >> 52n);
+  return {
+    significand: (encoded & FRACTION) | (exponent === 0 ? 0n : LEADING),
+    exponent: exponent === 0 ? -1074 : exponent - 1075,
+  };
+}
+
+function decode(encoded: bigint): number {
+  view.setBigUint64(0, encoded, false);
+  return view.getFloat64(0, false);
+}
+
+/** A power-of-two upper bound makes integer Newton steps decrease to the floor. */
+export function integerSqrt(value: bigint): bigint {
+  if (value < 2n) return value;
+  let before = 1n << BigInt(Math.ceil(value.toString(2).length / 2));
+  for (;;) {
+    const next = (before + value / before) >> 1n;
+    if (next >= before) return before;
+    before = next;
+  }
+}
+
+/**
+ * Keep the squared sum exact, then compare against a squared rounding midpoint.
+ * Binary64 input widths bound every temporary integer to fewer than 4,200 bits.
+ */
+export function hypotenuse(x: number, y: number): number | null {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  if (x === 0) return Math.abs(y);
+  if (y === 0) return Math.abs(x);
+  const a = parts(x);
+  const b = parts(y);
+  const exponent = Math.min(a.exponent, b.exponent);
+  const square = (a.significand * a.significand << BigInt(2 * (a.exponent - exponent))) +
+    (b.significand * b.significand << BigInt(2 * (b.exponent - exponent)));
+  const top = square.toString(2).length - 1;
+  let spacing = Math.max(-1074, exponent + Math.floor(top / 2) - 52);
+  const shift = exponent - spacing;
+  const numerator = shift < 0 ? square : square << BigInt(2 * shift);
+  const denominator = shift < 0 ? 1n << BigInt(-2 * shift) : 1n;
+  let significand = integerSqrt(numerator / denominator);
+  const midpoint = 2n * significand + 1n;
+  const comparison = 4n * numerator - denominator * midpoint * midpoint;
+  if (comparison > 0n || comparison === 0n && (significand & 1n) !== 0n) significand += 1n;
+  if (significand >= 2n * LEADING) {
+    significand >>= 1n;
+    spacing += 1;
+  }
+  // Encoding after rounding avoids a second rounding through a floating scale.
+  if (significand < LEADING) return decode(significand);
+  const encodedExponent = spacing + 1075;
+  if (encodedExponent >= 2047) return null;
+  return decode(BigInt(encodedExponent) << 52n | (significand - LEADING));
+}

package/src/core/stdlib/maths/power.ts

@@ -0,0 +1,57 @@
+/** Exact real power rounded once, following section 20.10.3. */
+import { integerSqrt } from './hypot.js';
+import { ceil, exponentialEndpoint, floor, logarithm, parts, rounded } from './transcendental.js';
+
+function oddParts(value: number): readonly [bigint, number] {
+  let [integer, exponent] = parts(value);
+  while ((integer & 1n) === 0n) { integer >>= 1n; exponent++; }
+  return [integer, exponent];
+}
+
+/** Undefined requests intervals; null is an exactly determined overflow. */
+function rationalResult(base: number, exponent: number): number | null | undefined {
+  let [odd, scale] = oddParts(base);
+  let [numerator, shift] = oddParts(exponent);
+  if (shift >= 0) numerator <<= BigInt(shift);
+  else for (; shift < 0; shift++) {
+    if (scale % 2 !== 0) return undefined;
+    const root = integerSqrt(odd);
+    if (root * root !== odd) return undefined;
+    odd = root; scale /= 2;
+  }
+  if (odd === 1n) {
+    const power = BigInt(scale) * numerator * (exponent < 0 ? -1n : 1n);
+    if (power > 1023n) return null;
+    if (power < -1075n) return 0;
+    return rounded(1n, Number(power));
+  }
+  // These exact odd powers include every possible dyadic rounding midpoint.
+  if (exponent > 0 && numerator <= 53n) return rounded(odd ** numerator, scale * Number(numerator));
+  return undefined;
+}
+
+/** Internal kernel; a lower starting precision exposes refinement to tests. */
+export function power(base: number, exponent: number, initialPrecision = 160): number | null {
+  if (!Number.isFinite(base) || !Number.isFinite(exponent)) return null;
+  if (exponent === 0) return 1;
+  if (base === 0) return exponent > 0 ? 0 : null;
+  if (base < 0 && !Number.isInteger(exponent)) return null;
+  const sign = base < 0 && exponent % 2 !== 0 ? -1 : 1;
+  const magnitude = Math.abs(base);
+  if (magnitude === 1) return sign;
+  const signed = (value: number | null): number | null => value === null ? null : value === 0 ? 0 : sign * value;
+  const exact = rationalResult(magnitude, exponent);
+  if (exact !== undefined) return signed(exact);
+  const [multiplier, shift] = parts(exponent);
+  for (let precision = Math.max(64, initialPrecision); ; precision += 80) {
+    let [low, high] = logarithm(magnitude, precision);
+    low *= multiplier; high *= multiplier;
+    if (shift >= 0) { low <<= BigInt(shift); high <<= BigInt(shift); }
+    else { const divisor = 1n << BigInt(-shift); low = floor(low, divisor); high = ceil(high, divisor); }
+    if (exponent < 0) [low, high] = [-high, -low];
+    const below = exponentialEndpoint(low, precision), above = exponentialEndpoint(high, precision);
+    if (below === undefined || above === undefined) continue;
+    const left = below[0], right = above[1];
+    if (Object.is(left, right)) return signed(left);
+  }
+}

package/src/core/stdlib/maths/transcendental.ts

@@ -0,0 +1,160 @@
+/** Exact integer enclosures for section 20.10.2. No host elementary calls. */
+export type ElementaryKind = 'exp' | 'log' | 'log10' | 'log2';
+export type Interval = readonly [bigint, bigint];
+const view = new DataView(new ArrayBuffer(8));
+const mask = (1n << 52n) - 1n;
+let defaultTwo: Interval | undefined;
+let defaultTen: Interval | undefined;
+
+export const bitLength = (x: bigint): number => x === 0n ? 0 : x.toString(2).length;
+export const floor = (n: bigint, d: bigint): bigint => n >= 0n ? n / d : -((-n + d - 1n) / d);
+export const ceil = (n: bigint, d: bigint): bigint => -floor(-n, d);
+
+export function parts(x: number): readonly [bigint, number] {
+  view.setFloat64(0, Math.abs(x));
+  const bits = view.getBigUint64(0), exponent = Number(bits >> 52n);
+  return [exponent === 0 ? bits : (bits & mask) | (1n << 52n), exponent === 0 ? -1074 : exponent - 1075];
+}
+
+function fixed(x: number, precision: number): Interval {
+  const [m, e] = parts(x), shift = e + precision;
+  return shift >= 0 ? [m << BigInt(shift), m << BigInt(shift)]
+    : [m >> BigInt(-shift), ceil(m, 1n << BigInt(-shift))];
+}
+
+/** Round an exact dyadic endpoint directly, with the subnormal spacing floor. */
+export function rounded(numerator: bigint, exponent: number): number | null {
+  if (numerator === 0n) return 0;
+  const negative = numerator < 0n;
+  const magnitude = negative ? -numerator : numerator;
+  let spacing = Math.max(-1074, bitLength(magnitude) - 1 + exponent - 52);
+  const shift = spacing - exponent;
+  let significand: bigint;
+  if (shift <= 0) significand = magnitude << BigInt(-shift);
+  else {
+    const divisor = 1n << BigInt(shift), remainder = magnitude % divisor;
+    significand = magnitude / divisor;
+    if (remainder * 2n > divisor || (remainder * 2n === divisor && (significand & 1n))) significand++;
+  }
+  if (significand === 0n) return 0;
+  if (significand >= 1n << 53n) { significand >>= 1n; spacing++; }
+  if (spacing > 971) return null;
+  const bits = significand < 1n << 52n ? significand
+    : (BigInt(spacing + 1075) << 52n) | (significand & mask);
+  view.setBigUint64(0, bits | (negative ? 1n << 63n : 0n));
+  return view.getFloat64(0);
+}
+
+/** Twice the positive odd-power sum, for 0 <= a/b <= 1/3. */
+function oddSeries(a: bigint, b: bigint, precision: number): Interval {
+  if (a === 0n) return [0n, 0n];
+  const unit = 1n << BigInt(precision), low = a * unit / b, high = ceil(a * unit, b);
+  const squaredLow = low * low / unit, squaredHigh = ceil(high * high, unit);
+  let powerLow = low, powerHigh = high, sumLow = 0n, sumHigh = 0n, odd = 1n;
+  for (;;) {
+    sumLow += powerLow / odd; sumHigh += ceil(powerHigh, odd);
+    powerLow = powerLow * squaredLow / unit;
+    powerHigh = ceil(powerHigh * squaredHigh, unit); odd += 2n;
+    if (powerHigh <= 2n) return [2n * sumLow, 2n * (sumHigh + ceil(9n * powerHigh, 8n * odd))];
+  }
+}
+
+function lnTwo(precision: number): Interval {
+  if (precision !== 160) return oddSeries(1n, 3n, precision);
+  return defaultTwo ??= oddSeries(1n, 3n, precision);
+}
+
+export function logarithm(x: number, precision: number): Interval {
+  const [m, e] = parts(x), width = bitLength(m), one = 1n << BigInt(width - 1);
+  const k = BigInt(e + width - 1), [low, high] = oddSeries(m - one, m + one, precision);
+  const [constantLow, constantHigh] = lnTwo(precision);
+  return k >= 0n ? [low + k * constantLow, high + k * constantHigh]
+    : [low + k * constantHigh, high + k * constantLow];
+}
+
+function lnTen(precision: number): Interval {
+  if (precision !== 160) return logarithm(10, precision);
+  return defaultTen ??= logarithm(10, precision);
+}
+
+function quotient(numerator: Interval, denominator: Interval, precision: number): Interval {
+  const unit = 1n << BigInt(precision);
+  let low: bigint | undefined, high: bigint | undefined;
+  for (const n of numerator) for (const d of denominator) {
+    const below = floor(n * unit, d), above = ceil(n * unit, d);
+    if (low === undefined || below < low) low = below;
+    if (high === undefined || above > high) high = above;
+  }
+  return [low as bigint, high as bigint];
+}
+
+function exponentialRange(low: bigint, high: bigint, positive: boolean, precision: number): readonly [bigint, bigint, number] | undefined {
+  const unit = 1n << BigInt(precision);
+  const [constantLow, constantHigh] = lnTwo(precision), k = low / constantHigh;
+  const reducedLow = low - k * constantHigh, reducedHigh = high - k * constantLow;
+  if (reducedLow < 0n || reducedHigh >= unit) return undefined;
+  let termLow = unit, termHigh = unit, sumLow = unit, sumHigh = unit, n = 0n;
+  for (;;) {
+    n++;
+    termLow = termLow * reducedLow / (unit * n);
+    termHigh = ceil(termHigh * reducedHigh, unit * n);
+    if (termHigh <= 1n) { sumHigh += 2n * termHigh; break; }
+    sumLow += termLow; sumHigh += termHigh;
+  }
+  return positive ? [sumLow, sumHigh, Number(k) - precision]
+    : [unit * unit / sumHigh, ceil(unit * unit, sumLow), -Number(k) - precision];
+}
+
+/** Enclose exp(integer / 2**precision) without a binary64 intermediate. */
+export function exponentialEndpoint(integer: bigint, precision: number): readonly [number | null, number | null] | undefined {
+  const cutoff = 1024n << BigInt(precision);
+  if (integer >= cutoff) return [null, null];
+  if (integer <= -cutoff) return [0, 0];
+  if (integer === 0n) return [1, 1];
+  const magnitude = integer < 0n ? -integer : integer;
+  const range = exponentialRange(magnitude, magnitude, integer > 0n, precision);
+  if (range === undefined) return undefined;
+  const [low, high, exponent] = range;
+  return [rounded(low, exponent), rounded(high, exponent)];
+}
+
+/** Internal kernel. The optional starting precision permits refinement tests. */
+export function transcendental(kind: ElementaryKind, x: number, initialPrecision = 160): number | null {
+  if (!Number.isFinite(x) || (kind !== 'exp' && x <= 0)) return null;
+  if (kind === 'exp') {
+    if (x >= 1024) return null;
+    if (x <= -1024) return 0;
+    if (Math.abs(x) < 2 ** -60) return 1;
+  } else {
+    if (x === 1) return 0;
+    if (kind === 'log2') {
+      const [m, e] = parts(x);
+      if ((m & (m - 1n)) === 0n) return e + bitLength(m) - 1;
+    }
+    if (kind === 'log10') {
+      const [m, e] = parts(x);
+      let integer = e >= 0 ? m << BigInt(e)
+        : m % (1n << BigInt(-e)) === 0n ? m >> BigInt(-e) : 0n;
+      let count = 0;
+      while (integer > 1n && integer % 10n === 0n) { integer /= 10n; count++; }
+      if (integer === 1n) return count;
+    }
+  }
+  for (let precision = Math.max(64, initialPrecision); ; precision += 80) {
+    let low: bigint, high: bigint, exponent: number;
+    if (kind === 'exp') {
+      const [start, end] = fixed(x, precision);
+      const range = exponentialRange(start, end, x >= 0, precision);
+      if (range === undefined) continue;
+      [low, high, exponent] = range;
+    }
+    else {
+      const natural = logarithm(x, precision);
+      [low, high] = kind === 'log' ? natural
+        : quotient(natural, kind === 'log2' ? lnTwo(precision) : lnTen(precision), precision);
+      exponent = -precision;
+    }
+    const left = rounded(low, exponent), right = rounded(high, exponent);
+    if (Object.is(left, right)) return left;
+  }
+}