@thi.ng/tensors 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-05-02T08:39:24Z
+- **Last updated**: 2025-05-08T15:13:02Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,25 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [0.3.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/tensors@0.3.0) (2025-05-08)
+
+#### 🚀 Features
+
+- add swap(), update defOpRT/TT() fns ([5d2dd2a](https://github.com/thi-ng/umbrella/commit/5d2dd2a))
+- add range() tensor factory ([a8a6365](https://github.com/thi-ng/umbrella/commit/a8a6365))
+- add ITensor.position() & impls ([595764d](https://github.com/thi-ng/umbrella/commit/595764d))
+- add filteredIndices() & presets ([edd8983](https://github.com/thi-ng/umbrella/commit/edd8983))
+  - add nonZeroIndices()
+  - add negativeIndices(), positiveIndices()
+
+#### 🩹 Bug fixes
+
+- update ITensor.broadcast() return type ([f7b2e7a](https://github.com/thi-ng/umbrella/commit/f7b2e7a))
+
+#### ♻️ Refactoring
+
+- update range() impl (w/o dependencies) ([ce89d71](https://github.com/thi-ng/umbrella/commit/ce89d71))
+
 ## [0.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/tensors@0.2.0) (2025-05-02)
 
 #### 🚀 Features

package/README.md

@@ -180,7 +180,7 @@ For Node.js REPL:
 const ten = await import("@thi.ng/tensors");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 7.72 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 8.06 KB
 
 ## Dependencies
 

package/api.d.ts

@@ -80,9 +80,28 @@ export interface ITensor<T = number> extends ICopy<ITensor<T>>, IEquiv, IEqualsD
      *
      * @internal
      */
-    broadcast(shape: number[], stride: number[]): this;
+    broadcast<S extends Shape>(shape: S, stride: S): ShapeTensor<S, T>;
     empty(storage?: ITensorStorage<T>): this;
+    /**
+     * Computes linear array index from given grid position. Reverse-op of
+     * {@link ITensor.position}.
+     *
+     * @param pos
+     */
     index(pos: NumericArray): number;
+    /**
+     * Computes nD grid position for given linear array index. Reverse-op of
+     * {@link ITensor.index}.
+     *
+     * @remarks
+     * **CAUTION:** Currently only supports tensors with positive strides,
+     * otherwise will yield incorrect results! Tensors with negative strides
+     * (aka flipped axes in reverse order) need to be first packed via
+     * {@link ITensor.pack}.
+     *
+     * @param index
+     */
+    position(index: number): number[];
     get(pos: NumericArray): T;
     set(pos: NumericArray, value: T): this;
     lo(pos: NumericArray): this;

package/broadcast.d.ts

@@ -18,7 +18,7 @@ import type { ITensor, Shape } from "./api.js";
  */
 export declare const broadcast: <T = number>(a: ITensor<T>, b: ITensor<T>) => {
     shape: Shape;
-    a: ITensor<T>;
-    b: ITensor<T>;
+    a: ITensor<T> | import("./tensor.js").Tensor4<T> | import("./tensor.js").Tensor3<T> | import("./tensor.js").Tensor2<T> | import("./tensor.js").Tensor1<T>;
+    b: ITensor<T> | import("./tensor.js").Tensor4<T> | import("./tensor.js").Tensor3<T> | import("./tensor.js").Tensor2<T> | import("./tensor.js").Tensor1<T>;
 };
 //# sourceMappingURL=broadcast.d.ts.map

package/defoprt.d.ts

@@ -1,5 +1,5 @@
-import type { Fn0, Fn2 } from "@thi.ng/api";
-import type { TensorOpRT } from "./api.js";
+import type { Fn0 } from "@thi.ng/api";
+import type { TensorData, TensorOpRT } from "./api.js";
 /**
  * Higher order tensor reduction op factory. Takes given reduction `rfn` and
  * `init` function to produce an initial result. Returns a {@link TensorOpRT}
@@ -8,5 +8,5 @@ import type { TensorOpRT } from "./api.js";
  * @param rfn
  * @param init
  */
-export declare const defOpRT: <A = number, B = A>(rfn: Fn2<B, A, B>, init: Fn0<B>) => import("./api.js").MultiTensorOpImpl<TensorOpRT<A, B>>;
+export declare const defOpRT: <A = number, B = A>(rfn: (acc: B, data: TensorData<A>, i: number) => B, init: Fn0<B>) => import("./api.js").MultiTensorOpImpl<TensorOpRT<A, B>>;
 //# sourceMappingURL=defoprt.d.ts.map

package/defoprt.js

@@ -9,7 +9,7 @@ const defOpRT = (rfn, init) => {
     } = a;
     let res = init();
     for (let x = 0; x < sx; x++) {
-      res = rfn(res, data[offset + x * tx]);
+      res = rfn(res, data, offset + x * tx);
     }
     return res;
   };
@@ -25,7 +25,7 @@ const defOpRT = (rfn, init) => {
     for (let x = 0; x < sx; x++) {
       ox = offset + x * tx;
       for (let y = 0; y < sy; y++) {
-        res = rfn(res, data[ox + y * ty]);
+        res = rfn(res, data, ox + y * ty);
       }
     }
     return res;
@@ -44,7 +44,7 @@ const defOpRT = (rfn, init) => {
       for (let y = 0; y < sy; y++) {
         oy = ox + y * ty;
         for (let z = 0; z < sz; z++) {
-          res = rfn(res, data[oy + z * tz]);
+          res = rfn(res, data, oy + z * tz);
         }
       }
     }
@@ -66,7 +66,7 @@ const defOpRT = (rfn, init) => {
         for (let z = 0; z < sz; z++) {
           oz = oy + z * tz;
           for (let w = 0; w < sw; w++) {
-            res = rfn(res, data[oz + w * tw]);
+            res = rfn(res, data, oz + w * tw);
           }
         }
       }

package/defoprtt.d.ts

@@ -1,13 +1,14 @@
-import type { Fn0, Fn3 } from "@thi.ng/api";
-import type { TensorOpRTT } from "./api.js";
+import type { Fn0 } from "@thi.ng/api";
+import type { TensorData, TensorOpRTT } from "./api.js";
 /**
  * Higher order tensor reduction op factory. Takes given reduction `rfn` and
  * `init` function to produce an initial result. Returns a {@link TensorOpRTT}
- * applying the given function componentwise with broadcasting rules (see
- * {@link broadcast} for details).
+ * applying the given function componentwise, by default with broadcasting rules
+ * (see {@link broadcast} for details).
  *
  * @param rfn
  * @param init
+ * @param useBroadcast
  */
-export declare const defOpRTT: <A = number, B = A>(rfn: Fn3<B, A, A, B>, init: Fn0<B>) => TensorOpRTT<A, B>;
+export declare const defOpRTT: <A = number, B = A>(rfn: (acc: B, adata: TensorData<A>, bdata: TensorData<A>, ia: number, ib: number) => B, init: Fn0<B>, useBroadcast?: boolean) => TensorOpRTT<A, B>;
 //# sourceMappingURL=defoprtt.d.ts.map

package/defoprtt.js

@@ -1,5 +1,5 @@
 import { broadcast } from "./broadcast.js";
-const defOpRTT = (rfn, init) => {
+const defOpRTT = (rfn, init, useBroadcast = true) => {
   const f1 = (a, b) => {
     const {
       data: adata,
@@ -14,7 +14,7 @@ const defOpRTT = (rfn, init) => {
     } = b;
     let res = init();
     for (let x = 0; x < sx; x++) {
-      res = rfn(res, adata[oa + x * txa], bdata[ob + x * txb]);
+      res = rfn(res, adata, bdata, oa + x * txa, ob + x * txb);
     }
     return res;
   };
@@ -36,7 +36,7 @@ const defOpRTT = (rfn, init) => {
       oax = oa + x * txa;
       obx = ob + x * txb;
       for (let y = 0; y < sy; y++) {
-        res = rfn(res, adata[oax + y * tya], bdata[obx + y * tyb]);
+        res = rfn(res, adata, bdata, oax + y * tya, obx + y * tyb);
       }
     }
     return res;
@@ -62,7 +62,7 @@ const defOpRTT = (rfn, init) => {
         oay = oax + y * tya;
         oby = obx + y * tyb;
         for (let z = 0; z < sz; z++) {
-          res = rfn(res, adata[oay + z * tza], bdata[oby + z * tzb]);
+          res = rfn(res, adata, bdata, oay + z * tza, oby + z * tzb);
         }
       }
     }
@@ -94,8 +94,10 @@ const defOpRTT = (rfn, init) => {
           for (let w = 0; w < sw; w++) {
             res = rfn(
               res,
-              adata[oaz + w * twa],
-              bdata[obz + w * twb]
+              adata,
+              bdata,
+              oaz + w * twa,
+              obz + w * twb
             );
           }
         }
@@ -104,10 +106,10 @@ const defOpRTT = (rfn, init) => {
     return res;
   };
   const impls = [, f1, f2, f3, f4];
-  const wrapper = (a, b) => {
+  const wrapper = useBroadcast ? (a, b) => {
     const { shape, a: $a, b: $b } = broadcast(a, b);
     return impls[shape.length]($a, $b);
-  };
+  } : (a, b) => impls[a.dim](a, b);
   return wrapper;
 };
 export {

package/dot.js

@@ -1,6 +1,6 @@
 import { defOpRTT } from "./defoprtt.js";
 const dot = defOpRTT(
-  (acc, x, y) => acc + x * y,
+  (acc, adata, bdata, ia, ib) => acc + adata[ia] * bdata[ib],
   () => 0
 );
 export {

package/filtered-indices.d.ts

@@ -0,0 +1,34 @@
+import type { Predicate } from "@thi.ng/api";
+/**
+ * Higher order function. Takes a predicate function and returns a new function
+ * which accepts a tensor and then returns an array of tensor component indices
+ * for which the predicate passed.
+ *
+ * @remarks
+ * Also see {@link nonZeroIndices}.
+ *
+ * @param pred
+ */
+export declare const filteredIndices: <T = number>(pred: Predicate<T>) => import("./api.js").MultiTensorOpImpl<import("./api.js").TensorOpRT<T, number[]>>;
+/**
+ * Returns an array of indices where the given tensor has non-zero component
+ * values.
+ *
+ * @param a
+ */
+export declare const nonZeroIndices: import("./api.js").MultiTensorOpImpl<import("./api.js").TensorOpRT<number, number[]>>;
+/**
+ * Returns an array of indices where the given tensor has negative component
+ * values.
+ *
+ * @param a
+ */
+export declare const negativeIndices: import("./api.js").MultiTensorOpImpl<import("./api.js").TensorOpRT<number, number[]>>;
+/**
+ * Returns an array of indices where the given tensor has positive component
+ * values.
+ *
+ * @param a
+ */
+export declare const positiveIndices: import("./api.js").MultiTensorOpImpl<import("./api.js").TensorOpRT<number, number[]>>;
+//# sourceMappingURL=filtered-indices.d.ts.map

package/filtered-indices.js

@@ -0,0 +1,17 @@
+import { defOpRT } from "./defoprt.js";
+const filteredIndices = (pred) => defOpRT(
+  (acc, data, i) => {
+    if (pred(data[i])) acc.push(i);
+    return acc;
+  },
+  () => []
+);
+const nonZeroIndices = filteredIndices((x) => x !== 0);
+const negativeIndices = filteredIndices((x) => x < 0);
+const positiveIndices = filteredIndices((x) => x > 0);
+export {
+  filteredIndices,
+  negativeIndices,
+  nonZeroIndices,
+  positiveIndices
+};

package/index.d.ts

@@ -21,6 +21,7 @@ export * from "./dot.js";
 export * from "./errors.js";
 export * from "./exp.js";
 export * from "./exp2.js";
+export * from "./filtered-indices.js";
 export * from "./format.js";
 export * from "./identity.js";
 export * from "./log.js";
@@ -40,6 +41,7 @@ export * from "./pow.js";
 export * from "./pown.js";
 export * from "./product.js";
 export * from "./rand-distrib.js";
+export * from "./range.js";
 export * from "./relu.js";
 export * from "./relun.js";
 export * from "./select.js";
@@ -56,6 +58,7 @@ export * from "./sub.js";
 export * from "./subn.js";
 export * from "./sum.js";
 export * from "./svd.js";
+export * from "./swap.js";
 export * from "./tan.js";
 export * from "./tanh.js";
 export * from "./tensor.js";

package/index.js

@@ -21,6 +21,7 @@ export * from "./dot.js";
 export * from "./errors.js";
 export * from "./exp.js";
 export * from "./exp2.js";
+export * from "./filtered-indices.js";
 export * from "./format.js";
 export * from "./identity.js";
 export * from "./log.js";
@@ -40,6 +41,7 @@ export * from "./pow.js";
 export * from "./pown.js";
 export * from "./product.js";
 export * from "./rand-distrib.js";
+export * from "./range.js";
 export * from "./relu.js";
 export * from "./relun.js";
 export * from "./select.js";
@@ -56,6 +58,7 @@ export * from "./sub.js";
 export * from "./subn.js";
 export * from "./sum.js";
 export * from "./svd.js";
+export * from "./swap.js";
 export * from "./tan.js";
 export * from "./tanh.js";
 export * from "./tensor.js";

package/magsq.js

@@ -1,6 +1,6 @@
 import { defOpRT } from "./defoprt.js";
 const magSq = defOpRT(
-  (acc, x) => acc + x * x,
+  (acc, data, i) => acc + data[i] ** 2,
   () => 0
 );
 export {

package/normalize.d.ts

@@ -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: (out: ITensor | null, a: ITensor, n?: number) => import("./tensor.js").Tensor1<any> | ITensor<number>;
 //# sourceMappingURL=normalize.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/tensors",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage",
   "type": "module",
   "module": "./index.js",
@@ -170,6 +170,9 @@
     "./exp2": {
       "default": "./exp2.js"
     },
+    "./filtered-indices": {
+      "default": "./filtered-indices.js"
+    },
     "./format": {
       "default": "./format.js"
     },
@@ -227,6 +230,9 @@
     "./rand-distrib": {
       "default": "./rand-distrib.js"
     },
+    "./range": {
+      "default": "./range.js"
+    },
     "./relu": {
       "default": "./relu.js"
     },
@@ -275,6 +281,9 @@
     "./svd": {
       "default": "./svd.js"
     },
+    "./swap": {
+      "default": "./swap.js"
+    },
     "./tan": {
       "default": "./tan.js"
     },
@@ -292,5 +301,5 @@
     "status": "alpha",
     "year": 2018
   },
-  "gitHead": "21e1e46f087a0b8e53b7eafa38ac38a83596ef8f\n"
+  "gitHead": "8e61726779260744ea70bfe38438e755d6b53844\n"
 }

package/product.js

@@ -1,6 +1,8 @@
-import { $mul } from "@thi.ng/vectors/ops";
 import { defOpRT } from "./defoprt.js";
-const product = defOpRT($mul, () => 1);
+const product = defOpRT(
+  (acc, data, i) => acc * data[i],
+  () => 1
+);
 export {
   product
 };

package/range.d.ts

@@ -0,0 +1,20 @@
+import type { TensorOpts } from "./api.js";
+import { Tensor1 } from "./tensor.js";
+/**
+ * Creates a 1D tensor of monotonically increasing values in the interval `[0,max)`.
+ *
+ * @param max
+ * @param opts
+ */
+export declare function range(max: number, opts?: Pick<TensorOpts<number, any>, "storage">): Tensor1;
+/**
+ * Creates a 1D tensor of monotonically increasing values in the interval
+ * `[min,max)`, using optional `step` and `opts`. If `from <= to`, the default
+ * step is 1, otherise -1.
+ *
+ * @param from
+ * @param to
+ * @param opts
+ */
+export declare function range(from: number, to: number, step?: number, opts?: Pick<TensorOpts<number, any>, "storage">): Tensor1;
+//# sourceMappingURL=range.d.ts.map

package/range.js

@@ -0,0 +1,28 @@
+import { peek } from "@thi.ng/arrays/peek";
+import { isPlainObject } from "@thi.ng/checks";
+import { tensor, Tensor1 } from "./tensor.js";
+function range(...args) {
+  const opts = isPlainObject(peek(args)) ? args.pop() : void 0;
+  let [from, to, step] = args;
+  if (to === void 0) {
+    to = from;
+    from = 0;
+  }
+  step = step === void 0 ? from < to ? 1 : -1 : step;
+  const data = [];
+  if (step > 0) {
+    while (from < to) {
+      data.push(from);
+      from += step;
+    }
+  } else if (step < 0) {
+    while (from > to) {
+      data.push(from);
+      from += step;
+    }
+  }
+  return tensor("num", [data.length], { ...opts, data });
+}
+export {
+  range
+};

package/sum.js

@@ -1,6 +1,8 @@
-import { $add } from "@thi.ng/vectors/ops";
 import { defOpRT } from "./defoprt.js";
-const sum = defOpRT($add, () => 0);
+const sum = defOpRT(
+  (acc, data, i) => acc + data[i],
+  () => 0
+);
 export {
   sum
 };

package/swap.d.ts

@@ -0,0 +1,26 @@
+import type { ITensor } from "./api.js";
+/**
+ * Swaps all data value of the two given tensors (which must have same shape).
+ * Returns `a`.
+ *
+ * @remarks
+ * Combined with {@link ITensor.pick}, this can be used to swap
+ * columns/rows/slices of a shared parent tensor.
+ *
+ * ```ts tangle:../export/swap.ts
+ * import { swap, range, print } from "@thi.ng/tensors";
+ *
+ * const a = range(12).reshape([3,4]);
+ * print(a);
+ *
+ * // swap data from 1st & 3rd column
+ * swap(a.pick([-1,0]), a.pick([-1,2]));
+ *
+ * print(a);
+ * ```
+ *
+ * @param a
+ * @param b
+ */
+export declare const swap: <A, TA extends ITensor<A>>(a: TA, b: TA) => TA;
+//# sourceMappingURL=swap.d.ts.map

package/swap.js

@@ -0,0 +1,15 @@
+import { defOpRTT } from "./defoprtt.js";
+const $swap = defOpRTT(
+  (_, adata, bdata, ia, ib) => {
+    const t = adata[ia];
+    adata[ia] = bdata[ib];
+    bdata[ib] = t;
+  },
+  () => {
+  },
+  false
+);
+const swap = (a, b) => $swap(a, b);
+export {
+  swap
+};

package/tensor.d.ts

@@ -14,12 +14,13 @@ export declare abstract class ATensor<T = number> implements ITensor<T> {
     get orderedShape(): number[];
     get orderedStride(): number[];
     abstract [Symbol.iterator](): IterableIterator<T>;
-    broadcast(shape: number[], stride: number[]): typeof this;
+    broadcast<S extends Shape>(shape: S, stride: S): ShapeTensor<S, T>;
     copy(): typeof this;
     empty(storage?: ITensorStorage<T>): typeof this;
     equiv(o: any): boolean;
     eqDelta(o: ITensor<T>, eps?: number): boolean;
     abstract index(pos: NumericArray): number;
+    position(index: number): any[];
     abstract get(pos: NumericArray): T;
     abstract set(pos: NumericArray, v: T): this;
     hi(pos: NumericArray): this;
@@ -43,6 +44,7 @@ export declare class Tensor1<T = number> extends ATensor<T> {
     get order(): number[];
     get length(): number;
     index([x]: NumericArray): number;
+    position(index: number): number[];
     get([x]: NumericArray): T;
     set([x]: NumericArray, v: T): this;
     pick([x]: NumericArray): Tensor1<T>;
@@ -125,6 +127,6 @@ export declare function tensorFromArray<T extends NumType, N extends Nested<numb
 export declare function tensorFromArray<N extends Nested<string>>(data: N, opts?: TensorFromArrayOpts<"str", string>): NestedTensor<N, string>;
 export declare const zeroes: <S extends Shape>(shape: S, type?: NumType, storage?: ITensorStorage<number>) => ShapeTensor<S, number>;
 export declare const ones: <S extends Shape>(shape: S, type?: NumType, storage?: ITensorStorage<number>) => ShapeTensor<S, number>;
-export declare const shapeToStride: (shape: NumericArray) => any[];
+export declare const shapeToStride: (shape: number[]) => any[];
 export declare const strideOrder: (strides: number[]) => number[];
 //# sourceMappingURL=tensor.d.ts.map

package/tensor.js

@@ -30,7 +30,7 @@ class ATensor {
     return swizzle(this.order)(this.stride);
   }
   broadcast(shape, stride) {
-    return new this.constructor(
+    return new TENSOR_IMPLS[shape.length](
       this.type,
       this.storage,
       this.data,
@@ -64,6 +64,16 @@ class ATensor {
   eqDelta(o, eps = 1e-6) {
     return this === o || equiv(this.shape, o.shape) && _eqDelta([...this], [...o], this.length, eps);
   }
+  position(index) {
+    const { order, stride } = this;
+    index -= this.offset;
+    const idx = order.map((o) => {
+      const i = ~~(index / stride[o]);
+      index -= i * stride[o];
+      return i;
+    });
+    return swizzle(order)(idx);
+  }
   hi(pos) {
     return new this.constructor(
       this.type,
@@ -167,6 +177,9 @@ class Tensor1 extends ATensor {
   index([x]) {
     return this.offset + x * this.stride[0];
   }
+  position(index) {
+    return [~~((index - this.offset) / this.stride[0])];
+  }
   get([x]) {
     return this.data[this.offset + x * this.stride[0]];
   }

package/defopbtt.d.ts

@@ -1,11 +0,0 @@
-import type { FnU2 } from "@thi.ng/api";
-import type { ITensor } from "./api.js";
-/**
- * Higher order tensor op factory. Takes given `fn` and returns a
- * {@link TensorOpTT}s applying the given function component-wise.
- *
- * @param fn
- * @param dispatch
- */
-export declare const defOpBTT: <T = number>(fn: FnU2<T>) => (out: ITensor<T> | null, a: ITensor<T>, b: ITensor<T>) => ITensor<T>;
-//# sourceMappingURL=defopbtt.d.ts.map

package/defopbtt.js

@@ -1,153 +0,0 @@
-import { equals } from "@thi.ng/vectors/equals";
-import { broadcast } from "./broadcast.js";
-import { illegalShape } from "./errors.js";
-import { tensor } from "./tensor.js";
-const defOpBTT = (fn) => {
-  const f1 = (out, a, b) => {
-    !out && (out = a);
-    const {
-      data: odata,
-      offset: oo,
-      stride: [txo]
-    } = out;
-    const {
-      data: adata,
-      offset: oa,
-      shape: [sx],
-      stride: [txa]
-    } = a;
-    const {
-      data: bdata,
-      offset: ob,
-      stride: [txb]
-    } = b;
-    for (let x = 0; x < sx; x++) {
-      odata[oo + x * txo] = fn(adata[oa + x * txa], bdata[ob + x * txb]);
-    }
-    return out;
-  };
-  const f2 = (out, a, b) => {
-    !out && (out = a);
-    const {
-      data: odata,
-      offset: oo,
-      stride: [txo, tyo]
-    } = out;
-    const {
-      data: adata,
-      offset: oa,
-      shape: [sx, sy],
-      stride: [txa, tya]
-    } = a;
-    const {
-      data: bdata,
-      offset: ob,
-      stride: [txb, tyb]
-    } = b;
-    let oox, oax, obx;
-    for (let x = 0; x < sx; x++) {
-      oox = oo + x * txo;
-      oax = oa + x * txa;
-      obx = ob + x * txb;
-      for (let y = 0; y < sy; y++) {
-        odata[oox + y * tyo] = fn(
-          adata[oax + y * tya],
-          bdata[obx + y * tyb]
-        );
-      }
-    }
-    return out;
-  };
-  const f3 = (out, a, b) => {
-    !out && (out = a);
-    const {
-      data: odata,
-      offset: oo,
-      stride: [txo, tyo, tzo]
-    } = out;
-    const {
-      data: adata,
-      offset: oa,
-      shape: [sx, sy, sz],
-      stride: [txa, tya, tza]
-    } = a;
-    const {
-      data: bdata,
-      offset: ob,
-      stride: [txb, tyb, tzb]
-    } = b;
-    let oox, oax, obx, ooy, oay, oby;
-    for (let x = 0; x < sx; x++) {
-      oox = oo + x * txo;
-      oax = oa + x * txa;
-      obx = ob + x * txb;
-      for (let y = 0; y < sy; y++) {
-        ooy = oox + y * tyo;
-        oay = oax + y * tya;
-        oby = obx + y * tyb;
-        for (let z = 0; z < sz; z++) {
-          odata[ooy + z * tzo] = fn(
-            adata[oay + z * tza],
-            bdata[oby + z * tzb]
-          );
-        }
-      }
-    }
-    return out;
-  };
-  const f4 = (out, a, b) => {
-    !out && (out = a);
-    const {
-      data: odata,
-      offset: oo,
-      stride: [txo, tyo, tzo, two]
-    } = out;
-    const {
-      data: adata,
-      offset: oa,
-      shape: [sx, sy, sz, sw],
-      stride: [txa, tya, tza, twa]
-    } = a;
-    const {
-      data: bdata,
-      offset: ob,
-      stride: [txb, tyb, tzb, twb]
-    } = b;
-    let oox, oax, obx, ooy, oay, oby, ooz, oaz, obz;
-    for (let x = 0; x < sx; x++) {
-      oox = oo + x * txo;
-      oax = oa + x * txa;
-      obx = ob + x * txb;
-      for (let y = 0; y < sy; y++) {
-        ooy = oox + y * tyo;
-        oay = oax + y * tya;
-        oby = obx + y * tyb;
-        for (let z = 0; z < sz; z++) {
-          ooz = ooy + z * tzo;
-          oaz = oay + z * tza;
-          obz = oby + z * tzb;
-          for (let w = 0; w < sw; w++) {
-            odata[ooz + w * two] = fn(
-              adata[oaz + w * twa],
-              bdata[obz + w * twb]
-            );
-          }
-        }
-      }
-    }
-    return out;
-  };
-  const impls = [, f1, f2, f3, f4];
-  return (out, a, b) => {
-    const { shape, a: $a, b: $b } = broadcast(a, b);
-    if (out) {
-      if (!equals(out.shape, shape)) illegalShape(out.shape);
-    } else {
-      out = tensor(a.type, shape, { storage: a.storage });
-    }
-    return impls[shape.length](out, $a, $b);
-  };
-};
-export {
-  defOpBTT
-};