@thi.ng/tensors 0.10.13 → 0.11.0

package/diagonal.js

@@ -1,16 +1,14 @@
 import { sum as vsum } from "@thi.ng/vectors/sum";
 import { sum } from "./sum.js";
 import { Tensor1 } from "./tensor.js";
-const diagonal = (a) => {
-  return new Tensor1(
-    a.type,
-    a.storage,
-    a.data,
-    [Math.min(...a.shape)],
-    [vsum(a.stride)],
-    a.offset
-  );
-};
+const diagonal = (a) => new Tensor1(
+  a.type,
+  a.storage,
+  a.data,
+  [Math.min(...a.shape)],
+  [vsum(a.stride)],
+  a.offset
+);
 const trace = (a) => sum(diagonal(a));
 export {
   diagonal,

package/find.d.ts

@@ -0,0 +1,4 @@
+import type { Predicate } from "@thi.ng/api";
+import type { ITensor1 } from "./api.js";
+export declare const findIndex: <T = number>(a: ITensor1<T>, pred: Predicate<T>, start?: number, end?: number) => number;
+//# sourceMappingURL=find.d.ts.map

package/find.js

@@ -0,0 +1,14 @@
+const findIndex = (a, pred, start = 0, end = a.length) => {
+  const {
+    offset: oa,
+    stride: [ta],
+    data: adata
+  } = a;
+  for (let i = start; i < end; i++) {
+    if (pred(adata[oa + i * ta])) return i;
+  }
+  return -1;
+};
+export {
+  findIndex
+};

package/histogram.d.ts

@@ -0,0 +1,69 @@
+import type { Range1_24 } from "@thi.ng/api";
+import type { ITensor, ITensor1 } from "./api.js";
+/**
+ * Computes the histogram of given uint-based tensor. Returns histogram as a 1D
+ * tensor of `u32` values. The `depth` param defines the value range (as number
+ * of bits) of the input values (max. 24 bits). The optional `mask` and `shift`
+ * params are used to transform input values like so: `(x >>> shift) & mask`.
+ * This allows extracting sub-ranges from a packed integer representation (e.g.
+ * indidivual color channels from a pixel buffer).
+ *
+ * @remarks
+ * Also see {@link equalizeHistogram} and {@link applyLUT}.
+ *
+ * @example
+ * ```ts tangle:../export/histogram-uint.ts
+ * import { histogramUint, tensor } from "@thi.ng/tensors";
+ *
+ * const src = tensor("u8", [3,3], { data: [12,4,4, 16,16,32, 64,48,4] });
+ *
+ * // compute histogram with input value range = 8 bits
+ * const hist = histogramUint(src, 8);
+ *
+ * console.log(hist.data);
+ * // Uint8Array(256) [
+ * //   0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+ * //   2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ * //   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ * //   1, 0, 0, 0, 0, 0, 0 ...
+ * // ]
+ * ```
+ *
+ * @param src
+ * @param depth
+ * @param mask
+ * @param shift
+ */
+export declare const histogramUint: (src: ITensor, depth: Range1_24, mask?: number, shift?: number) => ITensor1<number>;
+/**
+ * Takes a 1D tensor containing a histogram (e.g. obtained via
+ * {@link histogramUint}) and applies histogram equalization by first
+ * normalizing the histogram, computing its cumulative distribution (via
+ * {@link cdf}), determining the used min/max input value range and then
+ * rescaling values to produce a lookup table (LUT) for remapping input values
+ * via {@link applyLUT}.
+ *
+ * @remarks
+ * References:
+ *
+ * - https://en.wikipedia.org/wiki/Histogram_equalization
+ *
+ * @param out
+ * @param src
+ * @param depth
+ * @param numSamples
+ * @param threshold
+ */
+export declare const equalizeHistogram: (out: ITensor1 | null, src: ITensor1, depth: number, numSamples: number, threshold?: number) => ITensor1;
+/**
+ * Applies given lookup table to `a` and writes results to `out`. I.e. `out[i] =
+ * lut[a[i]]`. This is intended as last step of a histogram equalization process
+ * to transform `a` via applying the histogram obtained via
+ * {@link equalizeHistogram}.
+ *
+ * @param out
+ * @param a
+ * @param lut
+ */
+export declare const applyLUT: (out: ITensor | null, a: ITensor, lut: ITensor1) => import("./api.js").ITensor0<number>;
+//# sourceMappingURL=histogram.d.ts.map

package/histogram.js

@@ -0,0 +1,60 @@
+import { cdf } from "./cdf.js";
+import { defOpT } from "./defopt.js";
+import { ensureShape } from "./errors.js";
+import { findIndex } from "./find.js";
+import { mulN } from "./muln.js";
+import { tensor } from "./tensor.js";
+const histogramUint = (src, depth, mask = (1 << depth) - 1, shift = 0) => {
+  const histType = src.length < 256 ? "u8" : src.length < 65536 ? "u16" : "u32";
+  const histogram = tensor(histType, [1 << depth]);
+  if (src.dim > 1) src = src.reshape([src.length]);
+  const {
+    offset: oa,
+    shape: [sa],
+    stride: [ta],
+    data: adata
+  } = src;
+  for (let i = 0; i < sa; i++)
+    histogram.data[adata[oa + i * ta] >>> shift & mask]++;
+  return histogram;
+};
+const equalizeHistogram = (out, src, depth, numSamples, threshold = 0) => {
+  !out && (out = src);
+  ensureShape(out, src.shape);
+  const norm = mulN(tensor("f64", [src.length]), src, 1 / numSamples);
+  const $cdf = cdf(null, norm);
+  const lo = findIndex($cdf, (x) => x > threshold);
+  if (lo < 0) return out.fill(0);
+  const {
+    offset: oc,
+    shape: [sc],
+    stride: [tc],
+    data: cdata
+  } = $cdf;
+  const {
+    offset: oo,
+    stride: [to],
+    data: odata
+  } = out;
+  const base = cdata[oc + lo * tc];
+  const scale = (2 ** depth - 1) / (cdata[oc + (sc - 1) * tc] - base);
+  for (let i = 0; i < sc; i++) {
+    odata[oo + i * to] = Math.max(0, scale * (cdata[oc + i * tc] - base));
+  }
+  return out;
+};
+const applyLUT = (out, a, lut) => {
+  !out && (out = a);
+  ensureShape(out, a.shape);
+  const {
+    offset: ol,
+    stride: [tl],
+    data: ldata
+  } = lut;
+  return defOpT((x) => ldata[ol + x * tl])(out, a);
+};
+export {
+  applyLUT,
+  equalizeHistogram,
+  histogramUint
+};

package/identity.d.ts

@@ -1,5 +1,4 @@
-import type { TensorOpts, Type } from "./api.js";
-import { Tensor2 } from "./tensor.js";
+import type { ITensor2, TensorOpts, Type } from "./api.js";
 /**
  * Creates a square identity matrix of given `size` and options.
  *
@@ -7,5 +6,5 @@ import { Tensor2 } from "./tensor.js";
  * @param size
  * @param opts
  */
-export declare const identity: <T extends Exclude<Type, "str">>(type: T, size: number, opts?: Pick<TensorOpts<any, any>, "storage">) => Tensor2<number>;
+export declare const identity: <T extends Exclude<Type, "str">>(type: T, size: number, opts?: Pick<TensorOpts<any, any>, "storage">) => ITensor2;
 //# sourceMappingURL=identity.d.ts.map

package/index.d.ts

@@ -4,6 +4,7 @@ export * from "./addn.js";
 export * from "./api.js";
 export * from "./apply-kernel.js";
 export * from "./broadcast.js";
+export * from "./cdf.js";
 export * from "./clamp.js";
 export * from "./clampn.js";
 export * from "./convert.js";
@@ -24,8 +25,10 @@ export * from "./dot.js";
 export * from "./errors.js";
 export * from "./exp.js";
 export * from "./exp2.js";
+export * from "./find.js";
 export * from "./filtered-indices.js";
 export * from "./format.js";
+export * from "./histogram.js";
 export * from "./identity.js";
 export * from "./integrate.js";
 export * from "./kernels.js";

package/index.js

@@ -4,6 +4,7 @@ export * from "./addn.js";
 export * from "./api.js";
 export * from "./apply-kernel.js";
 export * from "./broadcast.js";
+export * from "./cdf.js";
 export * from "./clamp.js";
 export * from "./clampn.js";
 export * from "./convert.js";
@@ -24,8 +25,10 @@ export * from "./dot.js";
 export * from "./errors.js";
 export * from "./exp.js";
 export * from "./exp2.js";
+export * from "./find.js";
 export * from "./filtered-indices.js";
 export * from "./format.js";
+export * from "./histogram.js";
 export * from "./identity.js";
 export * from "./integrate.js";
 export * from "./kernels.js";

package/integrate.d.ts

@@ -1,6 +1,5 @@
 import type { Fn } from "@thi.ng/api";
-import type { ITensor } from "./api.js";
-import { Tensor1 } from "./tensor.js";
+import type { ITensor, ITensor1 } from "./api.js";
 /**
  * Integrates given tensor along innermost dimension and writes result to 1D
  * tensor `out` (or creates new one).
@@ -30,5 +29,5 @@ import { Tensor1 } from "./tensor.js";
  * @param a
  * @param fn
  */
-export declare const integrate: (out: Tensor1 | null, a: ITensor, fn?: Fn<ITensor, number>) => Tensor1;
+export declare const integrate: (out: ITensor1 | null, a: ITensor, fn?: Fn<ITensor, number>) => ITensor1;
 //# sourceMappingURL=integrate.d.ts.map

package/integrate.js

@@ -1,6 +1,6 @@
 import { ensureShape } from "./errors.js";
-import { Tensor1 } from "./tensor.js";
 import { sum } from "./sum.js";
+import { Tensor1 } from "./tensor.js";
 const integrate = (out, a, fn = sum) => {
   const { shape, dim } = a;
   const odim = shape[shape.length - 1];

package/kernels.d.ts

@@ -2,46 +2,46 @@ import type { KernelSpec } from "./api.js";
 /**
  * 1D Sobel convolution kernel.
  */
-export declare const SOBEL1: import("./tensor.js").Tensor1<number>;
+export declare const SOBEL1: import("./api.js").ITensor1<number>;
 /**
  * 2D Sobel convolution kernel (along outer axis).
  *
  * @remarks
  * Use `SOBEL2.transpose([1, 0])` for inner axis.
  */
-export declare const SOBEL2: import("./tensor.js").Tensor2<number>;
+export declare const SOBEL2: import("./api.js").ITensor2<number>;
 /**
  * 3D Sobel convolution kernel (along outer axis).
  *
  * @remarks
  * Use `SOBEL3.transpose()` for other axes.
  */
-export declare const SOBEL3: import("./tensor.js").Tensor3<number>;
+export declare const SOBEL3: import("./api.js").ITensor3<number>;
 /**
  * 2D edge detection convolution kernel factory for given integer radius `r`.
  * Returns 2D tensor of size `2*r+1`.
  *
  * @param r
  */
-export declare const EDGE2: (r: number) => import("./tensor.js").Tensor2<number>;
+export declare const EDGE2: (r: number) => import("./api.js").ITensor2<number>;
 /**
  * 2D sharpen 3x3 kernel preset.
  */
-export declare const SHARPEN2_3x3: import("./tensor.js").Tensor2<number>;
+export declare const SHARPEN2_3x3: import("./api.js").ITensor2<number>;
 /**
  * 2D box blur convolution kernel factory for given integer radius `r`. Returns
  * 2D tensor of size `2*r+1`.
  *
  * @param r
  */
-export declare const BOX_BLUR2: (r: number) => import("./tensor.js").Tensor2<number>;
+export declare const BOX_BLUR2: (r: number) => import("./api.js").ITensor2<number>;
 /**
  * 2D Gaussian blur kernel factory for given integer radius `r`. Returns 2D
  * tensor of size `2r+1`.
  *
  * @param r -
  */
-export declare const GAUSSIAN_BLUR2: (r: number) => import("./tensor.js").Tensor2<number>;
+export declare const GAUSSIAN_BLUR2: (r: number) => import("./api.js").ITensor2<number>;
 /**
  * Max. pool kernel factory for given window size and use with
  * {@link applyKernel}. The kernel produces the maximum value in its window.

package/mulm.d.ts

@@ -1,4 +1,4 @@
-import { type Tensor2 } from "./tensor.js";
+import type { ITensor2 } from "./api.js";
 /**
  * Matrix-matrix multiplication between matrix `a` (MxN) and matrix `b` (PxQ).
  * If `out` is given, it MUST be a MxQ tensor. If null then a new one will be
@@ -8,5 +8,5 @@ import { type Tensor2 } from "./tensor.js";
  * @param a
  * @param b
  */
-export declare const mulM: (out: Tensor2 | null, a: Tensor2, b: Tensor2) => Tensor2<number>;
+export declare const mulM: (out: ITensor2 | null, a: ITensor2, b: ITensor2) => ITensor2;
 //# sourceMappingURL=mulm.d.ts.map

package/mulv.d.ts

@@ -1,4 +1,4 @@
-import { type Tensor1, type Tensor2 } from "./tensor.js";
+import type { ITensor1, ITensor2 } from "./api.js";
 /**
  * Matrix-vector multiplication. If `out` is null, a new 1D tensor will be
  * created, using vector `b`'s type and storage impl.
@@ -7,5 +7,5 @@ import { type Tensor1, type Tensor2 } from "./tensor.js";
  * @param a
  * @param b
  */
-export declare const mulV: (out: Tensor1 | null, a: Tensor2, b: Tensor1) => Tensor1<number>;
+export declare const mulV: (out: ITensor1 | null, a: ITensor2, b: ITensor1) => ITensor1;
 //# sourceMappingURL=mulv.d.ts.map

package/normalize.d.ts

@@ -1,4 +1,4 @@
-import type { ITensor } from "./api.js";
+import type { TensorOpTNO } from "./api.js";
 /**
  * Normalizes tensor `a` to given magnitude `n` (default: 1) and writes result
  * to `out`. If `out` is null, mutates `a`.
@@ -7,5 +7,5 @@ import type { ITensor } from "./api.js";
  * @param a
  * @param n
  */
-export declare const normalize: (out: ITensor | null, a: ITensor, n?: number) => ITensor<number> | import("./tensor.js").Tensor1<any>;
+export declare const normalize: TensorOpTNO;
 //# sourceMappingURL=normalize.d.ts.map

package/normalize.js

@@ -4,7 +4,7 @@ import { set } from "./set.js";
 const normalize = (out, a, n = 1) => {
   !out && (out = a);
   const m = Math.sqrt(magSq(a));
-  return m >= 1e-6 ? mulN(out || a, a, n / m) : out !== a ? set(out, a) : out;
+  return m >= 1e-6 ? mulN(out, a, n / m) : out !== a ? set(out, a) : out;
 };
 export {
   normalize

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/tensors",
-	"version": "0.10.13",
+	"version": "0.11.0",
 	"description": "0D/1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage",
 	"type": "module",
 	"module": "./index.js",
@@ -8,7 +8,8 @@
 	"sideEffects": false,
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/thi-ng/umbrella.git"
+		"url": "git+https://github.com/thi-ng/umbrella.git",
+		"directory": "packages/tensors"
 	},
 	"homepage": "https://thi.ng/tensors",
 	"funding": [
@@ -39,15 +40,15 @@
 		"tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
 	},
 	"dependencies": {
-		"@thi.ng/api": "^8.12.13",
-		"@thi.ng/arrays": "^2.14.6",
-		"@thi.ng/checks": "^3.8.3",
-		"@thi.ng/equiv": "^2.1.103",
-		"@thi.ng/errors": "^2.6.2",
-		"@thi.ng/math": "^5.15.2",
-		"@thi.ng/random": "^4.1.38",
-		"@thi.ng/strings": "^3.9.34",
-		"@thi.ng/vectors": "^8.6.19"
+		"@thi.ng/api": "^8.12.14",
+		"@thi.ng/arrays": "^2.14.7",
+		"@thi.ng/checks": "^3.8.4",
+		"@thi.ng/equiv": "^2.1.104",
+		"@thi.ng/errors": "^2.6.3",
+		"@thi.ng/math": "^5.15.3",
+		"@thi.ng/random": "^4.1.39",
+		"@thi.ng/strings": "^3.9.35",
+		"@thi.ng/vectors": "^8.6.20"
 	},
 	"devDependencies": {
 		"esbuild": "^0.27.2",
@@ -342,5 +343,5 @@
 		"status": "alpha",
 		"year": 2018
 	},
-	"gitHead": "828ec2e9ffde7307231b03cff46598c0915b1857\n"
+	"gitHead": "3f0b151fb2283888314eb34206ba50c2dd5c7af6\n"
 }

package/rand-distrib.d.ts

@@ -1,7 +1,6 @@
 import type { Fn0 } from "@thi.ng/api";
-import type { ITensor } from "./api.js";
-import type { Tensor0, Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
-export declare const randDistrib0: (a: Tensor0, rnd?: () => number, n?: number) => Tensor0<number>;
+import type { ITensor, ITensor0, ITensor1, ITensor2, ITensor3, ITensor4 } from "./api.js";
+export declare const randDistrib0: (a: ITensor0, rnd?: () => number, n?: number) => ITensor0;
 /**
  * Same as {@link randDistrib} for 1D tensors.
  *
@@ -9,7 +8,7 @@ export declare const randDistrib0: (a: Tensor0, rnd?: () => number, n?: number)
  * @param rnd
  * @param n
  */
-export declare const randDistrib1: (a: Tensor1, rnd?: () => number, n?: number) => Tensor1<number>;
+export declare const randDistrib1: (a: ITensor1, rnd?: () => number, n?: number) => ITensor1;
 /**
  * Same as {@link randDistrib} for 2D tensors.
  *
@@ -17,7 +16,7 @@ export declare const randDistrib1: (a: Tensor1, rnd?: () => number, n?: number)
  * @param rnd
  * @param n
  */
-export declare const randDistrib2: (a: Tensor2, rnd?: () => number, n?: number) => Tensor2<number>;
+export declare const randDistrib2: (a: ITensor2, rnd?: () => number, n?: number) => ITensor2;
 /**
  * Same as {@link randDistrib} for 3D tensors.
  *
@@ -25,7 +24,7 @@ export declare const randDistrib2: (a: Tensor2, rnd?: () => number, n?: number)
  * @param rnd
  * @param n
  */
-export declare const randDistrib3: (a: Tensor3, rnd?: () => number, n?: number) => Tensor3<number>;
+export declare const randDistrib3: (a: ITensor3, rnd?: () => number, n?: number) => ITensor3;
 /**
  * Same as {@link randDistrib} for 3D tensors.
  *
@@ -33,7 +32,7 @@ export declare const randDistrib3: (a: Tensor3, rnd?: () => number, n?: number)
  * @param rnd
  * @param n
  */
-export declare const randDistrib4: (a: Tensor4, rnd?: () => number, n?: number) => Tensor4<number>;
+export declare const randDistrib4: (a: ITensor4, rnd?: () => number, n?: number) => ITensor4;
 /**
  * Randomizes given nD tensor `a`, with each component drawn from given random
  * distribution function (default: gaussian/normal distribution) and scaled to

package/range.d.ts

@@ -1,5 +1,4 @@
-import type { NumType, TensorOpts } from "./api.js";
-import { Tensor1 } from "./tensor.js";
+import type { ITensor1, NumType, TensorOpts } from "./api.js";
 export interface RangeOpts<T extends NumType> extends Pick<TensorOpts<T, [number]>, "storage"> {
     /**
      * Tensor data type.
@@ -14,7 +13,7 @@ export interface RangeOpts<T extends NumType> extends Pick<TensorOpts<T, [number
  * @param max
  * @param opts
  */
-export declare function range<T extends NumType>(max: number, opts?: RangeOpts<T>): Tensor1;
+export declare function range<T extends NumType>(max: number, opts?: RangeOpts<T>): ITensor1;
 /**
  * Creates a 1D tensor of monotonically increasing values in the interval
  * `[min,max)`, using optional `step` and `opts`. If `from <= to`, the default
@@ -24,5 +23,5 @@ export declare function range<T extends NumType>(max: number, opts?: RangeOpts<T
  * @param to
  * @param opts
  */
-export declare function range<T extends NumType>(from: number, to: number, step?: number, opts?: RangeOpts<T>): Tensor1;
+export declare function range<T extends NumType>(from: number, to: number, step?: number, opts?: RangeOpts<T>): ITensor1;
 //# sourceMappingURL=range.d.ts.map

package/range.js

@@ -1,6 +1,6 @@
 import { peek } from "@thi.ng/arrays/peek";
 import { isPlainObject } from "@thi.ng/checks";
-import { tensor, Tensor1 } from "./tensor.js";
+import { tensor } from "./tensor.js";
 function range(...args) {
   const opts = isPlainObject(peek(args)) ? args.pop() : void 0;
   const type = opts?.type ?? "num";

package/sample.d.ts

@@ -1,11 +1,10 @@
 import type { Fn2, Fn3, Fn4, Fn5, FnN, FnN2 } from "@thi.ng/api";
-import type { ITensor } from "./api.js";
-import { type Tensor1 } from "./tensor.js";
+import type { ITensor1, ITensor2, ITensor3, ITensor4 } from "./api.js";
 type BoundaryFn = FnN2;
-type Sampler1 = Fn2<ITensor, number, number>;
-type Sampler2 = Fn3<ITensor, number, number, number>;
-type Sampler3 = Fn4<ITensor, number, number, number, number>;
-type Sampler4 = Fn5<ITensor, number, number, number, number, number>;
+type Sampler1 = Fn2<ITensor1, number, number>;
+type Sampler2 = Fn3<ITensor2, number, number, number>;
+type Sampler3 = Fn4<ITensor3, number, number, number, number>;
+type Sampler4 = Fn5<ITensor4, number, number, number, number, number>;
 type BoundaryType = "clamp" | "mirror" | "wrap" | "zero";
 type SamplerType = "nearest" | "linear" | "cubic" | "lanczos";
 interface SamplerKernel {
@@ -20,8 +19,8 @@ export declare const defSampler1: (kernel: SamplerKernel | SamplerType, boundary
 export declare const defSampler2: (kernel: SamplerType | SamplerKernel | [SamplerType | SamplerKernel, SamplerType | SamplerKernel], boundary?: BoundaryType | BoundaryFn | [BoundaryType | BoundaryFn, BoundaryType | BoundaryFn]) => Sampler2;
 export declare const defSampler3: (kernel: SamplerType | SamplerKernel | [SamplerType | SamplerKernel, SamplerType | SamplerKernel, SamplerType | SamplerKernel], boundary?: BoundaryType | BoundaryFn | [BoundaryType | BoundaryFn, BoundaryType | BoundaryFn, BoundaryType | BoundaryFn]) => Sampler3;
 export declare const defSampler4: (kernel: SamplerType | SamplerKernel | [SamplerType | SamplerKernel, SamplerType | SamplerKernel, SamplerType | SamplerKernel, SamplerType | SamplerKernel], boundary?: BoundaryType | BoundaryFn | [BoundaryType | BoundaryFn, BoundaryType | BoundaryFn, BoundaryType | BoundaryFn, BoundaryType | BoundaryFn]) => Sampler4;
-export declare const resample1: (out: Tensor1, a: Tensor1, sampler: Sampler1) => Tensor1<number>;
-export declare const resample2: (out: ITensor, a: ITensor, [samplerX, samplerY]: Sampler1[]) => ITensor<number>;
-export declare const resample3: (out: ITensor, a: ITensor, [samplerX, samplerY, samplerZ]: Sampler1[]) => ITensor<number>;
+export declare const resample1: (out: ITensor1, a: ITensor1, sampler: Sampler1) => ITensor1;
+export declare const resample2: (out: ITensor2, a: ITensor2, [samplerX, samplerY]: Sampler1[]) => ITensor2;
+export declare const resample3: (out: ITensor3, a: ITensor3, [samplerX, samplerY, samplerZ]: Sampler1[]) => ITensor3;
 export {};
 //# sourceMappingURL=sample.d.ts.map

package/sample.js

@@ -238,10 +238,18 @@ const resample2 = (out, a, [samplerX, samplerY]) => {
   } = a;
   const tmp = tensor("num", [sxa, syo]);
   for (let x = 0; x < sxa; x++) {
-    resample1(tmp.pick([x, -1]), a.pick([x, -1]), samplerX);
+    resample1(
+      tmp.pick([x, -1]),
+      a.pick([x, -1]),
+      samplerX
+    );
   }
   for (let y = 0; y < syo; y++) {
-    resample1(out.pick([-1, y]), tmp.pick([-1, y]), samplerY);
+    resample1(
+      out.pick([-1, y]),
+      tmp.pick([-1, y]),
+      samplerY
+    );
   }
   return out;
 };
@@ -257,7 +265,11 @@ const resample3 = (out, a, [samplerX, samplerY, samplerZ]) => {
     const src = a.pick([i]);
     const dest = tmpX.pick([i]);
     for (let j = 0; j < sya; j++) {
-      resample1(dest.pick([j]), src.pick([j]), samplerX);
+      resample1(
+        dest.pick([j]),
+        src.pick([j]),
+        samplerX
+      );
     }
   }
   const tmpY = tensor("num", [sxa, syo, szo]);
@@ -265,12 +277,20 @@ const resample3 = (out, a, [samplerX, samplerY, samplerZ]) => {
     const src = tmpX.pick([i]);
     const dest = tmpY.pick([i]);
     for (let j = 0; j < szo; j++) {
-      resample1(dest.pick([-1, j]), src.pick([-1, j]), samplerY);
+      resample1(
+        dest.pick([-1, j]),
+        src.pick([-1, j]),
+        samplerY
+      );
     }
   }
   for (let i = 0; i < syo; i++) {
     for (let j = 0; j < szo; j++) {
-      resample1(out.pick([-1, i, j]), tmpY.pick([-1, i, j]), samplerZ);
+      resample1(
+        out.pick([-1, i, j]),
+        tmpY.pick([-1, i, j]),
+        samplerZ
+      );
     }
   }
   return out;

package/select.d.ts

@@ -1,6 +1,5 @@
 import type { Fn, Predicate2 } from "@thi.ng/api";
-import type { ITensor } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { ITensor, ITensor1, ITensor2, ITensor3, ITensor4 } from "./api.js";
 /**
  * Result type of {@link select}.
  */
@@ -16,7 +15,7 @@ export type SelectResult<T> = {
  * @param pred
  * @param initial
  */
-export declare const select1: <A, B>(a: Tensor1<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
+export declare const select1: <A, B>(a: ITensor1<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
 /**
  * Same as {@link select} for 2D tensors.
  *
@@ -25,7 +24,7 @@ export declare const select1: <A, B>(a: Tensor1<A>, xform: Fn<A, B>, pred: Predi
  * @param pred
  * @param initial
  */
-export declare const select2: <A, B>(a: Tensor2<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
+export declare const select2: <A, B>(a: ITensor2<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
 /**
  * Same as {@link select} for 3D tensors.
  *
@@ -34,7 +33,7 @@ export declare const select2: <A, B>(a: Tensor2<A>, xform: Fn<A, B>, pred: Predi
  * @param pred
  * @param initial
  */
-export declare const select3: <A, B>(a: Tensor3<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
+export declare const select3: <A, B>(a: ITensor3<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
 /**
  * Same as {@link select} for 4D tensors.
  *
@@ -43,7 +42,7 @@ export declare const select3: <A, B>(a: Tensor3<A>, xform: Fn<A, B>, pred: Predi
  * @param pred
  * @param initial
  */
-export declare const select4: <A, B>(a: Tensor4<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
+export declare const select4: <A, B>(a: ITensor4<A>, xform: Fn<A, B>, pred: Predicate2<B>, initial: B) => SelectResult<B>;
 /**
  * Uses given value transform `xform` and predicate `pred` to select a specific
  * component value and its position in the tensor. The `initial` value is used

package/set.d.ts

@@ -1,3 +1,3 @@
 import type { ITensor } from "./api.js";
-export declare const set: <T>(out: ITensor<T>, src: ITensor<T>) => import("./tensor.js").Tensor1<any>;
+export declare const set: <T>(out: ITensor<T>, src: ITensor<T>) => import("./api.js").ITensor0<any>;
 //# sourceMappingURL=set.d.ts.map

package/softmax.d.ts

@@ -1,4 +1,4 @@
-import type { ITensor } from "./api.js";
+import type { TensorOpTNO } from "./api.js";
 /**
  * Computes softmax (aka normalized {@link exp}) of input tensor `src` and
  * writes results to `out` (or if null, back into `src`). The optional
@@ -23,5 +23,5 @@ import type { ITensor } from "./api.js";
  * @param src -
  * @param temperature -
  */
-export declare const softMax: (out: ITensor | null, src: ITensor, temperature?: number) => import("./tensor.js").Tensor1<number>;
+export declare const softMax: TensorOpTNO;
 //# sourceMappingURL=softmax.d.ts.map