@thi.ng/tensors 0.1.0 → 0.2.0

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

package/defoptn.js

@@ -1,5 +1,5 @@
 import { top } from "./top.js";
-const defOpTN = (fn, dispatch = 1) => {
+const defOpTN = (fn) => {
   const f1 = (out, a, n) => {
     !out && (out = a);
     const {
@@ -31,9 +31,10 @@ const defOpTN = (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], n);
       }
@@ -53,12 +54,13 @@ const defOpTN = (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], n);
         }
@@ -79,15 +81,16 @@ const defOpTN = (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], n);
           }
@@ -96,13 +99,7 @@ const defOpTN = (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 {
   defOpTN

package/defoptnn.d.ts

@@ -1,13 +1,10 @@
 import type { FnU3 } from "@thi.ng/api";
-import type { MultiTensorOpTNN, TensorOpTNN } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { TensorOpTNN } from "./api.js";
 /**
- * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
- * {@link TensorOpTNN}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 TensorOpTNN} applying the given function component-wise.
  *
  * @param fn
- * @param dispatch
  */
-export declare const defOpTNN: <T = number>(fn: FnU3<T>, dispatch?: number) => [MultiTensorOpTNN<T>, TensorOpTNN<T, T, Tensor1<T>, Tensor1<T>>, TensorOpTNN<T, T, Tensor2<T>, Tensor2<T>>, TensorOpTNN<T, T, Tensor3<T>, Tensor3<T>>, TensorOpTNN<T, T, Tensor4<T>, Tensor4<T>>];
+export declare const defOpTNN: <T = number>(fn: FnU3<T>) => import("./api.js").MultiTensorOpImpl<TensorOpTNN<T>>;
 //# sourceMappingURL=defoptnn.d.ts.map

package/defoptnn.js

@@ -1,5 +1,5 @@
 import { top } from "./top.js";
-const defOpTNN = (fn, dispatch = 1) => {
+const defOpTNN = (fn) => {
   const f1 = (out, a, n, m) => {
     !out && (out = a);
     const {
@@ -31,9 +31,10 @@ const defOpTNN = (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], n, m);
       }
@@ -53,12 +54,13 @@ const defOpTNN = (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], n, m);
         }
@@ -79,15 +81,16 @@ const defOpTNN = (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], n, m);
           }
@@ -96,13 +99,14 @@ const defOpTNN = (fn, dispatch = 1) => {
     }
     return out;
   };
-  return [
-    top(dispatch, void 0, f1, f2, f3, f4),
+  return top(
+    1,
+    void 0,
     f1,
     f2,
     f3,
     f4
-  ];
+  );
 };
 export {
   defOpTNN

package/defoptt.d.ts

@@ -1,13 +1,12 @@
 import type { FnU2 } from "@thi.ng/api";
-import type { MultiTensorOpTT, TensorOpTT } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { TensorOpTT } from "./api.js";
 /**
- * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
- * {@link TensorOpTT}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 TensorOpTT} applying the given function componentwise with
+ * broadcasting rules (see {@link broadcast} for details).
  *
  * @param fn
  * @param dispatch
  */
-export declare const defOpTT: <T = number>(fn: FnU2<T>, dispatch?: number) => [MultiTensorOpTT<T>, TensorOpTT<T, T, Tensor1<T>, Tensor1<T>>, TensorOpTT<T, T, Tensor2<T>, Tensor2<T>>, TensorOpTT<T, T, Tensor3<T>, Tensor3<T>>, TensorOpTT<T, T, Tensor4<T>, Tensor4<T>>];
+export declare const defOpTT: <T = number>(fn: FnU2<T>) => TensorOpTT<T>;
 //# sourceMappingURL=defoptt.d.ts.map

package/defoptt.js

@@ -1,5 +1,7 @@
-import { top } from "./top.js";
-const defOpTT = (fn, dispatch = 1) => {
+import { broadcast } from "./broadcast.js";
+import { ensureShape } from "./errors.js";
+import { tensor } from "./tensor.js";
+const defOpTT = (fn) => {
   const f1 = (out, a, b) => {
     !out && (out = a);
     const {
@@ -41,10 +43,11 @@ const defOpTT = (fn, dispatch = 1) => {
       offset: ob,
       stride: [txb, tyb]
     } = b;
+    let oox, oax, obx;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
+      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],
@@ -72,14 +75,15 @@ const defOpTT = (fn, dispatch = 1) => {
       offset: ob,
       stride: [txb, tyb, tzb]
     } = b;
+    let oox, oax, obx, ooy, oay, oby;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
       for (let y = 0; y < sy; y++) {
-        const ooy = oox + y * tyo;
-        const oay = oax + y * tya;
-        const oby = obx + y * tyb;
+        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],
@@ -108,18 +112,19 @@ const defOpTT = (fn, dispatch = 1) => {
       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++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
       for (let y = 0; y < sy; y++) {
-        const ooy = oox + y * tyo;
-        const oay = oax + y * tya;
-        const oby = obx + y * tyb;
+        ooy = oox + y * tyo;
+        oay = oax + y * tya;
+        oby = obx + y * tyb;
         for (let z = 0; z < sz; z++) {
-          const ooz = ooy + z * tzo;
-          const oaz = oay + z * tza;
-          const obz = oby + z * tzb;
+          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],
@@ -131,13 +136,17 @@ const defOpTT = (fn, dispatch = 1) => {
     }
     return out;
   };
-  return [
-    top(dispatch, void 0, f1, f2, f3, f4),
-    f1,
-    f2,
-    f3,
-    f4
-  ];
+  const impls = [, f1, f2, f3, f4];
+  const wrapper = (out, a, b) => {
+    const { shape, a: $a, b: $b } = broadcast(a, b);
+    if (out) {
+      ensureShape(out, shape);
+    } else {
+      out = tensor(a.type, shape, { storage: a.storage });
+    }
+    return impls[shape.length](out, $a, $b);
+  };
+  return wrapper;
 };
 export {
   defOpTT

package/defopttt.d.ts

@@ -1,13 +1,11 @@
 import type { FnU3 } from "@thi.ng/api";
-import type { MultiTensorOpTTT, TensorOpTTT } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { TensorOpTTT } from "./api.js";
 /**
- * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
- * {@link TensorOpTTT}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 TensorOpTTT} applying the given function componentwise with
+ * broadcasting rules (see {@link broadcast} for details).
  *
  * @param fn
- * @param dispatch
  */
-export declare const defOpTTT: <T = number>(fn: FnU3<T>, dispatch?: number) => [MultiTensorOpTTT<T>, TensorOpTTT<T, T, Tensor1<T>, Tensor1<T>>, TensorOpTTT<T, T, Tensor2<T>, Tensor2<T>>, TensorOpTTT<T, T, Tensor3<T>, Tensor3<T>>, TensorOpTTT<T, T, Tensor4<T>, Tensor4<T>>];
+export declare const defOpTTT: <T = number>(fn: FnU3<T>) => TensorOpTTT<T>;
 //# sourceMappingURL=defopttt.d.ts.map

package/defopttt.js

@@ -1,7 +1,8 @@
-import { top } from "./top.js";
-const defOpTTT = (fn, dispatch = 1) => {
+import { broadcast } from "./broadcast.js";
+import { ensureShape } from "./errors.js";
+import { tensor } from "./tensor.js";
+const defOpTTT = (fn) => {
   const f1 = (out, a, b, c) => {
-    !out && (out = a);
     const {
       data: odata,
       offset: oo,
@@ -33,7 +34,6 @@ const defOpTTT = (fn, dispatch = 1) => {
     return out;
   };
   const f2 = (out, a, b, c) => {
-    !out && (out = a);
     const {
       data: odata,
       offset: oo,
@@ -55,11 +55,12 @@ const defOpTTT = (fn, dispatch = 1) => {
       offset: oc,
       stride: [txc, tyc]
     } = c;
+    let oox, oax, obx, ocx;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
-      const ocx = oc + x * txc;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
+      ocx = oc + x * txc;
       for (let y = 0; y < sy; y++) {
         odata[oox + y * tyo] = fn(
           adata[oax + y * tya],
@@ -71,7 +72,6 @@ const defOpTTT = (fn, dispatch = 1) => {
     return out;
   };
   const f3 = (out, a, b, c) => {
-    !out && (out = a);
     const {
       data: odata,
       offset: oo,
@@ -93,16 +93,17 @@ const defOpTTT = (fn, dispatch = 1) => {
       offset: oc,
       stride: [txc, tyc, tzc]
     } = c;
+    let oox, oax, obx, ocx, ooy, oay, oby, ocy;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
-      const ocx = oc + x * txc;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
+      ocx = oc + x * txc;
       for (let y = 0; y < sy; y++) {
-        const ooy = oox + y * tyo;
-        const oay = oax + y * tya;
-        const oby = obx + y * tyb;
-        const ocy = ocx + y * tyc;
+        ooy = oox + y * tyo;
+        oay = oax + y * tya;
+        oby = obx + y * tyb;
+        ocy = ocx + y * tyc;
         for (let z = 0; z < sz; z++) {
           odata[ooy + z * tzo] = fn(
             adata[oay + z * tza],
@@ -115,7 +116,6 @@ const defOpTTT = (fn, dispatch = 1) => {
     return out;
   };
   const f4 = (out, a, b, c) => {
-    !out && (out = a);
     const {
       data: odata,
       offset: oo,
@@ -137,21 +137,22 @@ const defOpTTT = (fn, dispatch = 1) => {
       offset: oc,
       stride: [txc, tyc, tzc, twc]
     } = c;
+    let oox, oax, obx, ocx, ooy, oay, oby, ocy, ooz, oaz, obz, ocz;
     for (let x = 0; x < sx; x++) {
-      const oox = oo + x * txo;
-      const oax = oa + x * txa;
-      const obx = ob + x * txb;
-      const ocx = oc + x * txc;
+      oox = oo + x * txo;
+      oax = oa + x * txa;
+      obx = ob + x * txb;
+      ocx = oc + x * txc;
       for (let y = 0; y < sy; y++) {
-        const ooy = oox + y * tyo;
-        const oay = oax + y * tya;
-        const oby = obx + y * tyb;
-        const ocy = ocx + y * tyc;
+        ooy = oox + y * tyo;
+        oay = oax + y * tya;
+        oby = obx + y * tyb;
+        ocy = ocx + y * tyc;
         for (let z = 0; z < sz; z++) {
-          const ooz = ooy + z * tzo;
-          const oaz = oay + z * tza;
-          const obz = oby + z * tzb;
-          const ocz = ocy + z * tzc;
+          ooz = ooy + z * tzo;
+          oaz = oay + z * tza;
+          obz = oby + z * tzb;
+          ocz = ocy + z * tzc;
           for (let w = 0; w < sw; w++) {
             odata[ooz + w * two] = fn(
               adata[oaz + w * twa],
@@ -164,13 +165,18 @@ const defOpTTT = (fn, dispatch = 1) => {
     }
     return out;
   };
-  return [
-    top(dispatch, void 0, f1, f2, f3, f4),
-    f1,
-    f2,
-    f3,
-    f4
-  ];
+  const impls = [, f1, f2, f3, f4];
+  const wrapper = (out, a, b, c) => {
+    const { a: $a1, b: $b } = broadcast(a, b);
+    const { shape, a: $a2, b: $c } = broadcast($a1, c);
+    if (out) {
+      ensureShape(out, shape);
+    } else {
+      out = tensor(a.type, shape, { storage: a.storage });
+    }
+    return impls[shape.length](out, $a2, $b, $c);
+  };
+  return wrapper;
 };
 export {
   defOpTTT

package/diagonal.d.ts

@@ -0,0 +1,16 @@
+import type { ITensor } from "./api.js";
+import { Tensor1 } from "./tensor.js";
+/**
+ * Returns a 1D tensor view of the nD diagonal of the given tensor.
+ *
+ * @remarks
+ * For 1D tensors this will merely by a shallow copy.
+ */
+export declare const diagonal: <T>(a: ITensor<T>) => Tensor1<T>;
+/**
+ * Computes the trace of given tensor, i.e. the component sum of `diagonal(a)`.
+ *
+ * @param a
+ */
+export declare const trace: (a: ITensor) => number;
+//# sourceMappingURL=diagonal.d.ts.map

package/diagonal.js

@@ -0,0 +1,18 @@
+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 trace = (a) => sum(diagonal(a));
+export {
+  diagonal,
+  trace
+};

package/div.d.ts

@@ -1,42 +1,11 @@
 /**
  * Componentwise nD tensor division. Writes result to `out`. If `out` is null,
- * mutates `a`. Multi-method.
+ * 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 n - scalar
+ * @param b - input tensor
  */
-export declare const div: import("./api.js").MultiTensorOpTT<number>;
-/**
- * Same as {@link div} for 1D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param n - scalar
- */
-export declare const div1: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
-/**
- * Same as {@link div} for 2D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param n - scalar
- */
-export declare const div2: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
-/**
- * Same as {@link div} for 3D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param n - scalar
- */
-export declare const div3: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
-/**
- * Same as {@link div} for 4D tensors.
- *
- * @param out - output tensor
- * @param a - input tensor
- * @param n - scalar
- */
-export declare const div4: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+export declare const div: import("./api.js").TensorOpTT<number>;
 //# sourceMappingURL=div.d.ts.map

package/div.js

@@ -1,15 +1,6 @@
 import { $div } from "@thi.ng/vectors/ops";
 import { defOpTT } from "./defoptt.js";
-const [a, b, c, d, e] = defOpTT($div);
-const div = a;
-const div1 = b;
-const div2 = c;
-const div3 = d;
-const div4 = e;
+const div = defOpTT($div);
 export {
-  div,
-  div1,
-  div2,
-  div3,
-  div4
+  div
 };