@thi.ng/tensors 0.1.0

package/log.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.log` of given nD tensor and writes result to
+ * `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link log} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log_1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link log} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log_2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link log} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log_3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link log} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log_4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=log.d.ts.map

package/log.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.log);
+const log = a;
+const log_1 = b;
+const log_2 = c;
+const log_3 = d;
+const log_4 = e;
+export {
+  log,
+  log_1,
+  log_2,
+  log_3,
+  log_4
+};

package/log2.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.log2` of given nD tensor and writes result to
+ * `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log2: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link log2} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log2_1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link log2} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log2_2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link log2} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log2_3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link log2} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const log2_4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=log2.d.ts.map

package/log2.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.log2);
+const log2 = a;
+const log2_1 = b;
+const log2_2 = c;
+const log2_3 = d;
+const log2_4 = e;
+export {
+  log2,
+  log2_1,
+  log2_2,
+  log2_3,
+  log2_4
+};

package/mag.d.ts

@@ -0,0 +1,3 @@
+import type { ITensor } from "./api.js";
+export declare const mag: (a: ITensor) => number;
+//# sourceMappingURL=mag.d.ts.map

package/mag.js

@@ -0,0 +1,5 @@
+import { magSq } from "./magsq.js";
+const mag = (a) => Math.sqrt(magSq(a));
+export {
+  mag
+};

package/magsq.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Squared magnitude of given nD tensor. Multi-method.
+ *
+ * @param a - input tensor
+ */
+export declare const magSq: import("./api.js").MultiTensorOpRT<number, number>;
+/**
+ * Squared magnitude of given 1D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const magSq1: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor1<number>>;
+/**
+ * Squared magnitude of given 2D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const magSq2: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor2<number>>;
+/**
+ * Squared magnitude of given 3D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const magSq3: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor3<number>>;
+/**
+ * Squared magnitude of given 4D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const magSq4: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=magsq.d.ts.map

package/magsq.js

@@ -0,0 +1,17 @@
+import { defOpRT } from "./defoprt.js";
+const [a, b, c, d, e] = defOpRT(
+  (acc, x) => acc + x * x,
+  () => 0
+);
+const magSq = a;
+const magSq1 = b;
+const magSq2 = c;
+const magSq3 = d;
+const magSq4 = e;
+export {
+  magSq,
+  magSq1,
+  magSq2,
+  magSq3,
+  magSq4
+};

package/max.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.max` of given nD tensors and writes result to
+ * `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const max: import("./api.js").MultiTensorOpTT<number>;
+/**
+ * Same as {@link max} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const max1: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link max} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const max2: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link max} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const max3: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link max} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const max4: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=max.d.ts.map

package/max.js

@@ -0,0 +1,14 @@
+import { defOpTT } from "./defoptt.js";
+const [a, b, c, d, e] = defOpTT(Math.max);
+const max = a;
+const max1 = b;
+const max2 = c;
+const max3 = d;
+const max4 = e;
+export {
+  max,
+  max1,
+  max2,
+  max3,
+  max4
+};

package/maxn.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Componentwise computes `Math.max` of given nD tensor and uniform scalar `n`.
+ * Writes result to `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const maxN: import("./api.js").MultiTensorOpTN<number>;
+/**
+ * Same as {@link maxN} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const maxN1: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link maxN} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const maxN2: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link maxN} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const maxN3: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link maxN} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const maxN4: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=maxn.d.ts.map

package/maxn.js

@@ -0,0 +1,14 @@
+import { defOpTN } from "./defoptn.js";
+const [a, b, c, d, e] = defOpTN(Math.max);
+const maxN = a;
+const maxN1 = b;
+const maxN2 = c;
+const maxN3 = d;
+const maxN4 = e;
+export {
+  maxN,
+  maxN1,
+  maxN2,
+  maxN3,
+  maxN4
+};

package/min.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.min` of given nD tensors and writes result to
+ * `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const min: import("./api.js").MultiTensorOpTT<number>;
+/**
+ * Same as {@link min} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const min1: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link min} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const min2: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link min} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const min3: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link min} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const min4: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=min.d.ts.map

package/min.js

@@ -0,0 +1,14 @@
+import { defOpTT } from "./defoptt.js";
+const [a, b, c, d, e] = defOpTT(Math.min);
+const min = a;
+const min1 = b;
+const min2 = c;
+const min3 = d;
+const min4 = e;
+export {
+  min,
+  min1,
+  min2,
+  min3,
+  min4
+};

package/minn.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Componentwise computes `Math.min` of given nD tensor and uniform scalar `n`.
+ * Writes result to `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const minN: import("./api.js").MultiTensorOpTN<number>;
+/**
+ * Same as {@link minN} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const minN1: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link minN} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const minN2: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link minN} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const minN3: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link minN} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const minN4: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=minn.d.ts.map

package/minn.js

@@ -0,0 +1,14 @@
+import { defOpTN } from "./defoptn.js";
+const [a, b, c, d, e] = defOpTN(Math.min);
+const minN = a;
+const minN1 = b;
+const minN2 = c;
+const minN3 = d;
+const minN4 = e;
+export {
+  minN,
+  minN1,
+  minN2,
+  minN3,
+  minN4
+};

package/mul.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Componentwise nD tensor multiplication. Writes result to `out`. If `out` is
+ * null, mutates `a`. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mul: import("./api.js").MultiTensorOpTT<number>;
+/**
+ * Same as {@link mul} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mul1: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link mul} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mul2: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link mul} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mul3: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link mul} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mul4: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=mul.d.ts.map

package/mul.js

@@ -0,0 +1,15 @@
+import { $mul } from "@thi.ng/vectors/ops";
+import { defOpTT } from "./defoptt.js";
+const [a, b, c, d, e] = defOpTT($mul);
+const mul = a;
+const mul1 = b;
+const mul2 = c;
+const mul3 = d;
+const mul4 = e;
+export {
+  mul,
+  mul1,
+  mul2,
+  mul3,
+  mul4
+};

package/mulm.d.ts

@@ -0,0 +1,12 @@
+import { type Tensor2 } from "./tensor.js";
+/**
+ * Matrix-matrix multiplication between matrix `a` (MxN) and matrix `b` (PxQ).
+ * If `out` is given, it MUST be a MxQ tensor. If null then a new will be
+ * created, using `a`'s storage impl.
+ *
+ * @param out
+ * @param a
+ * @param b
+ */
+export declare const mulM: (out: Tensor2 | null, a: Tensor2, b: Tensor2) => Tensor2<number>;
+//# sourceMappingURL=mulm.d.ts.map

package/mulm.js

@@ -0,0 +1,49 @@
+import { assert } from "@thi.ng/errors/assert";
+import { tensor } from "./tensor.js";
+const mulM = (out, a, b) => {
+  const {
+    data: adata,
+    offset: offa,
+    shape: [rowa, cola],
+    stride: [txa, tya]
+  } = a;
+  const {
+    data: bdata,
+    offset: offb,
+    shape: [rowb, colb],
+    stride: [txb, tyb]
+  } = b;
+  assert(
+    cola === rowb,
+    `incompatible matrix shapes, matrix b requires ${cola} rows`
+  );
+  if (out == null) {
+    out = tensor(a.type, [rowa, colb], { storage: a.storage });
+  }
+  const {
+    data: odata,
+    offset: offo,
+    shape: [rowo, colo],
+    stride: [txo, tyo]
+  } = out;
+  assert(
+    rowo === rowa && colo === colb,
+    `incompatible output matrix shape, expected: [${rowa},${colb}]`
+  );
+  for (let i = 0; i < rowa; i++) {
+    const io = offo + i * txo;
+    const ia = offa + i * txa;
+    for (let j = 0; j < colb; j++) {
+      const ib = offb + j * tyb;
+      let dot = 0;
+      for (let j2 = 0; j2 < cola; j2++) {
+        dot += adata[ia + j2 * tya] * bdata[ib + j2 * txb];
+      }
+      odata[io + j * tyo] = dot;
+    }
+  }
+  return out;
+};
+export {
+  mulM
+};

package/muln.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Componentwise nD tensor multiplication with uniform scalar `n`. Writes result
+ * to `out`. If `out` is null, mutates `a`. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mulN: import("./api.js").MultiTensorOpTN<number>;
+/**
+ * Same as {@link mulN} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mulN1: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link mulN} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mulN2: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link mulN} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mulN3: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link mulN} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const mulN4: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=muln.d.ts.map

package/muln.js

@@ -0,0 +1,15 @@
+import { $mul } from "@thi.ng/vectors/ops";
+import { defOpTN } from "./defoptn.js";
+const [a, b, c, d, e] = defOpTN($mul);
+const mulN = a;
+const mulN1 = b;
+const mulN2 = c;
+const mulN3 = d;
+const mulN4 = e;
+export {
+  mulN,
+  mulN1,
+  mulN2,
+  mulN3,
+  mulN4
+};

package/mulv.d.ts

@@ -0,0 +1,11 @@
+import { type Tensor1, type Tensor2 } from "./tensor.js";
+/**
+ * Matrix-vector multiplication. If `out` is null, a new 1D tensor will be
+ * created, using vector `b`'s storage impl.
+ *
+ * @param out
+ * @param a
+ * @param b
+ */
+export declare const mulV: (out: Tensor1 | null, a: Tensor2, b: Tensor1) => Tensor1<number>;
+//# sourceMappingURL=mulv.d.ts.map

package/mulv.js

@@ -0,0 +1,39 @@
+import { illegalShape } from "./errors.js";
+import { tensor } from "./tensor.js";
+const mulV = (out, a, b) => {
+  const {
+    data: adata,
+    offset: offa,
+    shape: [rowa, cola],
+    stride: [txa, tya]
+  } = a;
+  const {
+    data: bdata,
+    offset: offb,
+    shape: [rowb],
+    stride: [txb]
+  } = b;
+  if (cola !== rowb) illegalShape(b.shape);
+  if (out == null) {
+    out = tensor(b.type, [rowa], { storage: b.storage });
+  }
+  const {
+    data: odata,
+    offset: offo,
+    shape: [rowo],
+    stride: [txo]
+  } = out;
+  if (rowo !== rowa) illegalShape(out.shape);
+  for (let i = 0; i < rowa; i++) {
+    const ia = offa + i * txa;
+    let sum = 0;
+    for (let j = 0; j < cola; j++) {
+      sum += adata[ia + j * tya] * bdata[offb + j * txb];
+    }
+    odata[offo + i * txo] = sum;
+  }
+  return out;
+};
+export {
+  mulV
+};

package/normalize.d.ts

@@ -0,0 +1,3 @@
+import type { ITensor } from "./api.js";
+export declare const normalize: (out: ITensor | null, a: ITensor, n?: number) => ITensor<any>;
+//# sourceMappingURL=normalize.d.ts.map

package/normalize.js

@@ -0,0 +1,11 @@
+import { magSq } from "./magsq.js";
+import { mulN } from "./muln.js";
+import { set } from "./set.js";
+const normalize = (out, a, n = 1) => {
+  !out && (out = a);
+  const m = Math.sqrt(magSq(a));
+  return m >= 1e-6 ? mulN(out || a, a, n / m) : out !== a ? set(out, a) : out;
+};
+export {
+  normalize
+};