not-so-float 0.0.1 → 1.0.1

package/dist/index.js

@@ -1,8 +1,700 @@
-// src/index.ts
-function hello() {
-  console.log("hello");
+// src/nextafter.ts
+var buffer = new ArrayBuffer(8);
+var floatView = new Float64Array(buffer);
+var intView = new BigUint64Array(buffer);
+function next(x) {
+  if (x === Infinity) return x;
+  if (x === 0) return Number.MIN_VALUE;
+  floatView[0] = x;
+  let bits = intView[0];
+  if (x > 0) {
+    bits += 1n;
+  } else {
+    bits -= 1n;
+  }
+  intView[0] = bits;
+  return floatView[0];
 }
+function prev(x) {
+  if (x === -Infinity) return x;
+  if (x === 0) return -Number.MIN_VALUE;
+  floatView[0] = x;
+  let bits = intView[0];
+  if (x < 0) {
+    bits += 1n;
+  } else {
+    bits -= 1n;
+  }
+  intView[0] = bits;
+  return floatView[0];
+}
+
+// src/interval.ts
+var defaultNumbers = (x) => x.toString();
+var Interval = class {
+  constructor(lo, hi) {
+    this.lo = lo;
+    this.hi = hi;
+  }
+  isFull() {
+    return this.lo === -Infinity && this.hi === Infinity;
+  }
+  isFinite() {
+    return isFinite(this.lo) && isFinite(this.hi);
+  }
+  isDegenerate() {
+    return this.lo === this.hi;
+  }
+  contains(value) {
+    return this.lo <= value && value <= this.hi;
+  }
+  superset(other) {
+    return this.contains(other.lo) && this.contains(other.hi);
+  }
+  subset(other) {
+    return other.superset(this);
+  }
+  toString(numbers = defaultNumbers) {
+    return `[${numbers(this.lo)}, ${numbers(this.hi)}]`;
+  }
+  print() {
+    console.log(this.toString());
+  }
+};
+function typeCheckIntervalBound(v) {
+  if (typeof v !== "number") {
+    throw TypeError(`Interval bounds must be a number, got ${typeof v}`);
+  }
+  if (isNaN(v)) {
+    throw TypeError(`Interval bounds must not be NaN`);
+  }
+}
+function interval(a, b) {
+  if (typeof b === "undefined") {
+    b = a;
+  }
+  typeCheckIntervalBound(a);
+  typeCheckIntervalBound(b);
+  if (a > b) {
+    throw TypeError("Interval bound must be such that lo <= hi");
+  }
+  if (a === Infinity) {
+    throw TypeError("Interval lower bound cannot be Infinity");
+  }
+  if (b === -Infinity) {
+    throw TypeError("Interval lower bound cannot be -Infinity");
+  }
+  return new Interval(a, b);
+}
+var inter = interval;
+var FULL = new Interval(-Infinity, Infinity);
+function typeCheckIsInterval(x) {
+  if (!(x instanceof Interval)) {
+    throw TypeError(`Argument must be an interval (got type ${typeof x})`);
+  }
+  return true;
+}
+
+// src/union.ts
+var Union = class {
+  constructor(intervals) {
+    this.intervals = intervals;
+  }
+  isEmpty() {
+    return this.intervals.length === 0;
+  }
+  lower() {
+    if (this.isEmpty()) return Infinity;
+    return this.intervals[0].lo;
+  }
+  upper() {
+    if (this.isEmpty()) return -Infinity;
+    return this.intervals[this.intervals.length - 1].hi;
+  }
+  contains(value) {
+    return this.intervals.some((i) => i.contains(value));
+  }
+  forEach(callback) {
+    this.intervals.forEach(callback);
+  }
+  toString(numbers = defaultNumbers) {
+    if (this.intervals.length === 0) return "{\u2205}";
+    return this.intervals.map((i) => i.toString(numbers)).join(" U ");
+  }
+  print() {
+    console.log(this.toString());
+  }
+};
+function union(intervals) {
+  if (intervals.length <= 1) {
+    return new Union(intervals);
+  }
+  intervals.sort((x, y) => x.lo - y.lo);
+  const merged = [intervals[0]];
+  for (let i = 1; i < intervals.length; i++) {
+    const last = merged[merged.length - 1];
+    const curr = intervals[i];
+    if (curr.lo <= last.hi) {
+      merged[merged.length - 1] = new Interval(last.lo, Math.max(last.hi, curr.hi));
+    } else {
+      merged.push(curr);
+    }
+  }
+  return new Union(merged);
+}
+function typeCheckIsUnion(U) {
+  if (!(U instanceof Union)) {
+    throw TypeError(`Argument must be a Union (got type ${typeof U})`);
+  }
+  return true;
+}
+function toUnion(x) {
+  if (x instanceof Interval) return new Union([x]);
+  return x;
+}
+function makeUnaryOpUnion(op) {
+  return (U) => {
+    typeCheckIsUnion(U);
+    const results = [];
+    U.forEach((X) => {
+      results.push(...op(X).intervals);
+    });
+    return union(results);
+  };
+}
+function makeBinaryOpUnion(op) {
+  return (U, V) => {
+    typeCheckIsUnion(U);
+    typeCheckIsUnion(V);
+    const results = [];
+    U.forEach((X, i) => {
+      V.forEach((Y) => {
+        results.push(...op(X, Y).intervals);
+      });
+    });
+    return union(results);
+  };
+}
+function isIntervalOrUnion(x) {
+  return x instanceof Interval || x instanceof Union;
+}
+function typeCheckIsIntervalOrUnion(x) {
+  if (!isIntervalOrUnion(x)) {
+    throw TypeError("Argument must be of type Interval or Union");
+  }
+  return true;
+}
+function makeUnaryOpEither(op) {
+  return (A) => {
+    typeCheckIsIntervalOrUnion(A);
+    return op(toUnion(A));
+  };
+}
+function makeBinaryOpEither(op) {
+  return (A, B) => {
+    typeCheckIsIntervalOrUnion(A);
+    typeCheckIsIntervalOrUnion(B);
+    return op(toUnion(A), toUnion(B));
+  };
+}
+function bounded(x) {
+  return new Union([new Interval(prev(x), next(x))]);
+}
+var EMPTY = new Union([]);
+
+// src/compare.ts
+function ioverlap(a, b) {
+  return a.lo <= b.lo && b.lo <= a.hi || b.lo <= a.lo && a.lo <= b.hi;
+}
+function idisjoint(a, b) {
+  return a.hi < b.lo || a.lo > b.hi;
+}
+function iuoverlap(X, U) {
+  return U.intervals.some((Y) => ioverlap(X, Y));
+}
+function iudisjoint(X, U) {
+  return U.intervals.every((Y) => idisjoint(X, Y));
+}
+function overlap(A, B) {
+  typeCheckIsIntervalOrUnion(A);
+  typeCheckIsIntervalOrUnion(B);
+  const Bunion = toUnion(B);
+  return toUnion(A).intervals.some((X) => iuoverlap(X, Bunion));
+}
+function disjoint(A, B) {
+  typeCheckIsIntervalOrUnion(A);
+  typeCheckIsIntervalOrUnion(B);
+  const Bunion = toUnion(B);
+  return toUnion(A).intervals.every((X) => iudisjoint(X, Bunion));
+}
+
+// src/arithmetic.ts
+function leftAdd(a, b) {
+  if (a === 0) {
+    return b;
+  } else if (b === 0) {
+    return a;
+  }
+  return prev(a + b);
+}
+function rightAdd(a, b) {
+  if (a === 0) {
+    return b;
+  } else if (b === 0) {
+    return a;
+  }
+  return next(a + b);
+}
+function iadd(x, y) {
+  typeCheckIsInterval(x);
+  typeCheckIsInterval(y);
+  return new Union([new Interval(leftAdd(x.lo, y.lo), rightAdd(x.hi, y.hi))]);
+}
+function ineg(x) {
+  typeCheckIsInterval(x);
+  return new Interval(-x.hi, -x.lo);
+}
+function isub(x, y) {
+  return iadd(x, ineg(y));
+}
+function leftMul(a, b) {
+  if (a === 0 || b === 0) {
+    return 0;
+  }
+  return prev(a * b);
+}
+function rightMul(a, b) {
+  if (a === 0 || b === 0) {
+    return 0;
+  }
+  return next(a * b);
+}
+function imul(x, y) {
+  typeCheckIsInterval(x);
+  typeCheckIsInterval(y);
+  const [a, b] = [x.lo, x.hi];
+  const [c, d] = [y.lo, y.hi];
+  if (b < 0) {
+    if (d < 0) {
+      return new Union([new Interval(leftMul(b, d), rightMul(a, c))]);
+    } else if (c > 0) {
+      return new Union([new Interval(leftMul(a, d), rightMul(b, c))]);
+    } else {
+      return new Union([new Interval(leftMul(a, d), rightMul(a, c))]);
+    }
+  } else if (a > 0) {
+    if (d < 0) {
+      return new Union([new Interval(leftMul(b, c), rightMul(a, d))]);
+    } else if (c > 0) {
+      return new Union([new Interval(leftMul(a, c), rightMul(b, d))]);
+    } else {
+      return new Union([new Interval(leftMul(b, c), rightMul(b, d))]);
+    }
+  } else {
+    if (d < 0) {
+      return new Union([new Interval(leftMul(b, c), rightMul(a, c))]);
+    } else if (c > 0) {
+      return new Union([new Interval(leftMul(a, d), rightMul(b, d))]);
+    } else {
+      return new Union([
+        new Interval(
+          Math.min(leftMul(a, d), leftMul(b, c)),
+          Math.max(rightMul(a, c), rightMul(b, d))
+        )
+      ]);
+    }
+  }
+}
+function leftDiv(a, b) {
+  if (b === Infinity) {
+    return Math.sign(a) * 0;
+  }
+  if (b === -Infinity) {
+    return Math.sign(-a) * 0;
+  }
+  return prev(a / b);
+}
+function rightDiv(a, b) {
+  if (b === Infinity) {
+    return Math.sign(a) * 0;
+  }
+  if (b === -Infinity) {
+    return Math.sign(-a) * 0;
+  }
+  return next(a / b);
+}
+function intervalType(x) {
+  if (x.hi < 0) return 4 /* N1 */;
+  if (x.lo > 0) return 0 /* P1 */;
+  if (x.lo < 0 && x.hi === 0) return 3 /* N0 */;
+  if (x.lo === 0 && x.hi > 0) return 1 /* P0 */;
+  if (x.lo === 0 && x.hi === 0) return 5 /* Z */;
+  else return 2 /* M */;
+}
+function idiv(x, y) {
+  typeCheckIsInterval(x);
+  typeCheckIsInterval(y);
+  const xType = intervalType(x);
+  const yType = intervalType(y);
+  if (yType === 5 /* Z */) {
+    return EMPTY;
+  }
+  if (xType === 5 /* Z */) {
+    return union([inter(0, 0)]);
+  }
+  const [a, b] = [x.lo, x.hi];
+  const [c, d] = [y.lo, y.hi];
+  if (yType === 0 /* P1 */) {
+    if (xType === 0 /* P1 */) {
+      return union([new Interval(leftDiv(a, d), rightDiv(b, c))]);
+    } else if (xType === 1 /* P0 */) {
+      return union([new Interval(0, rightDiv(b, c))]);
+    } else if (xType === 2 /* M */) {
+      return union([new Interval(leftDiv(a, c), rightDiv(b, c))]);
+    } else if (xType === 3 /* N0 */) {
+      return union([new Interval(leftDiv(a, c), -0)]);
+    } else {
+      return union([new Interval(leftDiv(a, c), rightDiv(b, d))]);
+    }
+  } else if (yType === 1 /* P0 */) {
+    if (xType === 0 /* P1 */) {
+      return union([new Interval(leftDiv(a, d), Infinity)]);
+    } else if (xType === 1 /* P0 */) {
+      return union([new Interval(0, Infinity)]);
+    } else if (xType === 2 /* M */) {
+      return union([FULL]);
+    } else if (xType === 3 /* N0 */) {
+      return union([new Interval(-Infinity, -0)]);
+    } else {
+      return union([new Interval(-Infinity, rightDiv(b, d))]);
+    }
+  } else if (yType === 2 /* M */) {
+    if (xType === 0 /* P1 */) {
+      return union([
+        new Interval(-Infinity, rightDiv(a, c)),
+        new Interval(leftDiv(a, d), Infinity)
+      ]);
+    } else if (xType == 4 /* N1 */) {
+      return union([
+        new Interval(-Infinity, rightDiv(b, d)),
+        new Interval(leftDiv(b, c), Infinity)
+      ]);
+    } else {
+      return union([FULL]);
+    }
+  } else if (yType === 3 /* N0 */) {
+    if (xType === 0 /* P1 */) {
+      return union([new Interval(-Infinity, rightDiv(a, c))]);
+    } else if (xType === 1 /* P0 */) {
+      return union([new Interval(-Infinity, -0)]);
+    } else if (xType === 2 /* M */) {
+      return union([FULL]);
+    } else if (xType === 3 /* N0 */) {
+      return union([new Interval(0, Infinity)]);
+    } else {
+      return union([new Interval(leftDiv(b, c), Infinity)]);
+    }
+  } else {
+    if (xType === 0 /* P1 */) {
+      return union([new Interval(leftDiv(b, d), rightDiv(a, c))]);
+    } else if (xType === 1 /* P0 */) {
+      return union([new Interval(leftDiv(b, d), -0)]);
+    } else if (xType === 2 /* M */) {
+      return union([new Interval(leftDiv(b, d), rightDiv(a, d))]);
+    } else if (xType === 3 /* N0 */) {
+      return union([new Interval(0, rightDiv(a, d))]);
+    } else {
+      return union([new Interval(leftDiv(b, c), rightDiv(a, d))]);
+    }
+  }
+}
+var uadd = makeBinaryOpUnion(iadd);
+var usub = makeBinaryOpUnion(isub);
+var umul = makeBinaryOpUnion(imul);
+var udiv = makeBinaryOpUnion(idiv);
+function uneg(U) {
+  typeCheckIsUnion(U);
+  return new Union(U.intervals.slice().reverse().map(ineg));
+}
+var add = makeBinaryOpEither(uadd);
+var sub = makeBinaryOpEither(usub);
+var mul = makeBinaryOpEither(umul);
+var div = makeBinaryOpEither(udiv);
+
+// src/math.ts
+function iabs(X) {
+  if (X.lo >= 0) return new Union([X]);
+  if (X.hi <= 0) return new Union([ineg(X)]);
+  return new Union([new Interval(0, Math.max(-X.lo, X.hi))]);
+}
+var uabs = makeUnaryOpUnion(iabs);
+var abs = makeUnaryOpEither(uabs);
+function imin(X, Y) {
+  return new Union([new Interval(Math.min(X.lo, Y.lo), Math.min(X.hi, Y.hi))]);
+}
+var umin = makeBinaryOpUnion(imin);
+var min = makeBinaryOpEither(umin);
+function imax(X, Y) {
+  return new Union([new Interval(Math.max(X.lo, Y.lo), Math.max(X.hi, Y.hi))]);
+}
+var umax = makeBinaryOpUnion(imax);
+var max = makeBinaryOpEither(umax);
+function leftExp(x) {
+  if (x === -Infinity) return 0;
+  if (x === 0) return 1;
+  return prev(Math.exp(x));
+}
+function rightExp(x) {
+  if (x === 0) return 1;
+  return next(Math.exp(x));
+}
+function iexp(X) {
+  typeCheckIsInterval(X);
+  return new Interval(leftExp(X.lo), rightExp(X.hi));
+}
+function uexp(U) {
+  typeCheckIsUnion(U);
+  return new Union(U.intervals.map(iexp));
+}
+var exp = makeUnaryOpEither(uexp);
+function leftLog(x) {
+  if (x === 0) return -Infinity;
+  if (x === 1) return 0;
+  return prev(Math.log(x));
+}
+function rightLog(x) {
+  if (x === 0) return -Infinity;
+  if (x === 1) return 0;
+  return next(Math.log(x));
+}
+function ilog(X) {
+  typeCheckIsInterval(X);
+  if (X.hi <= 0) return new Union([]);
+  if (X.lo <= 0) {
+    return new Union([new Interval(-Infinity, rightLog(X.hi))]);
+  } else {
+    return new Union([new Interval(leftLog(Math.max(0, X.lo)), rightLog(X.hi))]);
+  }
+}
+function ulog(U) {
+  typeCheckIsUnion(U);
+  return new Union(
+    U.intervals.map((i) => ilog(i).intervals).filter((il) => il.length > 0).flat()
+  );
+}
+var log = makeUnaryOpEither(ulog);
+function leftPowInt(base, exponent) {
+  if (base === 0) return 0;
+  if (exponent === 0) return 1;
+  return prev(Math.pow(base, exponent));
+}
+function rightPowInt(base, exponent) {
+  if (base === 0) return 0;
+  if (exponent === 0) return 1;
+  return next(Math.pow(base, exponent));
+}
+function ipowInt(X, n) {
+  typeCheckIsInterval(X);
+  if (!Number.isInteger(n)) {
+    throw Error(`ipowint: exponent must be an integer, got ${n}`);
+  }
+  if (n < 0) return idiv(new Interval(1, 1), ipowInt(X, -n).intervals[0]);
+  if (n === 0) return new Union([X]);
+  if (X.lo > 0 || n % 2 !== 0) {
+    return new Union([new Interval(leftPowInt(X.lo, n), rightPowInt(X.hi, n))]);
+  } else if (X.hi < 0) {
+    return new Union([new Interval(leftPowInt(X.hi, n), rightPowInt(X.lo, n))]);
+  } else {
+    return new Union([new Interval(0, rightPowInt(Math.abs(X.lo), n))]);
+  }
+}
+function upowInt(U, n) {
+  typeCheckIsUnion(U);
+  return union(U.intervals.map((i) => ipowInt(i, n).intervals).flat());
+}
+function powInt(A, n) {
+  typeCheckIsIntervalOrUnion(A);
+  return upowInt(toUnion(A), n);
+}
+function ipow(X, Y) {
+  if (X.hi <= 0) return new Union([]);
+  return uexp(umul(new Union([Y]), ilog(X)));
+}
+var upow = makeBinaryOpUnion(ipow);
+var pow = makeBinaryOpEither(upow);
+function leftSqrt(x) {
+  if (x === 0) return 0;
+  if (x === 1) return 1;
+  return prev(Math.sqrt(x));
+}
+function rightSqrt(x) {
+  if (x === 0) return 0;
+  if (x === 1) return 1;
+  return next(Math.sqrt(x));
+}
+function isqrt(X) {
+  if (X.hi < 0) return EMPTY;
+  return new Union([new Interval(leftSqrt(Math.max(0, X.lo)), rightSqrt(X.hi))]);
+}
+function usqrt(U) {
+  typeCheckIsUnion(U);
+  return new Union(
+    U.intervals.map((i) => isqrt(i).intervals).filter((il) => il.length > 0).flat()
+  );
+}
+var sqrt = makeUnaryOpEither(usqrt);
+
+// src/trigonometry.ts
+var pi = Math.PI;
+var halfpi = Math.PI / 2;
+var tau = 2 * Math.PI;
+function wrapAngle(angle) {
+  return (angle % tau + tau) % tau;
+}
+function piMultiples(X) {
+  const lower = Math.ceil(X.lo / Math.PI);
+  const upper = Math.floor(X.hi / Math.PI);
+  if (lower > upper) {
+    return [];
+  }
+  const result = [];
+  for (let n = lower; n <= upper; n++) {
+    result.push(n);
+  }
+  return result;
+}
+function halfPiMultiples(X) {
+  const lower = Math.ceil((X.lo - Math.PI / 2) / Math.PI);
+  const upper = Math.floor((X.hi - Math.PI / 2) / Math.PI);
+  if (lower > upper) {
+    return [];
+  }
+  const result = [];
+  for (let n = lower; n <= upper; n++) {
+    result.push(n);
+  }
+  return result;
+}
+function leftCos(x) {
+  if (x === 0) return 1;
+  return Math.max(-1, Math.min(1, prev(Math.cos(x))));
+}
+function rightCos(x) {
+  if (x === 0) return 1;
+  return Math.max(-1, Math.min(1, next(Math.cos(x))));
+}
+function icos(X) {
+  typeCheckIsInterval(X);
+  const width = X.hi - X.lo;
+  if (width >= 2 * Math.PI) return new Union([new Interval(-1, 1)]);
+  const candidates = [X.lo, X.hi, ...piMultiples(X).map((x) => x * pi)];
+  const left = candidates.map(leftCos);
+  const right = candidates.map(rightCos);
+  return new Union([new Interval(Math.min(...left), Math.max(...right))]);
+}
+var ucos = makeUnaryOpUnion(icos);
+var cos = makeUnaryOpEither(ucos);
+function leftSin(x) {
+  if (x === 0) return 0;
+  return Math.max(-1, Math.min(1, prev(Math.sin(x))));
+}
+function rightSin(x) {
+  if (x === 0) return 0;
+  return Math.max(-1, Math.min(1, next(Math.sin(x))));
+}
+function isin(X) {
+  typeCheckIsInterval(X);
+  const width = X.hi - X.lo;
+  if (width >= 2 * Math.PI) return new Union([new Interval(-1, 1)]);
+  const candidates = [X.lo, X.hi, ...halfPiMultiples(X).map((x) => halfpi + x * pi)];
+  const left = candidates.map(leftSin);
+  const right = candidates.map(rightSin);
+  return new Union([new Interval(Math.min(...left), Math.max(...right))]);
+}
+var usin = makeUnaryOpUnion(isin);
+var sin = makeUnaryOpEither(usin);
+function utan(U) {
+  return udiv(usin(U), ucos(U));
+}
+var tan = makeUnaryOpEither(utan);
 export {
-  hello
+  EMPTY,
+  FULL,
+  Interval,
+  Union,
+  abs,
+  add,
+  bounded,
+  cos,
+  defaultNumbers,
+  disjoint,
+  div,
+  exp,
+  halfPiMultiples,
+  iabs,
+  iadd,
+  icos,
+  idisjoint,
+  idiv,
+  iexp,
+  ilog,
+  imax,
+  imin,
+  imul,
+  ineg,
+  inter,
+  interval,
+  intervalType,
+  ioverlap,
+  ipow,
+  ipowInt,
+  isIntervalOrUnion,
+  isin,
+  isqrt,
+  isub,
+  iudisjoint,
+  iuoverlap,
+  leftMul,
+  log,
+  makeBinaryOpEither,
+  makeBinaryOpUnion,
+  makeUnaryOpEither,
+  makeUnaryOpUnion,
+  max,
+  min,
+  mul,
+  next,
+  overlap,
+  piMultiples,
+  pow,
+  powInt,
+  prev,
+  rightMul,
+  sin,
+  sqrt,
+  sub,
+  tan,
+  toUnion,
+  typeCheckIsInterval,
+  typeCheckIsIntervalOrUnion,
+  typeCheckIsUnion,
+  uabs,
+  uadd,
+  ucos,
+  udiv,
+  uexp,
+  ulog,
+  umax,
+  umin,
+  umul,
+  uneg,
+  union,
+  upow,
+  upowInt,
+  usin,
+  usqrt,
+  usub,
+  utan,
+  wrapAngle
 };
 //# sourceMappingURL=index.js.map