@thi.ng/tensors 0.1.0

package/defopt.d.ts

@@ -0,0 +1,13 @@
+import type { Fn } from "@thi.ng/api";
+import type { MultiTensorOpT, TensorOpT } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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]`.
+ *
+ * @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>>];
+//# sourceMappingURL=defopt.d.ts.map

package/defopt.js

@@ -0,0 +1,109 @@
+import { top } from "./top.js";
+const defOpT = (fn, dispatch = 1) => {
+  const f1 = (out, a) => {
+    !out && (out = a);
+    const {
+      data: odata,
+      offset: oo,
+      stride: [txo]
+    } = out;
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx],
+      stride: [txa]
+    } = a;
+    for (let x = 0; x < sx; x++) {
+      odata[oo + x * txo] = fn(adata[oa + x * txa]);
+    }
+    return out;
+  };
+  const f2 = (out, a) => {
+    !out && (out = a);
+    const {
+      data: odata,
+      offset: oo,
+      stride: [txo, tyo]
+    } = out;
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx, sy],
+      stride: [txa, tya]
+    } = a;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        odata[oox + y * tyo] = fn(adata[oax + y * tya]);
+      }
+    }
+    return out;
+  };
+  const f3 = (out, a) => {
+    !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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        const ooy = oox + y * tyo;
+        const oay = oax + y * tya;
+        for (let z = 0; z < sz; z++) {
+          odata[ooy + z * tzo] = fn(adata[oay + z * tza]);
+        }
+      }
+    }
+    return out;
+  };
+  const f4 = (out, a) => {
+    !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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        const ooy = oox + y * tyo;
+        const oay = oax + y * tya;
+        for (let z = 0; z < sz; z++) {
+          const ooz = ooy + z * tzo;
+          const oaz = oay + z * tza;
+          for (let w = 0; w < sw; w++) {
+            odata[ooz + w * two] = fn(adata[oaz + w * twa]);
+          }
+        }
+      }
+    }
+    return out;
+  };
+  return [
+    top(dispatch, void 0, f1, f2, f3, f4),
+    f1,
+    f2,
+    f3,
+    f4
+  ];
+};
+export {
+  defOpT
+};

package/defoptn.d.ts

@@ -0,0 +1,13 @@
+import type { FnU2 } from "@thi.ng/api";
+import type { MultiTensorOpTN, TensorOpTN } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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]`.
+ *
+ * @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>>];
+//# sourceMappingURL=defoptn.d.ts.map

package/defoptn.js

@@ -0,0 +1,109 @@
+import { top } from "./top.js";
+const defOpTN = (fn, dispatch = 1) => {
+  const f1 = (out, a, n) => {
+    !out && (out = a);
+    const {
+      data: odata,
+      offset: oo,
+      stride: [txo]
+    } = out;
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx],
+      stride: [txa]
+    } = a;
+    for (let x = 0; x < sx; x++) {
+      odata[oo + x * txo] = fn(adata[oa + x * txa], n);
+    }
+    return out;
+  };
+  const f2 = (out, a, n) => {
+    !out && (out = a);
+    const {
+      data: odata,
+      offset: oo,
+      stride: [txo, tyo]
+    } = out;
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx, sy],
+      stride: [txa, tya]
+    } = a;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        odata[oox + y * tyo] = fn(adata[oax + y * tya], n);
+      }
+    }
+    return out;
+  };
+  const f3 = (out, a, n) => {
+    !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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        const ooy = oox + y * tyo;
+        const oay = oax + y * tya;
+        for (let z = 0; z < sz; z++) {
+          odata[ooy + z * tzo] = fn(adata[oay + z * tza], n);
+        }
+      }
+    }
+    return out;
+  };
+  const f4 = (out, a, n) => {
+    !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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        const ooy = oox + y * tyo;
+        const oay = oax + y * tya;
+        for (let z = 0; z < sz; z++) {
+          const ooz = ooy + z * tzo;
+          const oaz = oay + z * tza;
+          for (let w = 0; w < sw; w++) {
+            odata[ooz + w * two] = fn(adata[oaz + w * twa], n);
+          }
+        }
+      }
+    }
+    return out;
+  };
+  return [
+    top(dispatch, void 0, f1, f2, f3, f4),
+    f1,
+    f2,
+    f3,
+    f4
+  ];
+};
+export {
+  defOpTN
+};

package/defoptnn.d.ts

@@ -0,0 +1,13 @@
+import type { FnU3 } from "@thi.ng/api";
+import type { MultiTensorOpTNN, TensorOpTNN } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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]`.
+ *
+ * @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>>];
+//# sourceMappingURL=defoptnn.d.ts.map

package/defoptnn.js

@@ -0,0 +1,109 @@
+import { top } from "./top.js";
+const defOpTNN = (fn, dispatch = 1) => {
+  const f1 = (out, a, n, m) => {
+    !out && (out = a);
+    const {
+      data: odata,
+      offset: oo,
+      stride: [txo]
+    } = out;
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx],
+      stride: [txa]
+    } = a;
+    for (let x = 0; x < sx; x++) {
+      odata[oo + x * txo] = fn(adata[oa + x * txa], n, m);
+    }
+    return out;
+  };
+  const f2 = (out, a, n, m) => {
+    !out && (out = a);
+    const {
+      data: odata,
+      offset: oo,
+      stride: [txo, tyo]
+    } = out;
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx, sy],
+      stride: [txa, tya]
+    } = a;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        odata[oox + y * tyo] = fn(adata[oax + y * tya], n, m);
+      }
+    }
+    return out;
+  };
+  const f3 = (out, a, n, m) => {
+    !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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        const ooy = oox + y * tyo;
+        const oay = oax + y * tya;
+        for (let z = 0; z < sz; z++) {
+          odata[ooy + z * tzo] = fn(adata[oay + z * tza], n, m);
+        }
+      }
+    }
+    return out;
+  };
+  const f4 = (out, a, n, m) => {
+    !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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      for (let y = 0; y < sy; y++) {
+        const ooy = oox + y * tyo;
+        const oay = oax + y * tya;
+        for (let z = 0; z < sz; z++) {
+          const ooz = ooy + z * tzo;
+          const oaz = oay + z * tza;
+          for (let w = 0; w < sw; w++) {
+            odata[ooz + w * two] = fn(adata[oaz + w * twa], n, m);
+          }
+        }
+      }
+    }
+    return out;
+  };
+  return [
+    top(dispatch, void 0, f1, f2, f3, f4),
+    f1,
+    f2,
+    f3,
+    f4
+  ];
+};
+export {
+  defOpTNN
+};

package/defoptt.d.ts

@@ -0,0 +1,13 @@
+import type { FnU2 } from "@thi.ng/api";
+import type { MultiTensorOpTT, TensorOpTT } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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]`.
+ *
+ * @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>>];
+//# sourceMappingURL=defoptt.d.ts.map

package/defoptt.js

@@ -0,0 +1,144 @@
+import { top } from "./top.js";
+const defOpTT = (fn, dispatch = 1) => {
+  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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      const 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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      const 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;
+        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;
+    for (let x = 0; x < sx; x++) {
+      const oox = oo + x * txo;
+      const oax = oa + x * txa;
+      const 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;
+        for (let z = 0; z < sz; z++) {
+          const ooz = ooy + z * tzo;
+          const oaz = oay + z * tza;
+          const 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;
+  };
+  return [
+    top(dispatch, void 0, f1, f2, f3, f4),
+    f1,
+    f2,
+    f3,
+    f4
+  ];
+};
+export {
+  defOpTT
+};

package/defopttt.d.ts

@@ -0,0 +1,13 @@
+import type { FnU3 } from "@thi.ng/api";
+import type { MultiTensorOpTTT, TensorOpTTT } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.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]`.
+ *
+ * @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>>];
+//# sourceMappingURL=defopttt.d.ts.map