@thi.ng/tensors 0.1.0 → 0.2.0

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/defopbtt.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,153 @@
+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
+};

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 { 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: Fn2<B, A, B>, init: Fn0<B>) => import("./api.js").MultiTensorOpImpl<TensorOpRT<A, B>>;
 //# sourceMappingURL=defoprt.d.ts.map

package/defoprt.js

@@ -21,8 +21,9 @@ 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]);
       }
@@ -37,10 +38,11 @@ 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]);
         }
@@ -56,12 +58,13 @@ 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]);
           }
@@ -70,7 +73,14 @@ const defOpRT = (rfn, init) => {
     }
     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,13 @@
 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 { 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 with broadcasting rules (see
+ * {@link broadcast} for details).
  *
  * @param rfn
  * @param init
  */
-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: Fn3<B, A, A, B>, init: Fn0<B>) => TensorOpRTT<A, B>;
 //# sourceMappingURL=defoprtt.d.ts.map

package/defoprtt.js

@@ -1,4 +1,4 @@
-import { top } from "./top.js";
+import { broadcast } from "./broadcast.js";
 const defOpRTT = (rfn, init) => {
   const f1 = (a, b) => {
     const {
@@ -31,9 +31,10 @@ 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]);
       }
@@ -53,12 +54,13 @@ 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]);
         }
@@ -79,15 +81,16 @@ 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,
@@ -100,13 +103,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 = (a, b) => {
+    const { shape, a: $a, b: $b } = broadcast(a, b);
+    return impls[shape.length]($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