@thi.ng/tensors 0.1.0 → 0.3.0

package/broadcast.js

@@ -0,0 +1,54 @@
+import { illegalArgs } from "@thi.ng/errors";
+import { equals } from "@thi.ng/vectors";
+import { max } from "@thi.ng/vectors/max";
+const broadcast = (a, b) => {
+  if (equals(a.shape, b.shape)) return { shape: a.shape, a, b };
+  const ashape = a.shape.slice();
+  const astride = a.stride.slice();
+  const bshape = b.shape.slice();
+  const bstride = b.stride.slice();
+  let da = a.dim;
+  let db = b.dim;
+  let bcastA = da < db;
+  let bcastB = db < da;
+  if (bcastA) {
+    while (da < db) {
+      ashape.unshift(1);
+      astride.unshift(0);
+      da++;
+    }
+  } else if (bcastB) {
+    while (db < da) {
+      bshape.unshift(1);
+      bstride.unshift(0);
+      db++;
+    }
+  }
+  for (let i = 0; i < da; i++) {
+    const sa = ashape[i];
+    const sb = bshape[i];
+    if (sa < sb) {
+      if (sa > 1) __broadcastError(ashape, bshape);
+      astride[i] = 0;
+      bcastA = true;
+    } else if (sb < sa) {
+      if (sb > 1) __broadcastError(ashape, bshape);
+      bstride[i] = 0;
+      bcastB = true;
+    }
+  }
+  const shape = max([], ashape, bshape);
+  return {
+    shape,
+    a: bcastA ? a.broadcast(shape, astride) : a,
+    b: bcastB ? b.broadcast(shape, bstride) : b
+  };
+};
+const __broadcastError = (ashape, bshape) => illegalArgs(
+  `incompatible shapes: ${JSON.stringify(ashape)} vs ${JSON.stringify(
+    bshape
+  )}`
+);
+export {
+  broadcast
+};

package/clamp.d.ts

@@ -1,47 +1,13 @@
 /**
  * Componentwise clamps nD tensor `a` to closed interval defined by `[b,c]`.
- * Writes result to `out`. If `out` is null, mutates `a`. Multi-method.
+ * Writes result to `out`. If `out` is null, creates a new tensor using `a`'s
+ * type and storage provider and shape as determined by broadcasting rules (see
+ * {@link broadcast} for details).
  *
  * @param out - output tensor
  * @param a - input tensor
  * @param b - input tensor (min)
  * @param c - input tensor (max)
  */
-export declare const clamp: import("./api.js").MultiTensorOpTTT<number>;
-/**
- * Same as {@link clamp} for 1D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - input tensor (min)
- * @param c - input tensor (max)
- */
-export declare const clamp1: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
-/**
- * Same as {@link clamp} for 2D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - input tensor (min)
- * @param c - input tensor (max)
- */
-export declare const clamp2: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
-/**
- * Same as {@link clamp} for 3D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - input tensor (min)
- * @param c - input tensor (max)
- */
-export declare const clamp3: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
-/**
- * Same as {@link clamp} for 4D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - input tensor (min)
- * @param c - input tensor (max)
- */
-export declare const clamp4: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+export declare const clamp: import("./api.js").TensorOpTTT<number>;
 //# sourceMappingURL=clamp.d.ts.map

package/clamp.js

@@ -1,15 +1,6 @@
 import { clamp as op } from "@thi.ng/math/interval";
 import { defOpTTT } from "./defopttt.js";
-const [a, b, c, d, e] = defOpTTT(op);
-const clamp = a;
-const clamp1 = b;
-const clamp2 = c;
-const clamp3 = d;
-const clamp4 = e;
+const clamp = defOpTTT(op);
 export {
-  clamp,
-  clamp1,
-  clamp2,
-  clamp3,
-  clamp4
+  clamp
 };

package/clampn.d.ts

@@ -7,41 +7,5 @@
  * @param b - scalar (min)
  * @param c - scalar (max)
  */
-export declare const clampN: import("./api.js").MultiTensorOpTNN<number>;
-/**
- * Same as {@link clampN} for 1D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - scalar (min)
- * @param c - scalar (max)
- */
-export declare const clampN1: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
-/**
- * Same as {@link clampN} for 2D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - scalar (min)
- * @param c - scalar (max)
- */
-export declare const clampN2: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
-/**
- * Same as {@link clampN} for 3D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - scalar (min)
- * @param c - scalar (max)
- */
-export declare const clampN3: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
-/**
- * Same as {@link clampN} for 4D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param b - scalar (min)
- * @param c - scalar (max)
- */
-export declare const clampN4: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+export declare const clampN: import("./api.js").MultiTensorOpImpl<import("./api.js").TensorOpTNN<number>>;
 //# sourceMappingURL=clampn.d.ts.map

package/clampn.js

@@ -1,15 +1,6 @@
 import { clamp as op } from "@thi.ng/math/interval";
 import { defOpTNN } from "./defoptnn.js";
-const [a, b, c, d, e] = defOpTNN(op);
-const clampN = a;
-const clampN1 = b;
-const clampN2 = c;
-const clampN3 = d;
-const clampN4 = e;
+const clampN = defOpTNN(op);
 export {
-  clampN,
-  clampN1,
-  clampN2,
-  clampN3,
-  clampN4
+  clampN
 };

package/cos.d.ts

@@ -5,33 +5,5 @@
  * @param out - output tensor
  * @param a - input tensor
  */
-export declare const cos: import("./api.js").MultiTensorOpT<number>;
-/**
- * Same as {@link cos} for 1D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- */
-export declare const cos1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
-/**
- * Same as {@link cos} for 2D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- */
-export declare const cos2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
-/**
- * Same as {@link cos} for 3D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- */
-export declare const cos3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
-/**
- * Same as {@link cos} for 4D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- */
-export declare const cos4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+export declare const cos: import("./api.js").MultiTensorOpImpl<import("./api.js").TensorOpT<number>>;
 //# sourceMappingURL=cos.d.ts.map

package/cos.js

@@ -1,14 +1,5 @@
 import { defOpT } from "./defopt.js";
-const [a, b, c, d, e] = defOpT(Math.cos);
-const cos = a;
-const cos1 = b;
-const cos2 = c;
-const cos3 = d;
-const cos4 = e;
+const cos = defOpT(Math.cos);
 export {
-  cos,
-  cos1,
-  cos2,
-  cos3,
-  cos4
+  cos
 };

package/defopn.d.ts

@@ -1,13 +1,10 @@
 import type { Fn } from "@thi.ng/api";
-import type { MultiTensorOpN, TensorOpN } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { TensorOpN } from "./api.js";
 /**
- * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
- * {@link TensorOpN}s applying the given function component-wise. The result
- * tuple uses this order: `[polymorphic, 1d, 2d, 3d, 4d]`.
+ * Higher order tensor op factory. Takes given `fn` and returns a
+ * {@link TensorOpN} applying the given function component-wise.
  *
  * @param fn
- * @param dispatch
  */
-export declare const defOpN: <A = number, B = A>(fn: Fn<A, B>) => [MultiTensorOpN<A, B>, TensorOpN<A, B, Tensor1<B>>, TensorOpN<A, B, Tensor2<B>>, TensorOpN<A, B, Tensor3<B>>, TensorOpN<A, B, Tensor4<B>>];
+export declare const defOpN: <A = number, B = A>(fn: Fn<A, B>) => import("./api.js").MultiTensorOpImpl<TensorOpN<A, B>>;
 //# sourceMappingURL=defopn.d.ts.map

package/defopn.js

@@ -17,8 +17,9 @@ const defOpN = (fn) => {
       stride: [tx, ty],
       offset
     } = out;
+    let ox;
     for (let x = 0; x < sx; x++) {
-      const ox = offset + x * tx;
+      ox = offset + x * tx;
       for (let y = 0; y < sy; y++) data[ox + y * ty] = fn(a);
     }
     return out;
@@ -30,10 +31,11 @@ const defOpN = (fn) => {
       stride: [tx, ty, tz],
       offset
     } = out;
+    let ox, oy;
     for (let x = 0; x < sx; x++) {
-      const ox = offset + x * tx;
+      ox = offset + x * tx;
       for (let y = 0; y < sy; y++) {
-        const oy = ox + y * ty;
+        oy = ox + y * ty;
         for (let z = 0; z < sz; z++) data[oy + z * tz] = fn(a);
       }
     }
@@ -46,19 +48,27 @@ const defOpN = (fn) => {
       stride: [tx, ty, tz, tw],
       offset
     } = out;
+    let ox, oy, oz;
     for (let x = 0; x < sx; x++) {
-      const ox = offset + x * tx;
+      ox = offset + x * tx;
       for (let y = 0; y < sy; y++) {
-        const oy = ox + y * ty;
+        oy = ox + y * ty;
         for (let z = 0; z < sz; z++) {
-          const oz = oy + z * tz;
+          oz = oy + z * tz;
           for (let w = 0; w < sw; w++) data[oz + w * tw] = fn(a);
         }
       }
     }
     return out;
   };
-  return [top(0, void 0, f1, f2, f3, f4), f1, f2, f3, f4];
+  return top(
+    0,
+    void 0,
+    f1,
+    f2,
+    f3,
+    f4
+  );
 };
 export {
   defOpN

package/defoprt.d.ts

@@ -1,14 +1,12 @@
-import type { Fn0, Fn2 } from "@thi.ng/api";
-import type { MultiTensorOpRT, TensorOpRT } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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 4-tuple of
- * {@link TensorOpRT}s applying the given function component-wise. The result
- * tuple uses this order: `[polymorphic, 1d, 2d, 3d]`.
+ * `init` function to produce an initial result. Returns a {@link TensorOpRT}
+ * applying the given function component-wise.
  *
  * @param rfn
  * @param init
  */
-export declare const defOpRT: <A = number, B = A>(rfn: Fn2<B, A, B>, init: Fn0<B>) => [MultiTensorOpRT<A, B>, TensorOpRT<A, B, Tensor1<A>>, TensorOpRT<A, B, Tensor2<A>>, TensorOpRT<A, B, Tensor3<A>>, TensorOpRT<A, B, Tensor4<A>>];
+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;
   };
@@ -21,10 +21,11 @@ const defOpRT = (rfn, init) => {
       stride: [tx, ty]
     } = a;
     let res = init();
+    let ox;
     for (let x = 0; x < sx; x++) {
-      const ox = offset + x * tx;
+      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;
@@ -37,12 +38,13 @@ const defOpRT = (rfn, init) => {
       stride: [tx, ty, tz]
     } = a;
     let res = init();
+    let ox, oy;
     for (let x = 0; x < sx; x++) {
-      const ox = offset + x * tx;
+      ox = offset + x * tx;
       for (let y = 0; y < sy; y++) {
-        const oy = ox + y * ty;
+        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);
         }
       }
     }
@@ -56,21 +58,29 @@ const defOpRT = (rfn, init) => {
       stride: [tx, ty, tz, tw]
     } = a;
     let res = init();
+    let ox, oy, oz;
     for (let x = 0; x < sx; x++) {
-      const ox = offset + x * tx;
+      ox = offset + x * tx;
       for (let y = 0; y < sy; y++) {
-        const oy = ox + y * ty;
+        oy = ox + y * ty;
         for (let z = 0; z < sz; z++) {
-          const oz = oy + z * tz;
+          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);
           }
         }
       }
     }
     return res;
   };
-  return [top(0, void 0, f1, f2, f3, f4), f1, f2, f3, f4];
+  return top(
+    0,
+    void 0,
+    f1,
+    f2,
+    f3,
+    f4
+  );
 };
 export {
   defOpRT

package/defoprtt.d.ts

@@ -1,14 +1,14 @@
-import type { Fn0, Fn3 } from "@thi.ng/api";
-import type { MultiTensorOpRTT, TensorOpRTT } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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 4-tuple of
- * {@link TensorOpRTT}s applying the given function component-wise. The result
- * tuple uses this order: `[polymorphic, 1d, 2d, 3d]`.
+ * `init` function to produce an initial result. Returns a {@link TensorOpRTT}
+ * 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>) => [MultiTensorOpRTT<A, B>, TensorOpRTT<A, B, Tensor1<A>>, TensorOpRTT<A, B, Tensor2<A>>, TensorOpRTT<A, B, Tensor3<A>>, TensorOpRTT<A, B, Tensor4<A>>];
+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 { top } from "./top.js";
-const defOpRTT = (rfn, init) => {
+import { broadcast } from "./broadcast.js";
+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;
   };
@@ -31,11 +31,12 @@ const defOpRTT = (rfn, init) => {
       stride: [txb, tyb]
     } = b;
     let res = init();
+    let oax, obx;
     for (let x = 0; x < sx; x++) {
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
+      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;
@@ -53,14 +54,15 @@ const defOpRTT = (rfn, init) => {
       stride: [txb, tyb, tzb]
     } = b;
     let res = init();
+    let oax, obx, oay, oby;
     for (let x = 0; x < sx; x++) {
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
       for (let y = 0; y < sy; y++) {
-        const oay = oax + y * tya;
-        const oby = obx + y * tyb;
+        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);
         }
       }
     }
@@ -79,20 +81,23 @@ const defOpRTT = (rfn, init) => {
       stride: [txb, tyb, tzb, twb]
     } = b;
     let res = init();
+    let oax, obx, oay, oby, oaz, obz;
     for (let x = 0; x < sx; x++) {
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
       for (let y = 0; y < sy; y++) {
-        const oay = oax + y * tya;
-        const oby = obx + y * tyb;
+        oay = oax + y * tya;
+        oby = obx + y * tyb;
         for (let z = 0; z < sz; z++) {
-          const oaz = oay + z * tza;
-          const obz = oby + z * tzb;
+          oaz = oay + z * tza;
+          obz = oby + z * tzb;
           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
             );
           }
         }
@@ -100,13 +105,12 @@ const defOpRTT = (rfn, init) => {
     }
     return res;
   };
-  return [
-    top(0, void 0, f1, f2, f3, f4),
-    f1,
-    f2,
-    f3,
-    f4
-  ];
+  const impls = [, f1, f2, f3, f4];
+  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 {
   defOpRTT

package/defopt.d.ts

@@ -1,13 +1,10 @@
 import type { Fn } from "@thi.ng/api";
-import type { MultiTensorOpT, TensorOpT } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { TensorOpT } from "./api.js";
 /**
- * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
- * {@link TensorOpT}s applying the given function component-wise. The result
- * tuple uses this order: `[polymorphic, 1d, 2d, 3d, 4d]`.
+ * Higher order tensor op factory. Takes given `fn` and returns a
+ * {@link TensorOpT} applying the given function component-wise.
  *
  * @param fn
- * @param dispatch
  */
-export declare const defOpT: <T = number>(fn: Fn<T, T>, dispatch?: number) => [MultiTensorOpT<T>, TensorOpT<T, T, Tensor1<T>, Tensor1<T>>, TensorOpT<T, T, Tensor2<T>, Tensor2<T>>, TensorOpT<T, T, Tensor3<T>, Tensor3<T>>, TensorOpT<T, T, Tensor4<T>, Tensor4<T>>];
+export declare const defOpT: <T = number>(fn: Fn<T, T>) => import("./api.js").MultiTensorOpImpl<TensorOpT<T>>;
 //# sourceMappingURL=defopt.d.ts.map

package/defopt.js

@@ -1,5 +1,5 @@
 import { top } from "./top.js";
-const defOpT = (fn, dispatch = 1) => {
+const defOpT = (fn) => {
   const f1 = (out, a) => {
     !out && (out = a);
     const {
@@ -31,9 +31,10 @@ const defOpT = (fn, dispatch = 1) => {
       shape: [sx, sy],
       stride: [txa, tya]
     } = a;
+    let oox, oax;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
       for (let y = 0; y < sy; y++) {
         odata[oox + y * tyo] = fn(adata[oax + y * tya]);
       }
@@ -53,12 +54,13 @@ const defOpT = (fn, dispatch = 1) => {
       shape: [sx, sy, sz],
       stride: [txa, tya, tza]
     } = a;
+    let oox, oax, ooy, oay;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
       for (let y = 0; y < sy; y++) {
-        const ooy = oox + y * tyo;
-        const oay = oax + y * tya;
+        ooy = oox + y * tyo;
+        oay = oax + y * tya;
         for (let z = 0; z < sz; z++) {
           odata[ooy + z * tzo] = fn(adata[oay + z * tza]);
         }
@@ -79,15 +81,16 @@ const defOpT = (fn, dispatch = 1) => {
       shape: [sx, sy, sz, sw],
       stride: [txa, tya, tza, twa]
     } = a;
+    let oox, oax, ooy, oay, ooz, oaz;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
       for (let y = 0; y < sy; y++) {
-        const ooy = oox + y * tyo;
-        const oay = oax + y * tya;
+        ooy = oox + y * tyo;
+        oay = oax + y * tya;
         for (let z = 0; z < sz; z++) {
-          const ooz = ooy + z * tzo;
-          const oaz = oay + z * tza;
+          ooz = ooy + z * tzo;
+          oaz = oay + z * tza;
           for (let w = 0; w < sw; w++) {
             odata[ooz + w * two] = fn(adata[oaz + w * twa]);
           }
@@ -96,13 +99,7 @@ const defOpT = (fn, dispatch = 1) => {
     }
     return out;
   };
-  return [
-    top(dispatch, void 0, f1, f2, f3, f4),
-    f1,
-    f2,
-    f3,
-    f4
-  ];
+  return top(1, void 0, f1, f2, f3, f4);
 };
 export {
   defOpT

package/defoptn.d.ts

@@ -1,13 +1,10 @@
 import type { FnU2 } from "@thi.ng/api";
-import type { MultiTensorOpTN, TensorOpTN } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { TensorOpTN } from "./api.js";
 /**
- * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
- * {@link TensorOpTN}s applying the given function component-wise. The result
- * tuple uses this order: `[polymorphic, 1d, 2d, 3d, 4d]`.
+ * Higher order tensor op factory. Takes given `fn` and returns a
+ * {@link TensorOpTN} applying the given function component-wise.
  *
  * @param fn
- * @param dispatch
  */
-export declare const defOpTN: <T = number>(fn: FnU2<T>, dispatch?: number) => [MultiTensorOpTN<T>, TensorOpTN<T, T, Tensor1<T>, Tensor1<T>>, TensorOpTN<T, T, Tensor2<T>, Tensor2<T>>, TensorOpTN<T, T, Tensor3<T>, Tensor3<T>>, TensorOpTN<T, T, Tensor4<T>, Tensor4<T>>];
+export declare const defOpTN: <T = number>(fn: FnU2<T>) => import("./api.js").MultiTensorOpImpl<TensorOpTN<T>>;
 //# sourceMappingURL=defoptn.d.ts.map