not-so-float 1.2.1 → 2.1.0

package/README.md

@@ -15,9 +15,9 @@ Arithmetic** over IEEE 754 double precision floats (JS numbers).
 ```typescript
 import * as nsf from "not-so-float";
 
-const X = nsf.union([nsf.inter(-10, -1), nsf.inter(100, 120)]);
-const Y = nsf.union([nsf.inter(-10, 2)]);
-const Q = nsf.udiv(X, Y);
+const X = nsf.union([nsf.interval(-10, -1), nsf.interval(100, 120)]);
+const Y = nsf.union([nsf.interval(-10, 2)]);
+const Q = nsf.div(X, Y);
 
 console.log(`(${X.toString()}) / ${Y.toString()} = ${Q.toString()}`);
 ```
@@ -112,16 +112,16 @@ interval represents:
 Where $a$ and $b$ are real IEEE 754 values (not infinite).  
 The special case when both bounds are equal is called a _degenerate_ interval.
 
-To construct an interval, use the `nsf.inter()` function:
+To construct an interval, use the `nsf.interval()` function:
 
 ```typescript
-nsf.inter(a: number, b: number) : Interval
+nsf.interval(a: number, b: number) : Interval
 ```
 
 For example:
 
 ```typescript
-> I = nsf.inter(0, 6)
+> I = nsf.interval(0, 6)
 Interval { lo: 0, hi: 6 }
 ```
 
@@ -133,6 +133,7 @@ class Interval {
     isFinite(): boolean;
     isDegenerate(): boolean;
     contains(value: number): boolean;
+    hull(): Union;
     superset(other: Interval): boolean;
     subset(other: Interval): boolean;
     toString(numbers?: (x: number) => string): string;
@@ -179,6 +180,17 @@ For example:
 [ Interval { lo: 1, hi: 2 }, Interval { lo: 4, hi: 6 } ]
 ```
 
+You can also use the shorthand `nsf.single()` to construct a singleton, i.e. a union with a single interval:
+
+```typescript
+const U = nsf.single(-0.1, 0.1);
+```
+
+Constants are also provided:
+
+-   `FULL`: all real numbers
+-   `EMPTY`: the empty union
+
 ## Set theory
 
 Compare and compute intervals and unions with the following implementations of
@@ -244,5 +256,3 @@ function complement(A: Union | Interval): Union;
 ## Future improvements
 
 -   Support multiple rounding modes
--   Add shortcut function for `nsf.union(nsf.inter([x]))`
--   Change FULL constant to Union

package/dist/index.cjs

@@ -29,82 +29,29 @@ __export(index_exports, {
   bounded: () => bounded,
   complement: () => complement,
   cos: () => cos,
-  defaultNumbers: () => defaultNumbers,
   disjoint: () => disjoint,
   div: () => div,
   exp: () => exp,
-  halfPiMultiples: () => halfPiMultiples,
-  iabs: () => iabs,
-  iadd: () => iadd,
-  icos: () => icos,
-  idisjoint: () => idisjoint,
-  idiv: () => idiv,
-  iexp: () => iexp,
-  iintersection: () => iintersection,
-  ilog: () => ilog,
-  imax: () => imax,
-  imin: () => imin,
-  imul: () => imul,
-  ineg: () => ineg,
-  inter: () => inter,
   intersection: () => intersection,
   interval: () => interval,
-  intervalType: () => intervalType,
-  ioverlap: () => ioverlap,
-  ipow: () => ipow,
-  ipowInt: () => ipowInt,
-  isIntervalOrUnion: () => isIntervalOrUnion,
-  isin: () => isin,
-  isqrt: () => isqrt,
-  isub: () => isub,
-  iudisjoint: () => iudisjoint,
-  iuoverlap: () => iuoverlap,
-  leftMul: () => leftMul,
   log: () => log,
-  makeBinaryOpEither: () => makeBinaryOpEither,
-  makeBinaryOpUnion: () => makeBinaryOpUnion,
-  makeUnaryOpEither: () => makeUnaryOpEither,
-  makeUnaryOpUnion: () => makeUnaryOpUnion,
   max: () => max,
   min: () => min,
   mul: () => mul,
+  neg: () => neg,
   next: () => next,
   overlap: () => overlap,
-  piMultiples: () => piMultiples,
   pow: () => pow,
   powInt: () => powInt,
+  powIntInv: () => powIntInv,
   prev: () => prev,
-  rightMul: () => rightMul,
   sin: () => sin,
+  single: () => single,
   sqinv: () => sqinv,
   sqrt: () => sqrt,
   sub: () => sub,
   tan: () => tan,
-  toUnion: () => toUnion,
-  typeCheckIsInterval: () => typeCheckIsInterval,
-  typeCheckIsIntervalOrUnion: () => typeCheckIsIntervalOrUnion,
-  typeCheckIsUnion: () => typeCheckIsUnion,
-  uabs: () => uabs,
-  uadd: () => uadd,
-  ucomplement: () => ucomplement,
-  ucos: () => ucos,
-  udiv: () => udiv,
-  uexp: () => uexp,
-  uintersection: () => uintersection,
-  ulog: () => ulog,
-  umax: () => umax,
-  umin: () => umin,
-  umul: () => umul,
-  uneg: () => uneg,
-  union: () => union,
-  upow: () => upow,
-  upowInt: () => upowInt,
-  usin: () => usin,
-  usqinv: () => usqinv,
-  usqrt: () => usqrt,
-  usub: () => usub,
-  utan: () => utan,
-  wrapAngle: () => wrapAngle
+  union: () => union
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -196,14 +143,13 @@ function interval(a, b) {
   }
   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;
 }
+var IFULL = new Interval(-Infinity, Infinity);
 
 // src/union.ts
 var Union = class {
@@ -227,6 +173,20 @@ var Union = class {
   contains(value) {
     return this.intervals.some((i) => i.contains(value));
   }
+  subset(other) {
+    return this.intervals.every(
+      (thisInterval) => other.intervals.some((otherInterval) => thisInterval.subset(otherInterval))
+    );
+  }
+  superset(other) {
+    return other.intervals.every(
+      (otherInterval) => this.intervals.some((thisInterval) => thisInterval.superset(otherInterval))
+    );
+  }
+  hull() {
+    if (this.isEmpty()) return EMPTY;
+    return single(this.lower(), this.upper());
+  }
   forEach(callback) {
     this.intervals.forEach(callback);
   }
@@ -310,10 +270,17 @@ function makeBinaryOpEither(op) {
     return op(toUnion(A), toUnion(B));
   };
 }
+function single(a, b) {
+  if (typeof b === "undefined") {
+    b = a;
+  }
+  return union([interval(a, b)]);
+}
 function bounded(x) {
-  return new Union([new Interval(prev(x), next(x))]);
+  return single(prev(x), next(x));
 }
 var EMPTY = new Union([]);
+var FULL = new Union([new Interval(-Infinity, Infinity)]);
 
 // src/compare.ts
 function ioverlap(a, b) {
@@ -471,6 +438,8 @@ function leftDiv(a, b) {
   if (b === -Infinity) {
     return Math.sign(-a) * 0;
   }
+  if (b === 1) return a;
+  if (b === -1) return -a;
   return prev(a / b);
 }
 function rightDiv(a, b) {
@@ -480,6 +449,8 @@ function rightDiv(a, b) {
   if (b === -Infinity) {
     return Math.sign(-a) * 0;
   }
+  if (b === 1) return a;
+  if (b === -1) return -a;
   return next(a / b);
 }
 function intervalType(x) {
@@ -499,7 +470,7 @@ function idiv(x, y) {
     return EMPTY;
   }
   if (xType === 5 /* Z */) {
-    return union([inter(0, 0)]);
+    return single(0);
   }
   const [a, b] = [x.lo, x.hi];
   const [c, d] = [y.lo, y.hi];
@@ -521,7 +492,7 @@ function idiv(x, y) {
     } else if (xType === 1 /* P0 */) {
       return union([new Interval(0, Infinity)]);
     } else if (xType === 2 /* M */) {
-      return union([FULL]);
+      return FULL;
     } else if (xType === 3 /* N0 */) {
       return union([new Interval(-Infinity, -0)]);
     } else {
@@ -539,7 +510,7 @@ function idiv(x, y) {
         new Interval(leftDiv(b, c), Infinity)
       ]);
     } else {
-      return union([FULL]);
+      return FULL;
     }
   } else if (yType === 3 /* N0 */) {
     if (xType === 0 /* P1 */) {
@@ -547,7 +518,7 @@ function idiv(x, y) {
     } else if (xType === 1 /* P0 */) {
       return union([new Interval(-Infinity, -0)]);
     } else if (xType === 2 /* M */) {
-      return union([FULL]);
+      return FULL;
     } else if (xType === 3 /* N0 */) {
       return union([new Interval(0, Infinity)]);
     } else {
@@ -575,6 +546,7 @@ function uneg(U) {
   typeCheckIsUnion(U);
   return new Union(U.intervals.slice().reverse().map(ineg));
 }
+var neg = makeUnaryOpEither(uneg);
 var add = makeBinaryOpEither(uadd);
 var sub = makeBinaryOpEither(usub);
 var mul = makeBinaryOpEither(umul);
@@ -664,9 +636,7 @@ function ipowInt(X, 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.max(Math.abs(X.hi), Math.abs(X.lo)), n))
-    ]);
+    return new Union([new Interval(0, rightPowInt(Math.max(X.hi, -X.lo), n))]);
   }
 }
 function upowInt(U, n) {
@@ -709,14 +679,84 @@ function usqinv(U) {
   return union(uneg(x).intervals.concat(x.intervals));
 }
 var sqinv = makeUnaryOpEither(usqinv);
+function upowIntInv(U, n) {
+  if (n === 0) {
+    if (U.contains(1)) return FULL;
+    else return EMPTY;
+  }
+  if (n === 1) {
+    return U;
+  }
+  if (n > 0 && n % 2 === 0) {
+    return upowEvenInv(U, n);
+  }
+  if (n > 0 && n % 2 !== 0) {
+    return upowOddInv(U, n);
+  }
+  if (U.lower() === 0 && U.upper() === 0) {
+    return EMPTY;
+  }
+  const one = new Union([new Interval(1, 1)]);
+  return div(one, upowIntInv(U, -n));
+}
+function powIntInv(A, n) {
+  typeCheckIsIntervalOrUnion(A);
+  return upowIntInv(toUnion(A), n);
+}
+function leftPowOddInv(y, n) {
+  if (y === 0) return 0;
+  if (y === 1) return 1;
+  if (y === -1) return -1;
+  else if (y > 0) return prev(Math.pow(y, prev(1 / n)));
+  else return prev(-Math.pow(-y, next(1 / n)));
+}
+function rightPowOddInv(y, n) {
+  if (y === 0) return 0;
+  if (y === 1) return 1;
+  if (y === -1) return -1;
+  else if (y > 0) return next(Math.pow(y, next(1 / n)));
+  else return next(-Math.pow(-y, prev(1 / n)));
+}
+function ipowOddInv(X, n) {
+  typeCheckIsInterval(X);
+  return new Interval(leftPowOddInv(X.lo, n), rightPowOddInv(X.hi, n));
+}
+function upowOddInv(U, n) {
+  typeCheckIsUnion(U);
+  return new Union(U.intervals.map((X) => ipowOddInv(X, n)));
+}
+function leftPowEvenInv(y, n) {
+  if (y === 0) return 0;
+  if (y === 1) return 1;
+  return prev(Math.pow(y, prev(1 / n)));
+}
+function rightPowEvenInv(y, n) {
+  if (y === 0) return 0;
+  if (y === 1) return 1;
+  return next(Math.pow(y, next(1 / n)));
+}
+function ipowEvenInv(Y, n) {
+  if (Y.hi < 0) {
+    return EMPTY;
+  } else if (Y.hi === 0) {
+    return new Union([new Interval(0, 0)]);
+  } else {
+    const principal = new Interval(
+      leftPowEvenInv(Math.max(0, Y.lo), n),
+      rightPowEvenInv(Y.hi, n)
+    );
+    return new Union([ineg(principal), principal]);
+  }
+}
+function upowEvenInv(U, n) {
+  typeCheckIsUnion(U);
+  return union(U.intervals.map((X) => ipowEvenInv(X, n).intervals).flat());
+}
 
 // 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);
@@ -794,81 +834,28 @@ var tan = makeUnaryOpEither(utan);
   bounded,
   complement,
   cos,
-  defaultNumbers,
   disjoint,
   div,
   exp,
-  halfPiMultiples,
-  iabs,
-  iadd,
-  icos,
-  idisjoint,
-  idiv,
-  iexp,
-  iintersection,
-  ilog,
-  imax,
-  imin,
-  imul,
-  ineg,
-  inter,
   intersection,
   interval,
-  intervalType,
-  ioverlap,
-  ipow,
-  ipowInt,
-  isIntervalOrUnion,
-  isin,
-  isqrt,
-  isub,
-  iudisjoint,
-  iuoverlap,
-  leftMul,
   log,
-  makeBinaryOpEither,
-  makeBinaryOpUnion,
-  makeUnaryOpEither,
-  makeUnaryOpUnion,
   max,
   min,
   mul,
+  neg,
   next,
   overlap,
-  piMultiples,
   pow,
   powInt,
+  powIntInv,
   prev,
-  rightMul,
   sin,
+  single,
   sqinv,
   sqrt,
   sub,
   tan,
-  toUnion,
-  typeCheckIsInterval,
-  typeCheckIsIntervalOrUnion,
-  typeCheckIsUnion,
-  uabs,
-  uadd,
-  ucomplement,
-  ucos,
-  udiv,
-  uexp,
-  uintersection,
-  ulog,
-  umax,
-  umin,
-  umul,
-  uneg,
-  union,
-  upow,
-  upowInt,
-  usin,
-  usqinv,
-  usqrt,
-  usub,
-  utan,
-  wrapAngle
+  union
 });
 //# sourceMappingURL=index.cjs.map