@thi.ng/tensors 0.8.12 → 0.9.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-08-04T09:13:01Z
+- **Last updated**: 2025-08-16T18:12:02Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,15 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [0.9.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/tensors@0.9.0) (2025-08-16)
+
+#### 🚀 Features
+
+- add 0-dim (wrapped scalar) tensor support ([cd22ee6](https://github.com/thi-ng/umbrella/commit/cd22ee6))
+  - add `Tensor0`, `Shape0`
+  - update HOF tensor op generators
+  - add/update tests
+
 ## [0.8.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/tensors@0.8.0) (2025-07-10)
 
 #### 🚀 Features

package/README.md

@@ -31,12 +31,11 @@
 
 ## About
 
-1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage.
+0D/1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage.
 
 > [!NOTE]
-> This package contains code originally written in 2017/18 and, at the moment, is
-> undergoing heavy refactoring to be stylistically more aligned with other thi.ng
-> packages — use with caution!
+> This package contains code originally written in 2017/18 and has been
+> refactored to be stylistically more aligned with other thi.ng packages.
 
 ## Built-in tensor operations
 
@@ -251,7 +250,7 @@ For Node.js REPL:
 const ten = await import("@thi.ng/tensors");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 9.75 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 10.06 KB
 
 ## Dependencies
 

package/api.d.ts

@@ -1,17 +1,18 @@
 import type { Type as $Type, ICopy, IEqualsDelta, IEquiv, ILength, IRelease, Maybe, NumericArray } from "@thi.ng/api";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { Tensor0, Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
 export interface TensorData<T = number> extends Iterable<T>, ILength {
     [id: number]: T;
     fill(x: T, start?: number, end?: number): TensorData<T>;
 }
 export type Type = $Type | "num" | "str";
 export type NumType = $Type | "num";
+export type Shape0 = [];
 export type Shape1 = [number];
 export type Shape2 = [number, number];
 export type Shape3 = [number, number, number];
 export type Shape4 = [number, number, number, number];
-export type Shape = Shape1 | Shape2 | Shape3 | Shape4;
-export type ShapeTensor<S extends Shape, T> = S extends Shape4 ? Tensor4<T> : S extends Shape3 ? Tensor3<T> : S extends Shape2 ? Tensor2<T> : Tensor1<T>;
+export type Shape = Shape0 | Shape1 | Shape2 | Shape3 | Shape4;
+export type ShapeTensor<S extends Shape, T> = S extends Shape4 ? Tensor4<T> : S extends Shape3 ? Tensor3<T> : S extends Shape2 ? Tensor2<T> : S extends Shape1 ? Tensor1<T> : Tensor0<T>;
 export type Nested<T> = T[] | T[][] | T[][][] | T[][][][];
 export type NestedTensor<N extends Nested<T>, T> = N extends T[][][][] ? Tensor4<T> : N extends T[][][] ? Tensor3<T> : N extends T[][] ? Tensor2<T> : Tensor1<T>;
 export interface TypeMap {
@@ -108,6 +109,10 @@ export interface ITensor<T = number> extends ICopy<ITensor<T>>, IEquiv, IEqualsD
      * Computes linear array index from given grid position. Reverse-op of
      * {@link ITensor.position}.
      *
+     * @remarks
+     * The given `pos` is assumed to be integral and valid. No bounds checking
+     * performed.
+     *
      * @param pos
      */
     index(pos: NumericArray): number;
@@ -116,6 +121,8 @@ export interface ITensor<T = number> extends ICopy<ITensor<T>>, IEquiv, IEqualsD
      * {@link ITensor.index}.
      *
      * @remarks
+     * The given `index` is assumed to be valid. No bounds checking performed.
+     *
      * **CAUTION:** Currently only supports tensors with positive strides,
      * otherwise will yield incorrect results! Tensors with negative strides
      * (aka flipped axes in reverse order) need to be first packed via
@@ -435,108 +442,182 @@ export interface ITensorStorage<T> {
 }
 export type StorageRegistry = Record<Type, ITensorStorage<any>>;
 export interface TensorOpT<T = number> {
+    (out: Tensor0<T> | null, a: Tensor0<T>): Tensor0<T>;
     (out: Tensor1<T> | null, a: Tensor1<T>): Tensor1<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>): Tensor4<T>;
 }
 export interface TensorOpTT<T = number> {
+    (out: Tensor0<T> | null, a: Tensor0<T>, b: Tensor0<T>): Tensor0<T>;
+    (out: Tensor1<T> | null, a: Tensor0<T>, b: Tensor1<T>): Tensor1<T>;
+    (out: Tensor2<T> | null, a: Tensor0<T>, b: Tensor2<T>): Tensor2<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor4<T>): Tensor4<T>;
+    (out: Tensor1<T> | null, a: Tensor1<T>, b: Tensor0<T>): Tensor1<T>;
     (out: Tensor1<T> | null, a: Tensor1<T>, b: Tensor1<T>): Tensor1<T>;
     (out: Tensor2<T> | null, a: Tensor1<T>, b: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor4<T>): Tensor4<T>;
+    (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor0<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor1<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor0<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor1<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor2<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor4<T>): Tensor4<T>;
 }
 export interface TensorOpTTT<T = number> {
+    (out: Tensor0<T> | null, a: Tensor0<T>, b: Tensor0<T>, c: Tensor0<T>): Tensor0<T>;
+    (out: Tensor1<T> | null, a: Tensor0<T>, b: Tensor0<T>, c: Tensor1<T>): Tensor1<T>;
+    (out: Tensor2<T> | null, a: Tensor0<T>, b: Tensor0<T>, c: Tensor2<T>): Tensor2<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor0<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor0<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor1<T> | null, a: Tensor0<T>, b: Tensor1<T>, c: Tensor0<T>): Tensor1<T>;
+    (out: Tensor1<T> | null, a: Tensor0<T>, b: Tensor1<T>, c: Tensor1<T>): Tensor1<T>;
+    (out: Tensor2<T> | null, a: Tensor0<T>, b: Tensor1<T>, c: Tensor2<T>): Tensor2<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor1<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor1<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor2<T> | null, a: Tensor0<T>, b: Tensor2<T>, c: Tensor0<T>): Tensor2<T>;
+    (out: Tensor2<T> | null, a: Tensor0<T>, b: Tensor2<T>, c: Tensor1<T>): Tensor2<T>;
+    (out: Tensor2<T> | null, a: Tensor0<T>, b: Tensor2<T>, c: Tensor2<T>): Tensor2<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor2<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor2<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor3<T>, c: Tensor0<T>): Tensor3<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor3<T>, c: Tensor1<T>): Tensor3<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor3<T>, c: Tensor2<T>): Tensor3<T>;
+    (out: Tensor3<T> | null, a: Tensor0<T>, b: Tensor3<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor3<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor4<T>, c: Tensor0<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor4<T>, c: Tensor1<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor4<T>, c: Tensor2<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor4<T>, c: Tensor3<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor0<T>, b: Tensor4<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor1<T> | null, a: Tensor1<T>, b: Tensor0<T>, c: Tensor0<T>): Tensor1<T>;
+    (out: Tensor1<T> | null, a: Tensor1<T>, b: Tensor0<T>, c: Tensor1<T>): Tensor1<T>;
+    (out: Tensor2<T> | null, a: Tensor1<T>, b: Tensor0<T>, c: Tensor2<T>): Tensor2<T>;
+    (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor0<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor0<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor1<T> | null, a: Tensor1<T>, b: Tensor1<T>, c: Tensor0<T>): Tensor1<T>;
     (out: Tensor1<T> | null, a: Tensor1<T>, b: Tensor1<T>, c: Tensor1<T>): Tensor1<T>;
     (out: Tensor2<T> | null, a: Tensor1<T>, b: Tensor1<T>, c: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor1<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor1<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor2<T> | null, a: Tensor1<T>, b: Tensor2<T>, c: Tensor0<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor1<T>, b: Tensor2<T>, c: Tensor1<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor1<T>, b: Tensor2<T>, c: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor2<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor2<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor3<T>, c: Tensor0<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor3<T>, c: Tensor1<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor3<T>, c: Tensor2<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor1<T>, b: Tensor3<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor3<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor4<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor4<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor4<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor4<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor1<T>, b: Tensor4<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor0<T>, c: Tensor0<T>): Tensor2<T>;
+    (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor0<T>, c: Tensor1<T>): Tensor2<T>;
+    (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor0<T>, c: Tensor2<T>): Tensor2<T>;
+    (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor0<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor0<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor1<T>, c: Tensor0<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor1<T>, c: Tensor1<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor1<T>, c: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor1<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor1<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor2<T>, c: Tensor0<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor2<T>, c: Tensor1<T>): Tensor2<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, b: Tensor2<T>, c: Tensor2<T>): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor2<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor2<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor3<T>, c: Tensor0<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor3<T>, c: Tensor1<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor3<T>, c: Tensor2<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor2<T>, b: Tensor3<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor3<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor4<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor4<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor4<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor4<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor2<T>, b: Tensor4<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor0<T>, c: Tensor0<T>): Tensor3<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor0<T>, c: Tensor1<T>): Tensor3<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor0<T>, c: Tensor2<T>): Tensor3<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor0<T>, c: Tensor3<T>): Tensor3<T>;
+    (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor0<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor1<T>, c: Tensor0<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor1<T>, c: Tensor1<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor1<T>, c: Tensor2<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor1<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor1<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor2<T>, c: Tensor0<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor2<T>, c: Tensor1<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor2<T>, c: Tensor2<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor2<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor2<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor3<T>, c: Tensor0<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor3<T>, c: Tensor1<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor3<T>, c: Tensor2<T>): Tensor3<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, b: Tensor3<T>, c: Tensor3<T>): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor3<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor4<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor4<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor4<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor4<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor3<T>, b: Tensor4<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor0<T>, c: Tensor0<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor0<T>, c: Tensor1<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor0<T>, c: Tensor2<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor0<T>, c: Tensor3<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor0<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor1<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor1<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor1<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor1<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor1<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor2<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor2<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor2<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor2<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor2<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor3<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor3<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor3<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor3<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor3<T>, c: Tensor4<T>): Tensor4<T>;
+    (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor4<T>, c: Tensor0<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor4<T>, c: Tensor1<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor4<T>, c: Tensor2<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor4<T>, c: Tensor3<T>): Tensor4<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, b: Tensor4<T>, c: Tensor4<T>): Tensor4<T>;
 }
 export interface TensorOpN<A = number, B = A> {
+    (out: Tensor0<B>, n: A): Tensor0<B>;
     (out: Tensor1<B>, n: A): Tensor1<B>;
     (out: Tensor2<B>, n: A): Tensor2<B>;
     (out: Tensor3<B>, n: A): Tensor3<B>;
     (out: Tensor4<B>, n: A): Tensor4<B>;
 }
 export interface TensorOpTN<T = number> {
+    (out: Tensor0<T> | null, a: Tensor0<T>, n: T): Tensor0<T>;
     (out: Tensor1<T> | null, a: Tensor1<T>, n: T): Tensor1<T>;
     (out: Tensor2<T> | null, a: Tensor2<T>, n: T): Tensor2<T>;
     (out: Tensor3<T> | null, a: Tensor3<T>, n: T): Tensor3<T>;
     (out: Tensor4<T> | null, a: Tensor4<T>, n: T): Tensor4<T>;
 }
 export interface TensorOpTNN<T = number> {
+    (out: Tensor0<T>, a: Tensor0<T>, n: T, m: T): Tensor0<T>;
     (out: Tensor1<T>, a: Tensor1<T>, n: T, m: T): Tensor1<T>;
     (out: Tensor2<T>, a: Tensor2<T>, n: T, m: T): Tensor2<T>;
     (out: Tensor3<T>, a: Tensor3<T>, n: T, m: T): Tensor3<T>;
@@ -583,7 +664,7 @@ export interface KernelSpec<T = any> {
     /**
      * Kernel shape/size
      */
-    shape: Shape;
+    shape: Exclude<Shape, Shape0>;
     /**
      * Windowed intialization. Returns initial accumulator for each new kernel
      * window.

package/broadcast.d.ts

@@ -18,7 +18,7 @@ import type { ITensor, Shape } from "./api.js";
  */
 export declare const broadcast: <T = number>(a: ITensor<T>, b: ITensor<T>) => {
     shape: Shape;
-    a: ITensor<T> | import("./tensor.js").Tensor4<T> | import("./tensor.js").Tensor3<T> | import("./tensor.js").Tensor2<T> | import("./tensor.js").Tensor1<T>;
-    b: ITensor<T> | import("./tensor.js").Tensor4<T> | import("./tensor.js").Tensor3<T> | import("./tensor.js").Tensor2<T> | import("./tensor.js").Tensor1<T>;
+    a: ITensor<T> | import("./tensor.js").Tensor4<T> | import("./tensor.js").Tensor3<T> | import("./tensor.js").Tensor2<T> | import("./tensor.js").Tensor0<T> | import("./tensor.js").Tensor1<T>;
+    b: ITensor<T> | import("./tensor.js").Tensor4<T> | import("./tensor.js").Tensor3<T> | import("./tensor.js").Tensor2<T> | import("./tensor.js").Tensor0<T> | import("./tensor.js").Tensor1<T>;
 };
 //# sourceMappingURL=broadcast.d.ts.map

package/defopn.js

@@ -1,5 +1,9 @@
 import { top } from "./top.js";
 const defOpN = (fn) => {
+  const f0 = (out, a) => {
+    out.data[out.offset] = fn(a);
+    return out;
+  };
   const f1 = (out, a) => {
     const {
       data,
@@ -61,14 +65,7 @@ const defOpN = (fn) => {
     }
     return out;
   };
-  return top(
-    0,
-    void 0,
-    f1,
-    f2,
-    f3,
-    f4
-  );
+  return top(0, f0, f1, f2, f3, f4);
 };
 export {
   defOpN

package/defoprt.js

@@ -1,6 +1,7 @@
 import { identity } from "@thi.ng/api/fn";
 import { top } from "./top.js";
 const defOpRT = (rfn, init, complete = identity) => {
+  const f0 = (a) => complete(rfn(init(), a.data, a.offset), a);
   const f1 = (a) => {
     const {
       data,
@@ -76,7 +77,7 @@ const defOpRT = (rfn, init, complete = identity) => {
   };
   return top(
     0,
-    void 0,
+    f0,
     f1,
     f2,
     f3,

package/defoprtt.js

@@ -1,6 +1,7 @@
 import { identity } from "@thi.ng/api/fn";
 import { broadcast } from "./broadcast.js";
 const defOpRTT = (rfn, init, complete = identity, useBroadcast = true) => {
+  const f0 = (a, b) => complete(rfn(init(), a.data, b.data, a.offset, b.offset), a, b);
   const f1 = (a, b) => {
     const {
       data: adata,
@@ -106,7 +107,7 @@ const defOpRTT = (rfn, init, complete = identity, useBroadcast = true) => {
     }
     return complete(res, a, b);
   };
-  const impls = [, f1, f2, f3, f4];
+  const impls = [f0, f1, f2, f3, f4];
   const wrapper = useBroadcast ? (a, b) => {
     const { shape, a: $a, b: $b } = broadcast(a, b);
     return impls[shape.length]($a, $b);

package/defopt.js

@@ -1,5 +1,10 @@
 import { top } from "./top.js";
 const defOpT = (fn) => {
+  const f0 = (out, a) => {
+    !out && (out = a);
+    out.data[out.offset] = fn(a.data[a.offset]);
+    return out;
+  };
   const f1 = (out, a) => {
     !out && (out = a);
     const {
@@ -99,7 +104,7 @@ const defOpT = (fn) => {
     }
     return out;
   };
-  return top(1, void 0, f1, f2, f3, f4);
+  return top(1, f0, f1, f2, f3, f4);
 };
 export {
   defOpT

package/defoptn.js

@@ -1,5 +1,10 @@
 import { top } from "./top.js";
 const defOpTN = (fn) => {
+  const f0 = (out, a, n) => {
+    !out && (out = a);
+    out.data[out.offset] = fn(a.data[a.offset], n);
+    return out;
+  };
   const f1 = (out, a, n) => {
     !out && (out = a);
     const {
@@ -99,7 +104,7 @@ const defOpTN = (fn) => {
     }
     return out;
   };
-  return top(1, void 0, f1, f2, f3, f4);
+  return top(1, f0, f1, f2, f3, f4);
 };
 export {
   defOpTN

package/defoptnn.js

@@ -1,5 +1,10 @@
 import { top } from "./top.js";
 const defOpTNN = (fn) => {
+  const f0 = (out, a, n, m) => {
+    !out && (out = a);
+    out.data[out.offset] = fn(a.data[a.offset], n, m);
+    return out;
+  };
   const f1 = (out, a, n, m) => {
     !out && (out = a);
     const {
@@ -99,14 +104,7 @@ const defOpTNN = (fn) => {
     }
     return out;
   };
-  return top(
-    1,
-    void 0,
-    f1,
-    f2,
-    f3,
-    f4
-  );
+  return top(1, f0, f1, f2, f3, f4);
 };
 export {
   defOpTNN

package/defoptt.js

@@ -2,6 +2,11 @@ import { broadcast } from "./broadcast.js";
 import { ensureShape } from "./errors.js";
 import { tensor } from "./tensor.js";
 const defOpTT = (fn) => {
+  const f0 = (out, a, b) => {
+    !out && (out = a);
+    out.data[out.offset] = fn(a.data[a.offset], b.data[b.offset]);
+    return out;
+  };
   const f1 = (out, a, b) => {
     !out && (out = a);
     const {
@@ -136,7 +141,7 @@ const defOpTT = (fn) => {
     }
     return out;
   };
-  const impls = [, f1, f2, f3, f4];
+  const impls = [f0, f1, f2, f3, f4];
   const wrapper = (out, a, b) => {
     const { shape, a: $a, b: $b } = broadcast(a, b);
     if (out) {

package/defopttt.js

@@ -2,6 +2,14 @@ import { broadcast } from "./broadcast.js";
 import { ensureShape } from "./errors.js";
 import { tensor } from "./tensor.js";
 const defOpTTT = (fn) => {
+  const f0 = (out, a, b, c) => {
+    out.data[out.offset] = fn(
+      a.data[a.offset],
+      b.data[b.offset],
+      c.data[c.offset]
+    );
+    return out;
+  };
   const f1 = (out, a, b, c) => {
     const {
       data: odata,
@@ -165,7 +173,7 @@ const defOpTTT = (fn) => {
     }
     return out;
   };
-  const impls = [, f1, f2, f3, f4];
+  const impls = [f0, 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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thi.ng/tensors",
-  "version": "0.8.12",
-  "description": "1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage",
+  "version": "0.9.0",
+  "description": "0D/1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage",
   "type": "module",
   "module": "./index.js",
   "typings": "./index.d.ts",
@@ -40,14 +40,14 @@
   },
   "dependencies": {
     "@thi.ng/api": "^8.12.1",
-    "@thi.ng/arrays": "^2.13.9",
-    "@thi.ng/checks": "^3.7.16",
+    "@thi.ng/arrays": "^2.13.10",
+    "@thi.ng/checks": "^3.7.17",
     "@thi.ng/equiv": "^2.1.91",
     "@thi.ng/errors": "^2.5.41",
     "@thi.ng/math": "^5.11.35",
     "@thi.ng/random": "^4.1.26",
     "@thi.ng/strings": "^3.9.21",
-    "@thi.ng/vectors": "^8.6.4"
+    "@thi.ng/vectors": "^8.6.5"
   },
   "devDependencies": {
     "esbuild": "^0.25.8",
@@ -339,5 +339,5 @@
     "status": "alpha",
     "year": 2018
   },
-  "gitHead": "9a998c33c7a524c95b552b9cbdc2734d28a5dafc\n"
+  "gitHead": "b133e905b546bff0d244826684269cdbb2fcfa25\n"
 }

package/rand-distrib.d.ts

@@ -1,6 +1,7 @@
 import type { Fn0 } from "@thi.ng/api";
 import type { ITensor } from "./api.js";
-import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+import type { Tensor0, Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+export declare const randDistrib0: (a: Tensor0, rnd?: () => number, n?: number) => Tensor0<number>;
 /**
  * Same as {@link randDistrib} for 1D tensors.
  *

package/rand-distrib.js

@@ -1,5 +1,9 @@
 import { normal as op } from "@thi.ng/random/distributions/normal";
 import { top } from "./top.js";
+const randDistrib0 = (a, rnd = op(), n = 1) => {
+  a.data[a.offset] = rnd() * n;
+  return a;
+};
 const randDistrib1 = (a, rnd = op(), n = 1) => {
   const {
     data,
@@ -69,7 +73,7 @@ const randDistrib4 = (a, rnd = op(), n = 1) => {
 };
 const randDistrib = top(
   0,
-  void 0,
+  randDistrib0,
   randDistrib1,
   randDistrib2,
   randDistrib3,
@@ -77,6 +81,7 @@ const randDistrib = top(
 );
 export {
   randDistrib,
+  randDistrib0,
   randDistrib1,
   randDistrib2,
   randDistrib3,

package/tensor.d.ts

@@ -1,4 +1,4 @@
-import type { Maybe, NumericArray } from "@thi.ng/api";
+import type { NumericArray } from "@thi.ng/api";
 import type { ITensor, ITensorStorage, Nested, NestedTensor, NumType, Shape, ShapeTensor, TensorCtor, TensorData, TensorFromArrayOpts, TensorOpts, Type, TypeMap } from "./api.js";
 export declare abstract class ATensor<T = number> implements ITensor<T> {
     type: Type;
@@ -24,7 +24,7 @@ export declare abstract class ATensor<T = number> implements ITensor<T> {
     equiv(o: any): boolean;
     eqDelta(o: ITensor<T>, eps?: number): boolean;
     abstract index(pos: NumericArray): number;
-    position(index: number): any[];
+    position(index: number): number[];
     abstract get(pos: NumericArray): T;
     abstract set(pos: NumericArray, v: T): this;
     hi(pos: NumericArray): this;
@@ -40,9 +40,23 @@ export declare abstract class ATensor<T = number> implements ITensor<T> {
     toJSON(): {
         buf: T[];
         shape: number[];
-        stride: any[];
+        stride: number[];
     };
 }
+export declare class Tensor0<T = number> extends ATensor<T> {
+    [Symbol.iterator](): IterableIterator<T>;
+    get dim(): number;
+    get order(): number[];
+    get length(): number;
+    index(): number;
+    position(): number[];
+    get(): T;
+    set(_: NumericArray, v: T): this;
+    pick([x]: NumericArray): Tensor0<T>;
+    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
+    transpose(_: number[]): this;
+    toString(): string;
+}
 export declare class Tensor1<T = number> extends ATensor<T> {
     [Symbol.iterator](): IterableIterator<T>;
     get dim(): number;
@@ -52,7 +66,7 @@ export declare class Tensor1<T = number> extends ATensor<T> {
     position(index: number): number[];
     get([x]: NumericArray): T;
     set([x]: NumericArray, v: T): this;
-    pick([x]: NumericArray): Tensor1<T>;
+    pick([x]: NumericArray): ITensor<T>;
     resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
     transpose(_: number[]): this;
     toString(): string;
@@ -91,7 +105,10 @@ export declare class Tensor4<T = number> extends ATensor<T> {
     resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
     toString(): string;
 }
-export declare const TENSOR_IMPLS: Maybe<TensorCtor<any>>[];
+export declare const TENSOR_IMPLS: TensorCtor<any>[];
+/** Syntax sugar for wrapping a single scalar value */
+export declare function tensor(value: number): Tensor0<number>;
+export declare function tensor(value: string): Tensor0<string>;
 /** Syntax sugar for {@link tensorFromArray}. */
 export declare function tensor<T extends NumType, N extends Nested<number>>(data: N, opts?: TensorFromArrayOpts<T, number>): NestedTensor<N, number>;
 /** Syntax sugar for {@link tensorFromArray}. */
@@ -108,6 +125,13 @@ export declare function tensor<N extends Nested<string>>(data: N, opts?: TensorF
  * @param opts
  */
 export declare function tensor<T extends Type, S extends Shape>(type: T, shape: S, opts?: TensorOpts<TypeMap[T], S>): ShapeTensor<S, TypeMap[T]>;
+/**
+ * Returns a matching tensor impl for given shape. If `shape=[1]` the function
+ * returns {@link Tensor0}. Returns undefined if no matching impl is available.
+ *
+ * @param shape
+ */
+export declare const tensorImpl: (shape: number[]) => TensorCtor<any>;
 /**
  * Creates a new {@link ITensor} instance from given (possibly nested) numeric
  * array, and options.
@@ -133,6 +157,7 @@ export declare function tensorFromArray<N extends Nested<string>>(data: N, opts?
 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 constant: <T extends Type, S extends Shape>(shape: S, value: TypeMap[T], type: T, storage?: ITensorStorage<TypeMap[T]>) => ShapeTensor<S, TypeMap[T]>;
-export declare const shapeToStride: (shape: number[]) => any[];
+export declare const shapeToStride: (shape: number[]) => number[];
 export declare const strideOrder: (strides: number[]) => number[];
+export declare const computeOffset: (shape: number[], stride: number[]) => number;
 //# sourceMappingURL=tensor.d.ts.map

package/tensor.js

@@ -72,6 +72,7 @@ class ATensor {
   }
   position(index) {
     const { order, stride } = this;
+    index |= 0;
     index -= this.offset;
     const idx = order.map((o) => {
       const i = ~~(index / stride[o]);
@@ -172,6 +173,61 @@ class ATensor {
     };
   }
 }
+class Tensor0 extends ATensor {
+  *[Symbol.iterator]() {
+    yield this.data[this.offset];
+  }
+  get dim() {
+    return 0;
+  }
+  get order() {
+    return [0];
+  }
+  get length() {
+    return 1;
+  }
+  index() {
+    return this.offset;
+  }
+  position() {
+    return [0];
+  }
+  get() {
+    return this.data[this.offset];
+  }
+  set(_, v) {
+    this.data[this.offset] = v;
+    return this;
+  }
+  pick([x]) {
+    if (x !== 0) outOfBounds(x);
+    return new Tensor0(
+      this.type,
+      this.storage,
+      this.data,
+      [],
+      [],
+      this.offset
+    );
+  }
+  resize(newShape, fill, storage = this.storage) {
+    const newLength = product(newShape);
+    const newData = storage.alloc(newLength);
+    if (fill !== void 0) newData.fill(fill);
+    newData[0] = this.get();
+    return tensor(this.type, newShape, {
+      storage,
+      data: newData,
+      copy: false
+    });
+  }
+  transpose(_) {
+    return unsupported();
+  }
+  toString() {
+    return format(this.get());
+  }
+}
 class Tensor1 extends ATensor {
   *[Symbol.iterator]() {
     let {
@@ -195,7 +251,7 @@ class Tensor1 extends ATensor {
     return this.offset + x * this.stride[0];
   }
   position(index) {
-    return [~~((index - this.offset) / this.stride[0])];
+    return [~~(((index | 0) - this.offset) / this.stride[0])];
   }
   get([x]) {
     return this.data[this.offset + x * this.stride[0]];
@@ -206,12 +262,12 @@ class Tensor1 extends ATensor {
   }
   pick([x]) {
     if (x < 0 && x >= this.length) outOfBounds(x);
-    return new Tensor1(
+    return new Tensor0(
       this.type,
       this.storage,
       this.data,
-      [1],
-      [1],
+      [],
+      [],
       this.offset + x * this.stride[0]
     );
   }
@@ -235,7 +291,7 @@ class Tensor1 extends ATensor {
     });
   }
   transpose(_) {
-    return this.copy();
+    return unsupported();
   }
   toString() {
     const res = [];
@@ -443,7 +499,7 @@ class Tensor4 extends ATensor {
   }
 }
 const TENSOR_IMPLS = [
-  void 0,
+  Tensor0,
   Tensor1,
   Tensor2,
   Tensor3,
@@ -451,30 +507,32 @@ const TENSOR_IMPLS = [
 ];
 function tensor(...args) {
   if (Array.isArray(args[0])) return tensorFromArray(args[0], args[1]);
+  if (args.length === 1) return __tensor0(args[0]);
   const type = args[0];
   const shape = args[1];
+  const dim = shape.length;
   const opts = args[2];
   const storage = opts?.storage ?? STORAGE[type];
   const stride = opts?.stride ?? shapeToStride(shape);
+  const offset = opts?.offset ?? computeOffset(shape, stride);
   let data;
   if (opts?.data) {
     if (opts?.copy === false) data = opts.data;
     else data = storage.from(opts.data);
   } else {
-    data = storage.alloc(product(shape));
-  }
-  let offset = opts?.offset;
-  if (offset === void 0) {
-    offset = 0;
-    for (let i = 0; i < shape.length; i++) {
-      if (stride[i] < 0) {
-        offset -= (shape[i] - 1) * stride[i];
-      }
-    }
+    data = storage.alloc(dim > 0 ? product(shape) : 1);
   }
-  const ctor = TENSOR_IMPLS[shape.length];
-  return ctor ? new ctor(type, storage, data, shape, stride, offset) : unsupported(`unsupported dimension: ${shape.length}`);
+  const ctor = TENSOR_IMPLS[dim];
+  return ctor ? new ctor(type, storage, data, shape, stride, offset) : unsupported(`unsupported dimension: ${dim}`);
 }
+const __tensor0 = (x) => {
+  const type = isNumber(x) ? "num" : "str";
+  const storage = STORAGE[type];
+  const data = storage.alloc(1);
+  data[0] = x;
+  return new Tensor0(type, storage, data, [], []);
+};
+const tensorImpl = (shape) => shape.length === 1 && shape[0] === 1 ? Tensor0 : TENSOR_IMPLS[shape.length];
 function tensorFromArray(data, opts) {
   const shape = [data.length];
   let $data = data;
@@ -507,6 +565,15 @@ const shapeToStride = (shape) => {
   return stride;
 };
 const strideOrder = (strides) => strides.map((x, i) => [x, i]).sort((a, b) => abs(b[0]) - abs(a[0])).map((x) => x[1]);
+const computeOffset = (shape, stride) => {
+  let offset = 0;
+  for (let i = 0; i < shape.length; i++) {
+    if (stride[i] < 0) {
+      offset -= (shape[i] - 1) * stride[i];
+    }
+  }
+  return offset;
+};
 const __lo = (select, { shape, stride, offset }) => {
   const newShape = [];
   for (let i = 0, n = shape.length; i < n; i++) {
@@ -566,15 +633,18 @@ const __pick = (select, { shape, stride, offset }) => {
 export {
   ATensor,
   TENSOR_IMPLS,
+  Tensor0,
   Tensor1,
   Tensor2,
   Tensor3,
   Tensor4,
+  computeOffset,
   constant,
   ones,
   shapeToStride,
   strideOrder,
   tensor,
   tensorFromArray,
+  tensorImpl,
   zeroes
 };