@thi.ng/distance 2.4.32 → 2.4.34

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -130,7 +130,7 @@ For Node.js REPL:
 const distance = await import("@thi.ng/distance");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.42 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.38 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/argmin.js

@@ -1,82 +1,45 @@
 import { isFunction } from "@thi.ng/checks/is-function";
 import { knearest } from "./knearest.js";
 import { DIST_SQ, DIST_SQ1 } from "./squared.js";
-/**
- * Takes a vector `p`, array of `samples` and a `dist`ance function. Computes
- * and returns index of the sample closest to `p` (according to `dist`, default:
- * {@link DIST_SQ}).
- *
- * @reference
- * Use {@link argminT} for non-vector inputs.
- *
- * https://en.wikipedia.org/wiki/Arg_max#Arg_min
- *
- * @param p -
- * @param samples -
- * @param dist -
- */
-export const argmin = (p, samples, dist = DIST_SQ) => {
-    const distFn = isFunction(dist) ? dist : dist.metric;
-    let minD = Infinity;
-    let minArg = -1;
-    for (let i = 0, n = samples.length; i < n; i++) {
-        const d = distFn(p, samples[i]);
-        if (d < minD) {
-            minD = d;
-            minArg = i;
-        }
+const argmin = (p, samples, dist = DIST_SQ) => {
+  const distFn = isFunction(dist) ? dist : dist.metric;
+  let minD = Infinity;
+  let minArg = -1;
+  for (let i = 0, n = samples.length; i < n; i++) {
+    const d = distFn(p, samples[i]);
+    if (d < minD) {
+      minD = d;
+      minArg = i;
     }
-    return minArg;
+  }
+  return minArg;
 };
-export const argminN = (p, samples, dist = DIST_SQ1) => {
-    const distFn = isFunction(dist) ? dist : dist.metric;
-    let minD = Infinity;
-    let minArg = -1;
-    for (let i = 0, n = samples.length; i < n; i++) {
-        const d = distFn(p, samples[i]);
-        if (d < minD) {
-            minD = d;
-            minArg = i;
-        }
+const argminN = (p, samples, dist = DIST_SQ1) => {
+  const distFn = isFunction(dist) ? dist : dist.metric;
+  let minD = Infinity;
+  let minArg = -1;
+  for (let i = 0, n = samples.length; i < n; i++) {
+    const d = distFn(p, samples[i]);
+    if (d < minD) {
+      minD = d;
+      minArg = i;
     }
-    return minArg;
+  }
+  return minArg;
 };
-/**
- * Similar to {@link argmin}, but for non-vector inputs and taking an additional
- * `key` function. Applies `key` to each item (incl. `p`) to obtain its vector
- * representation, then computes and returns index of the sample closest to `p`
- * (according to `dist`).
- *
- * @reference
- * Use {@link argmin} if all items are vectors already.
- *
- * @param p -
- * @param samples -
- * @param key -
- * @param dist -
- */
-export const argminT = (p, samples, key, dist) => argmin(key(p), samples.map(key), dist);
-/**
- * Similar to {@link argmin}, but for k-nearest queries.
- *
- * @param k -
- * @param p -
- * @param samples -
- * @param dist -
- */
-export const argminK = (k, p, samples, dist = DIST_SQ) => {
-    const neighborhood = knearest(p, k, Infinity, dist);
-    for (let i = 0, n = samples.length; i < n; i++) {
-        neighborhood.consider(samples[i], i);
-    }
-    return neighborhood.values();
+const argminT = (p, samples, key, dist) => argmin(key(p), samples.map(key), dist);
+const argminK = (k, p, samples, dist = DIST_SQ) => {
+  const neighborhood = knearest(p, k, Infinity, dist);
+  for (let i = 0, n = samples.length; i < n; i++) {
+    neighborhood.consider(samples[i], i);
+  }
+  return neighborhood.values();
+};
+const argminKT = (k, p, samples, key, dist) => argminK(k, key(p), samples.map(key), dist);
+export {
+  argmin,
+  argminK,
+  argminKT,
+  argminN,
+  argminT
 };
-/**
- * Similar to {@link argminT}, but for k-nearest queries.
- *
- * @param k -
- * @param p -
- * @param samples -
- * @param dist -
- */
-export const argminKT = (k, p, samples, key, dist) => argminK(k, key(p), samples.map(key), dist);

package/eucledian.js

@@ -1,29 +1,23 @@
 import { dist, dist2, dist3 } from "@thi.ng/vectors/dist";
-export class Eucledian {
-    metric;
-    constructor(metric) {
-        this.metric = metric;
-    }
-    to(x) {
-        return x;
-    }
-    from(x) {
-        return x;
-    }
+class Eucledian {
+  constructor(metric) {
+    this.metric = metric;
+  }
+  to(x) {
+    return x;
+  }
+  from(x) {
+    return x;
+  }
 }
-/**
- * Eucledian distance metric for n-D vectors.
- */
-export const EUCLEDIAN = new Eucledian(dist);
-/**
- * Eucledian distance metric for numbers.
- */
-export const EUCLEDIAN1 = new Eucledian((a, b) => Math.abs(a - b));
-/**
- * Eucledian distance metric for 2d vectors.
- */
-export const EUCLEDIAN2 = new Eucledian(dist2);
-/**
- * Eucledian distance metric for 3d vectors.
- */
-export const EUCLEDIAN3 = new Eucledian(dist3);
+const EUCLEDIAN = new Eucledian(dist);
+const EUCLEDIAN1 = new Eucledian((a, b) => Math.abs(a - b));
+const EUCLEDIAN2 = new Eucledian(dist2);
+const EUCLEDIAN3 = new Eucledian(dist3);
+export {
+  EUCLEDIAN,
+  EUCLEDIAN1,
+  EUCLEDIAN2,
+  EUCLEDIAN3,
+  Eucledian
+};

package/haversine.js

@@ -1,10 +1,11 @@
-import { distHaversineLatLon, distHaversineLonLat, } from "@thi.ng/vectors/dist-haversine";
+import {
+  distHaversineLatLon,
+  distHaversineLonLat
+} from "@thi.ng/vectors/dist-haversine";
 import { Eucledian } from "./eucledian.js";
-/**
- * Distance metric for geo locations given as [lat,lon] vectors.
- */
-export const HAVERSINE_LATLON = new Eucledian(distHaversineLatLon);
-/**
- * Distance metric for geo locations given as [lon,lat] vectors.
- */
-export const HAVERSINE_LONLAT = new Eucledian(distHaversineLonLat);
+const HAVERSINE_LATLON = new Eucledian(distHaversineLatLon);
+const HAVERSINE_LONLAT = new Eucledian(distHaversineLonLat);
+export {
+  HAVERSINE_LATLON,
+  HAVERSINE_LONLAT
+};

package/knearest.js

@@ -2,155 +2,99 @@ import { assert } from "@thi.ng/errors/assert";
 import { Heap } from "@thi.ng/heaps/heap";
 import { clamp0 } from "@thi.ng/math/interval";
 import { DIST_SQ, DIST_SQ1, DIST_SQ2, DIST_SQ3 } from "./squared.js";
-/**
- * A {@link INeighborhood} implementation for K-nearest neighbor queries around
- * a given target location, initial query radius and {@link IDistance} metric to
- * determine proximity. See {@link Radial} for an unbounded and unsorted
- * version.
- *
- * @remarks
- * The K-nearest neighbors will be accumulated via an internal
- * [`Heap`](https://docs.thi.ng/umbrella/heaps/classes/Heap.html) and results
- * can be optionally returned in order of proximity (via {@link KNearest.deref}
- * or {@link KNearest.values}). For K=1 it will be more efficient to use
- * {@link Nearest} to avoid the additional overhead.
- *
- * @typeParam D - spatial position for distance metric
- * @typeParam T - indexed value
- */
-export class KNearest {
-    dist;
-    target;
-    k;
-    radius;
-    sorted;
-    _currR;
-    _heap = new Heap(null, {
-        compare: (a, b) => b[0] - a[0],
-    });
-    constructor(dist, target, k, radius = Infinity, sorted = false) {
-        this.dist = dist;
-        this.target = target;
-        this.k = k;
-        this.radius = radius;
-        this.sorted = sorted;
-        this.radius = clamp0(radius);
-        this.setK(k);
-    }
-    reset() {
-        this._currR = this.dist.to(this.radius);
-        this._heap.clear();
-        return this;
-    }
-    /**
-     * Resets search/reference position.
-     *
-     * @param target
-     */
-    setTarget(target) {
-        this.target = target;
-    }
-    /**
-     * Resets max. search/query radius and clears current results.
-     *
-     * @param r
-     */
-    setRadius(r) {
-        this.radius = clamp0(r);
-        this.reset();
-    }
-    /**
-     * Resets `k-nearest` limit and clears current results.
-     *
-     * @param r
-     */
-    setK(k) {
-        assert(k > 0, `invalid k (must be > 0)`);
-        this.k = k;
-        this.reset();
-    }
-    /**
-     * Returns an array of current nearest neighbor result tuples (each `[dist,
-     * val]`). The array will contain at most `k` items and if the `sorted` ctor
-     * arg was true, will be sorted by distance.
-     *
-     * @remarks
-     * Use {@link KNearest.values} to obtain result values **without** their distance
-     * metrics.
-     */
-    deref() {
-        return this.sorted ? this._heap.max() : this._heap.values;
-    }
-    /**
-     * Similar to {@link KNearest.deref}, but returns array of result values **without**
-     * their distance metrics.
-     */
-    values() {
-        return this.deref().map((x) => x[1]);
-    }
-    includesDistance(d, eucledian = true) {
-        return (eucledian ? this.dist.to(d) : d) <= this._currR;
-    }
-    includesPosition(pos) {
-        return this.dist.metric(this.target, pos) < this._currR;
-    }
-    consider(pos, val) {
-        const d = this.dist.metric(this.target, pos);
-        if (d <= this._currR) {
-            const heap = this._heap;
-            if (heap.length === this.k) {
-                heap.pushPop([d, val]);
-                this._currR = heap.peek()[0];
-            }
-            else {
-                heap.push([d, val]);
-            }
-        }
-        return d;
+class KNearest {
+  constructor(dist, target, k, radius = Infinity, sorted = false) {
+    this.dist = dist;
+    this.target = target;
+    this.k = k;
+    this.radius = radius;
+    this.sorted = sorted;
+    this.radius = clamp0(radius);
+    this.setK(k);
+  }
+  _currR;
+  _heap = new Heap(null, {
+    compare: (a, b) => b[0] - a[0]
+  });
+  reset() {
+    this._currR = this.dist.to(this.radius);
+    this._heap.clear();
+    return this;
+  }
+  /**
+   * Resets search/reference position.
+   *
+   * @param target
+   */
+  setTarget(target) {
+    this.target = target;
+  }
+  /**
+   * Resets max. search/query radius and clears current results.
+   *
+   * @param r
+   */
+  setRadius(r) {
+    this.radius = clamp0(r);
+    this.reset();
+  }
+  /**
+   * Resets `k-nearest` limit and clears current results.
+   *
+   * @param r
+   */
+  setK(k) {
+    assert(k > 0, `invalid k (must be > 0)`);
+    this.k = k;
+    this.reset();
+  }
+  /**
+   * Returns an array of current nearest neighbor result tuples (each `[dist,
+   * val]`). The array will contain at most `k` items and if the `sorted` ctor
+   * arg was true, will be sorted by distance.
+   *
+   * @remarks
+   * Use {@link KNearest.values} to obtain result values **without** their distance
+   * metrics.
+   */
+  deref() {
+    return this.sorted ? this._heap.max() : this._heap.values;
+  }
+  /**
+   * Similar to {@link KNearest.deref}, but returns array of result values **without**
+   * their distance metrics.
+   */
+  values() {
+    return this.deref().map((x) => x[1]);
+  }
+  includesDistance(d, eucledian = true) {
+    return (eucledian ? this.dist.to(d) : d) <= this._currR;
+  }
+  includesPosition(pos) {
+    return this.dist.metric(this.target, pos) < this._currR;
+  }
+  consider(pos, val) {
+    const d = this.dist.metric(this.target, pos);
+    if (d <= this._currR) {
+      const heap = this._heap;
+      if (heap.length === this.k) {
+        heap.pushPop([d, val]);
+        this._currR = heap.peek()[0];
+      } else {
+        heap.push([d, val]);
+      }
     }
+    return d;
+  }
 }
-/**
- * Defines a {@link KNearest} instance for arbitrary length vector positions
- * and, by default, using an infinite region radius and {@link DIST_SQ} distance
- * metric.
- *
- * @param p -
- * @param k -
- * @param r -
- * @param dist -
- * @param sorted -
- */
-export const knearest = (p, k, r, dist = DIST_SQ, sorted) => new KNearest(dist, p, k, r, sorted);
-/**
- * Defines a {@link KNearest} instance for 2D vector positions and, by default,
- * using an infinite region radius and {@link DIST_SQ2} distance metric.
- *
- * @param p -
- * @param k -
- * @param r -
- * @param dist -
- * @param sorted -
- */
-export const knearest2 = (p, k, r, dist = DIST_SQ2, sorted) => new KNearest(dist, p, k, r, sorted);
-/**
- * Defines a {@link KNearest} instance for 3D vector positions, by default,
- * using an infinite region radius and {@link DIST_SQ3} distance metric.
- *
- * @param p -
- * @param k -
- * @param r -
- * @param dist -
- * @param sorted -
- */
-export const knearest3 = (p, k, r, dist = DIST_SQ3, sorted) => new KNearest(dist, p, k, r, sorted);
-/**
- * Defines a {@link KNearest} instance for numeric positions and, by default,
- * using an infinite region radius and {@link DIST_SQ1} distance metric.
- *
- * @param p -
- * @param k -
- * @param r -
- * @param dist -
- * @param sorted -
- */
-export const knearestN = (p, k, r, dist = DIST_SQ1, sorted) => new KNearest(dist, p, k, r, sorted);
+const knearest = (p, k, r, dist = DIST_SQ, sorted) => new KNearest(dist, p, k, r, sorted);
+const knearest2 = (p, k, r, dist = DIST_SQ2, sorted) => new KNearest(dist, p, k, r, sorted);
+const knearest3 = (p, k, r, dist = DIST_SQ3, sorted) => new KNearest(dist, p, k, r, sorted);
+const knearestN = (p, k, r, dist = DIST_SQ1, sorted) => new KNearest(dist, p, k, r, sorted);
+export {
+  KNearest,
+  knearest,
+  knearest2,
+  knearest3,
+  knearestN
+};

package/manhattan.js

@@ -1,71 +1,28 @@
-import { distManhattan, distManhattan2, distManhattan3, } from "@thi.ng/vectors/dist-manhattan";
-/**
- * Manhattan distance metric and conversion to/from Eucledian distances.
- *
- * @remarks
- * The conversion are always based on n-D squares, i.e. the assumption that the
- * distance is equally shared in each dimension.
- *
- * E.g. a Manhattan distance of 30 could be obtained from [0,0] -> [10,20], but
- * would be interpreted here as distance from [0,0] -> [15,15], which produces
- * the same Manhattan value, but yields a different Eucledian result. For lack
- * of any other information about the distance values, this is however the only
- * way to approach conversion and is sufficient for the purposes of this
- * package...
- *
- * @example
- * ```ts
- * MANHATTAN2.metric([0,0], [10,20])
- * // 30
- *
- * MANHATTAN2.from(30);
- * // 21.213203435596427
- *
- * Math.hypot(15, 15) // <-- diagonal of manhattan square
- * // 21.213203435596427
- *
- * Math.hypot(10, 20) // <-- actual eucledian dist
- * // 22.360679774997898
- *
- * MANHATTAN2.to(21.213203435596427)
- * // 30
- *
- * // however, starting w/ eucledian dist first
- * e = mag([10, 20])
- * // 22.360679774997898
- *
- * m = MANHATTAN2.to(e)
- * // 31.622776601683793
- *
- * MANHATTAN2.from(m) === e
- * // true
- * ```
- */
-export class Manhattan {
-    dim;
-    metric;
-    _invD;
-    constructor(dim, metric) {
-        this.dim = dim;
-        this.metric = metric;
-        this._invD = this.dim / Math.sqrt(dim);
-    }
-    to(x) {
-        return x * this._invD;
-    }
-    from(x) {
-        return Math.sqrt((x / this.dim) ** 2 * this.dim);
-    }
+import {
+  distManhattan,
+  distManhattan2,
+  distManhattan3
+} from "@thi.ng/vectors/dist-manhattan";
+class Manhattan {
+  constructor(dim, metric) {
+    this.dim = dim;
+    this.metric = metric;
+    this._invD = this.dim / Math.sqrt(dim);
+  }
+  _invD;
+  to(x) {
+    return x * this._invD;
+  }
+  from(x) {
+    return Math.sqrt((x / this.dim) ** 2 * this.dim);
+  }
 }
-/**
- * Returns a new Manhattan distance metric for n-D vectors of dimension `dim`.
- */
-export const defManhattan = (dim) => new Manhattan(dim, distManhattan);
-/**
- * Manhattan distance metric for 2d vectors.
- */
-export const MANHATTAN2 = new Manhattan(2, distManhattan2);
-/**
- * Manhattan distance metric for 3d vectors.
- */
-export const MANHATTAN3 = new Manhattan(3, distManhattan3);
+const defManhattan = (dim) => new Manhattan(dim, distManhattan);
+const MANHATTAN2 = new Manhattan(2, distManhattan2);
+const MANHATTAN3 = new Manhattan(3, distManhattan3);
+export {
+  MANHATTAN2,
+  MANHATTAN3,
+  Manhattan,
+  defManhattan
+};

package/nearest.js

@@ -1,88 +1,50 @@
 import { clamp0 } from "@thi.ng/math/interval";
 import { DIST_SQ, DIST_SQ1, DIST_SQ2, DIST_SQ3 } from "./squared.js";
-/**
- * A {@link INeighborhood} implementation for nearest neighbor queries around a
- * given target location, initial query radius and {@link IDistance} metric to
- * determine proximity.
- *
- * @typeParam D - spatial position for distance metric
- * @typeParam T - indexed value
- */
-export class Nearest {
-    dist;
-    target;
-    radius;
-    _currR;
-    value;
-    constructor(dist, target, radius = Infinity) {
-        this.dist = dist;
-        this.target = target;
-        this.radius = clamp0(radius);
-        this.reset();
-    }
-    reset() {
-        this._currR = this.dist.to(this.radius);
-        this.value = undefined;
-        return this;
-    }
-    /**
-     * Returns current nearest neighbor result tuple (`[dist, val]`) or
-     * undefined, if no such result exists (yet).
-     */
-    deref() {
-        return this.value != undefined
-            ? [this._currR, this.value]
-            : undefined;
-    }
-    includesDistance(d, eucledian = true) {
-        return (eucledian ? this.dist.to(d) : d) <= this._currR;
-    }
-    includesPosition(pos) {
-        return this.dist.metric(this.target, pos) < this._currR;
-    }
-    consider(pos, val) {
-        const d = this.dist.metric(this.target, pos);
-        if (d <= this._currR) {
-            this._currR = d;
-            this.value = val;
-        }
-        return d;
+class Nearest {
+  constructor(dist, target, radius = Infinity) {
+    this.dist = dist;
+    this.target = target;
+    this.radius = clamp0(radius);
+    this.reset();
+  }
+  radius;
+  _currR;
+  value;
+  reset() {
+    this._currR = this.dist.to(this.radius);
+    this.value = void 0;
+    return this;
+  }
+  /**
+   * Returns current nearest neighbor result tuple (`[dist, val]`) or
+   * undefined, if no such result exists (yet).
+   */
+  deref() {
+    return this.value != void 0 ? [this._currR, this.value] : void 0;
+  }
+  includesDistance(d, eucledian = true) {
+    return (eucledian ? this.dist.to(d) : d) <= this._currR;
+  }
+  includesPosition(pos) {
+    return this.dist.metric(this.target, pos) < this._currR;
+  }
+  consider(pos, val) {
+    const d = this.dist.metric(this.target, pos);
+    if (d <= this._currR) {
+      this._currR = d;
+      this.value = val;
     }
+    return d;
+  }
 }
-/**
- * Defines a {@link Nearest} instance for arbitrary length vector positions, by
- * default, using an infinite region radius and {@link DIST_SQ} distance
- * metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const nearest = (p, r, dist = DIST_SQ) => new Nearest(dist, p, r);
-/**
- * Defines a {@link Nearest} instance for 2D vector positions, by default,
- * using an infinite region radius and {@link DIST_SQ2} distance metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const nearest2 = (p, r, dist = DIST_SQ2) => new Nearest(dist, p, r);
-/**
- * Defines a {@link Nearest} instance for 3D vector positions, by default,
- * using an infinite region radius and {@link DIST_SQ3} distance metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const nearest3 = (p, r, dist = DIST_SQ3) => new Nearest(dist, p, r);
-/**
- * Defines a {@link Nearest} instance for numeric positions and, by default,
- * using an infinite region radius and {@link DIST_SQ1} distance metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const nearestN = (p, r, dist = DIST_SQ1) => new Nearest(dist, p, r);
+const nearest = (p, r, dist = DIST_SQ) => new Nearest(dist, p, r);
+const nearest2 = (p, r, dist = DIST_SQ2) => new Nearest(dist, p, r);
+const nearest3 = (p, r, dist = DIST_SQ3) => new Nearest(dist, p, r);
+const nearestN = (p, r, dist = DIST_SQ1) => new Nearest(dist, p, r);
+export {
+  Nearest,
+  nearest,
+  nearest2,
+  nearest3,
+  nearestN
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/distance",
-  "version": "2.4.32",
+  "version": "2.4.34",
   "description": "N-dimensional distance metrics & K-nearest neighborhoods for point queries",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,16 +35,16 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/errors": "^2.4.4",
-    "@thi.ng/heaps": "^2.1.46",
-    "@thi.ng/math": "^5.7.5",
-    "@thi.ng/vectors": "^7.8.7"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/heaps": "^2.1.48",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/vectors": "^7.8.9"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -111,5 +113,5 @@
     ],
     "year": 2021
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/radial.js

@@ -1,121 +1,79 @@
 import { clamp0 } from "@thi.ng/math/interval";
 import { DIST_SQ, DIST_SQ1, DIST_SQ2, DIST_SQ3 } from "./squared.js";
-/**
- * A {@link INeighborhood} implementation for radial neighbor queries around a
- * given target location, initial query radius and {@link IDistance} metric to
- * determine proximity. Unbounded and unsorted version of {@link KNearest}.
- *
- * @remarks
- * Qualifying neighbors will be accumulated in order of processing via an
- * internal array and can be obtained via {@link Radial.deref} or
- * {@link Radial.values}.
- *
- * @typeParam D - spatial position for distance metric
- * @typeParam T - indexed value
- */
-export class Radial {
-    dist;
-    target;
-    radius;
-    _r;
-    _items;
-    constructor(dist, target, radius = Infinity) {
-        this.dist = dist;
-        this.target = target;
-        this.radius = radius;
-        this.setRadius(radius);
-    }
-    /**
-     * Clears current results.
-     */
-    reset() {
-        this._items = [];
-        return this;
-    }
-    /**
-     * Resets search/reference position and clears current results.
-     *
-     * @param target
-     */
-    setTarget(target) {
-        this.target = target;
-        this.reset();
-    }
-    /**
-     * Resets search/query radius and clears current results.
-     *
-     * @param r
-     */
-    setRadius(r) {
-        this.radius = clamp0(r);
-        this._r = this.dist.to(this.radius);
-        this.reset();
-    }
-    /**
-     * Returns an array of current neighbor result tuples (each `[dist, val]`).
-     *
-     * @remarks
-     * Use {@link Radial.values} to obtain result values **without** their
-     * distance metrics.
-     */
-    deref() {
-        return this._items;
-    }
-    /**
-     * Similar to {@link Radial.deref}, but returns array of result values **without**
-     * their distance metrics.
-     */
-    values() {
-        return this._items.map((x) => x[1]);
-    }
-    includesDistance(d, eucledian = true) {
-        return (eucledian ? this.dist.to(d) : d) <= this._r;
-    }
-    includesPosition(pos) {
-        return this.dist.metric(this.target, pos) < this._r;
-    }
-    consider(pos, val) {
-        const d = this.dist.metric(this.target, pos);
-        if (d <= this._r) {
-            this._items.push([d, val]);
-        }
-        return d;
+class Radial {
+  constructor(dist, target, radius = Infinity) {
+    this.dist = dist;
+    this.target = target;
+    this.radius = radius;
+    this.setRadius(radius);
+  }
+  _r;
+  _items;
+  /**
+   * Clears current results.
+   */
+  reset() {
+    this._items = [];
+    return this;
+  }
+  /**
+   * Resets search/reference position and clears current results.
+   *
+   * @param target
+   */
+  setTarget(target) {
+    this.target = target;
+    this.reset();
+  }
+  /**
+   * Resets search/query radius and clears current results.
+   *
+   * @param r
+   */
+  setRadius(r) {
+    this.radius = clamp0(r);
+    this._r = this.dist.to(this.radius);
+    this.reset();
+  }
+  /**
+   * Returns an array of current neighbor result tuples (each `[dist, val]`).
+   *
+   * @remarks
+   * Use {@link Radial.values} to obtain result values **without** their
+   * distance metrics.
+   */
+  deref() {
+    return this._items;
+  }
+  /**
+   * Similar to {@link Radial.deref}, but returns array of result values **without**
+   * their distance metrics.
+   */
+  values() {
+    return this._items.map((x) => x[1]);
+  }
+  includesDistance(d, eucledian = true) {
+    return (eucledian ? this.dist.to(d) : d) <= this._r;
+  }
+  includesPosition(pos) {
+    return this.dist.metric(this.target, pos) < this._r;
+  }
+  consider(pos, val) {
+    const d = this.dist.metric(this.target, pos);
+    if (d <= this._r) {
+      this._items.push([d, val]);
     }
+    return d;
+  }
 }
-/**
- * Defines a {@link Radial} instance for arbitrary length vector positions
- * and, by default, using an infinite region radius and {@link DIST_SQ} distance
- * metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const radial = (p, r, dist = DIST_SQ) => new Radial(dist, p, r);
-/**
- * Defines a {@link Radial} instance for 2D vector positions and, by default,
- * using an infinite region radius and {@link DIST_SQ2} distance metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const radial2 = (p, r, dist = DIST_SQ2) => new Radial(dist, p, r);
-/**
- * Defines a {@link Radial} instance for 3D vector positions, by default,
- * using an infinite region radius and {@link DIST_SQ3} distance metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const radial3 = (p, r, dist = DIST_SQ3) => new Radial(dist, p, r);
-/**
- * Defines a {@link Radial} instance for numeric positions and, by default,
- * using an infinite region radius and {@link DIST_SQ1} distance metric.
- *
- * @param p -
- * @param r -
- * @param dist -
- */
-export const radialN = (p, r, dist = DIST_SQ1) => new Radial(dist, p, r);
+const radial = (p, r, dist = DIST_SQ) => new Radial(dist, p, r);
+const radial2 = (p, r, dist = DIST_SQ2) => new Radial(dist, p, r);
+const radial3 = (p, r, dist = DIST_SQ3) => new Radial(dist, p, r);
+const radialN = (p, r, dist = DIST_SQ1) => new Radial(dist, p, r);
+export {
+  Radial,
+  radial,
+  radial2,
+  radial3,
+  radialN
+};

package/squared.js

@@ -1,17 +1,23 @@
 import { distSq, distSq2, distSq3 } from "@thi.ng/vectors/distsq";
-export class Squared {
-    metric;
-    constructor(metric) {
-        this.metric = metric;
-    }
-    to(x) {
-        return x * x;
-    }
-    from(x) {
-        return Math.sqrt(x);
-    }
+class Squared {
+  constructor(metric) {
+    this.metric = metric;
+  }
+  to(x) {
+    return x * x;
+  }
+  from(x) {
+    return Math.sqrt(x);
+  }
 }
-export const DIST_SQ = new Squared(distSq);
-export const DIST_SQ1 = new Squared((a, b) => (a - b) ** 2);
-export const DIST_SQ2 = new Squared(distSq2);
-export const DIST_SQ3 = new Squared(distSq3);
+const DIST_SQ = new Squared(distSq);
+const DIST_SQ1 = new Squared((a, b) => (a - b) ** 2);
+const DIST_SQ2 = new Squared(distSq2);
+const DIST_SQ3 = new Squared(distSq3);
+export {
+  DIST_SQ,
+  DIST_SQ1,
+  DIST_SQ2,
+  DIST_SQ3,
+  Squared
+};