@thi.ng/tensors 0.1.0 → 0.3.0

package/tanh.d.ts

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

package/tanh.js

@@ -1,14 +1,5 @@
 import { defOpT } from "./defopt.js";
-const [a, b, c, d, e] = defOpT(Math.tanh);
-const tanh = a;
-const tanh1 = b;
-const tanh2 = c;
-const tanh3 = d;
-const tanh4 = e;
+const tanh = defOpT(Math.tanh);
 export {
-  tanh,
-  tanh1,
-  tanh2,
-  tanh3,
-  tanh4
+  tanh
 };

package/tensor.d.ts

@@ -14,11 +14,13 @@ export declare abstract class ATensor<T = number> implements ITensor<T> {
     get orderedShape(): number[];
     get orderedStride(): number[];
     abstract [Symbol.iterator](): IterableIterator<T>;
+    broadcast<S extends Shape>(shape: S, stride: S): ShapeTensor<S, T>;
     copy(): typeof this;
     empty(storage?: ITensorStorage<T>): typeof this;
     equiv(o: any): boolean;
     eqDelta(o: ITensor<T>, eps?: number): boolean;
     abstract index(pos: NumericArray): number;
+    position(index: number): any[];
     abstract get(pos: NumericArray): T;
     abstract set(pos: NumericArray, v: T): this;
     hi(pos: NumericArray): this;
@@ -42,6 +44,7 @@ export declare class Tensor1<T = number> extends ATensor<T> {
     get order(): number[];
     get length(): number;
     index([x]: NumericArray): number;
+    position(index: number): number[];
     get([x]: NumericArray): T;
     set([x]: NumericArray, v: T): this;
     pick([x]: NumericArray): Tensor1<T>;
@@ -122,6 +125,8 @@ export declare function tensorFromArray<T extends NumType, N extends Nested<numb
  * @param opts
  */
 export declare function tensorFromArray<N extends Nested<string>>(data: N, opts?: TensorFromArrayOpts<"str", string>): NestedTensor<N, string>;
-export declare const shapeToStride: (shape: NumericArray) => any[];
+export declare const zeroes: <S extends Shape>(shape: S, type?: NumType, storage?: ITensorStorage<number>) => ShapeTensor<S, number>;
+export declare const ones: <S extends Shape>(shape: S, type?: NumType, storage?: ITensorStorage<number>) => ShapeTensor<S, number>;
+export declare const shapeToStride: (shape: number[]) => any[];
 export declare const strideOrder: (strides: number[]) => number[];
 //# sourceMappingURL=tensor.d.ts.map

package/tensor.js

@@ -29,6 +29,16 @@ class ATensor {
   get orderedStride() {
     return swizzle(this.order)(this.stride);
   }
+  broadcast(shape, stride) {
+    return new TENSOR_IMPLS[shape.length](
+      this.type,
+      this.storage,
+      this.data,
+      shape,
+      stride,
+      this.offset
+    );
+  }
   copy() {
     return new this.constructor(
       this.type,
@@ -54,6 +64,16 @@ class ATensor {
   eqDelta(o, eps = 1e-6) {
     return this === o || equiv(this.shape, o.shape) && _eqDelta([...this], [...o], this.length, eps);
   }
+  position(index) {
+    const { order, stride } = this;
+    index -= this.offset;
+    const idx = order.map((o) => {
+      const i = ~~(index / stride[o]);
+      index -= i * stride[o];
+      return i;
+    });
+    return swizzle(order)(idx);
+  }
   hi(pos) {
     return new this.constructor(
       this.type,
@@ -139,11 +159,11 @@ class Tensor1 extends ATensor {
   *[Symbol.iterator]() {
     let {
       data,
-      length,
+      shape: [sx],
       stride: [tx],
       offset
     } = this;
-    for (; length-- > 0; offset += tx) yield data[offset];
+    for (; sx-- > 0; offset += tx) yield data[offset];
   }
   get dim() {
     return 1;
@@ -157,6 +177,9 @@ class Tensor1 extends ATensor {
   index([x]) {
     return this.offset + x * this.stride[0];
   }
+  position(index) {
+    return [~~((index - this.offset) / this.stride[0])];
+  }
   get([x]) {
     return this.data[this.offset + x * this.stride[0]];
   }
@@ -211,8 +234,9 @@ class Tensor2 extends ATensor {
       shape: [sx, sy],
       stride: [tx, ty]
     } = this;
-    for (let ox = this.offset, x = 0; x < sx; x++, ox += tx) {
-      for (let y = 0; y < sy; y++) {
+    let ox, x, y;
+    for (ox = this.offset, x = 0; x < sx; x++, ox += tx) {
+      for (y = 0; y < sy; y++) {
         yield data[ox + y * ty];
       }
     }
@@ -246,8 +270,9 @@ class Tensor2 extends ATensor {
       stride: [tx, ty]
     } = this;
     const n = min(this.length, newLength);
-    for (let ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
-      for (let y = 0; y < sy && i < n; y++, i++) {
+    let ox, x, y, i;
+    for (ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
+      for (y = 0; y < sy && i < n; y++, i++) {
         newData[i] = data[ox + y * ty];
       }
     }
@@ -273,9 +298,10 @@ class Tensor3 extends ATensor {
       shape: [sx, sy, sz],
       stride: [tx, ty, tz]
     } = this;
-    for (let ox = this.offset, x = 0; x < sx; x++, ox += tx) {
-      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
-        for (let z = 0; z < sz; z++) {
+    let ox, oy, x, y, z;
+    for (ox = this.offset, x = 0; x < sx; x++, ox += tx) {
+      for (oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (z = 0; z < sz; z++) {
           yield data[oy + z * tz];
         }
       }
@@ -307,9 +333,10 @@ class Tensor3 extends ATensor {
       stride: [tx, ty, tz]
     } = this;
     const n = min(this.length, newLength);
-    for (let ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
-      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
-        for (let z = 0; z < sz && i < n; z++, i++) {
+    let ox, oy, x, y, z, i;
+    for (ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
+      for (oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (z = 0; z < sz && i < n; z++, i++) {
           newData[i] = data[oy + z * tz];
         }
       }
@@ -337,10 +364,11 @@ class Tensor4 extends ATensor {
       stride: [tx, ty, tz, tw],
       offset
     } = this;
-    for (let ox = offset, x = 0; x < sx; x++, ox += tx) {
-      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
-        for (let oz = oy, z = 0; z < sz; z++, oz += tz) {
-          for (let w = 0; w < sw; w++) {
+    let ox, oy, oz, x, y, z, w;
+    for (ox = offset, x = 0; x < sx; x++, ox += tx) {
+      for (oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (oz = oy, z = 0; z < sz; z++, oz += tz) {
+          for (w = 0; w < sw; w++) {
             yield data[oz + w * tw];
           }
         }
@@ -373,10 +401,11 @@ class Tensor4 extends ATensor {
       stride: [tx, ty, tz, tw]
     } = this;
     const n = min(this.length, newLength);
-    for (let ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
-      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
-        for (let oz = oy, z = 0; z < sz; z++, oz += tz) {
-          for (let w = 0; w < sw && i < n; w++, i++) {
+    let ox, oy, oz, x, y, z, w, i;
+    for (ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
+      for (oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (oz = oy, z = 0; z < sz; z++, oz += tz) {
+          for (w = 0; w < sw && i < n; w++, i++) {
             newData[i] = data[oz + w * tw];
           }
         }
@@ -445,6 +474,12 @@ function tensorFromArray(data, opts) {
     storage: opts?.storage
   });
 }
+const zeroes = (shape, type = "num", storage) => tensor(type, shape, { storage });
+const ones = (shape, type = "num", storage) => {
+  const res = tensor(type, shape, { storage });
+  res.data.fill(1);
+  return res;
+};
 const shapeToStride = (shape) => {
   const n = shape.length;
   const stride = new Array(n);
@@ -510,8 +545,10 @@ export {
   Tensor2,
   Tensor3,
   Tensor4,
+  ones,
   shapeToStride,
   strideOrder,
   tensor,
-  tensorFromArray
+  tensorFromArray,
+  zeroes
 };

package/top.d.ts

@@ -1,4 +1,5 @@
 import type { Maybe } from "@thi.ng/api";
+import type { MultiTensorOpImpl } from "./api.js";
 /**
  * Specialized / optimized version of
  * [`thi.ng/defmulti`](https://thi.ng/defmulti) for tensor operations. Uses
@@ -7,10 +8,5 @@ import type { Maybe } from "@thi.ng/api";
  *
  * @param dispatch - arg index (default: 1)
  */
-export declare const top: <T extends Function>(dispatch?: number, fallback?: T, ...optimized: Maybe<T>[]) => {
-    (...args: any[]): any;
-    add(dim: number, fn: T): T;
-    default(fn: T): T;
-    impl(dim?: number): Maybe<T>;
-};
+export declare const top: <T extends Function>(dispatch?: number, fallback?: T, ...optimized: Maybe<T>[]) => MultiTensorOpImpl<T>;
 //# sourceMappingURL=top.d.ts.map