@thi.ng/tensors 0.8.13 → 0.10.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-08-04T09:13:01Z
+- **Last updated**: 2025-09-01T16:38:35Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,28 @@ 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.10.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/tensors@0.10.0) (2025-09-01)
+
+#### 🚀 Features
+
+- add 1D/2D/3D samplers and resampling fns ([2130067](https://github.com/thi-ng/umbrella/commit/2130067))
+  - add `defSampler1/2/3/4()` and supporting helpers
+  - add sampling kernel presets:
+    - `SAMPLE_NEAREST`
+    - `SAMPLE_LINEAR`
+    - `SAMPLE_CUBIC`
+    - `SAMPLE_LANCZOS` (higher order)
+  - add `resample1/2/3()` fns
+
+## [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: 11.49 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/index.d.ts

@@ -50,6 +50,7 @@ export * from "./rand-distrib.js";
 export * from "./range.js";
 export * from "./relu.js";
 export * from "./relun.js";
+export * from "./sample.js";
 export * from "./select.js";
 export * from "./set.js";
 export * from "./setn.js";

package/index.js

@@ -50,6 +50,7 @@ export * from "./rand-distrib.js";
 export * from "./range.js";
 export * from "./relu.js";
 export * from "./relun.js";
+export * from "./sample.js";
 export * from "./select.js";
 export * from "./set.js";
 export * from "./setn.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thi.ng/tensors",
-  "version": "0.8.13",
-  "description": "1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage",
+  "version": "0.10.0",
+  "description": "0D/1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage",
   "type": "module",
   "module": "./index.js",
   "typings": "./index.d.ts",
@@ -39,19 +39,19 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.12.1",
-    "@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.5"
+    "@thi.ng/api": "^8.12.2",
+    "@thi.ng/arrays": "^2.13.11",
+    "@thi.ng/checks": "^3.7.18",
+    "@thi.ng/equiv": "^2.1.92",
+    "@thi.ng/errors": "^2.5.42",
+    "@thi.ng/math": "^5.12.0",
+    "@thi.ng/random": "^4.1.27",
+    "@thi.ng/strings": "^3.9.22",
+    "@thi.ng/vectors": "^8.6.6"
   },
   "devDependencies": {
-    "esbuild": "^0.25.8",
-    "typedoc": "^0.28.9",
+    "esbuild": "^0.25.9",
+    "typedoc": "^0.28.12",
     "typescript": "^5.9.2"
   },
   "keywords": [
@@ -268,6 +268,9 @@
     "./relun": {
       "default": "./relun.js"
     },
+    "./sample": {
+      "default": "./sample.js"
+    },
     "./select": {
       "default": "./select.js"
     },
@@ -339,5 +342,5 @@
     "status": "alpha",
     "year": 2018
   },
-  "gitHead": "f6ebc1302dc9211d588293aa0897173c6e54f4e5\n"
+  "gitHead": "e215a3e8de3809736ba0042c93bd8703a5a1a337\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/sample.d.ts

@@ -0,0 +1,27 @@
+import type { Fn2, Fn3, Fn4, Fn5, FnN, FnN2 } from "@thi.ng/api";
+import type { ITensor } from "./api.js";
+import { type Tensor1 } from "./tensor.js";
+type BoundaryFn = FnN2;
+type Sampler1 = Fn2<ITensor, number, number>;
+type Sampler2 = Fn3<ITensor, number, number, number>;
+type Sampler3 = Fn4<ITensor, number, number, number, number>;
+type Sampler4 = Fn5<ITensor, number, number, number, number, number>;
+type BoundaryType = "clamp" | "mirror" | "wrap" | "zero";
+type SamplerType = "nearest" | "linear" | "cubic" | "lanczos";
+interface SamplerKernel {
+    radius: number;
+    weight: FnN;
+}
+export declare const SAMPLE_NEAREST: SamplerKernel;
+export declare const SAMPLE_LINEAR: SamplerKernel;
+export declare const SAMPLE_CUBIC: SamplerKernel;
+export declare const SAMPLE_LANCZOS: (r?: number) => SamplerKernel;
+export declare const defSampler1: (kernel: SamplerKernel | SamplerType, boundary?: BoundaryFn | BoundaryType) => Sampler1;
+export declare const defSampler2: (kernel: SamplerType | SamplerKernel | [SamplerType | SamplerKernel, SamplerType | SamplerKernel], boundary?: BoundaryType | BoundaryFn | [BoundaryType | BoundaryFn, BoundaryType | BoundaryFn]) => Sampler2;
+export declare const defSampler3: (kernel: SamplerType | SamplerKernel | [SamplerType | SamplerKernel, SamplerType | SamplerKernel, SamplerType | SamplerKernel], boundary?: BoundaryType | BoundaryFn | [BoundaryType | BoundaryFn, BoundaryType | BoundaryFn, BoundaryType | BoundaryFn]) => Sampler3;
+export declare const defSampler4: (kernel: SamplerType | SamplerKernel | [SamplerType | SamplerKernel, SamplerType | SamplerKernel, SamplerType | SamplerKernel, SamplerType | SamplerKernel], boundary?: BoundaryType | BoundaryFn | [BoundaryType | BoundaryFn, BoundaryType | BoundaryFn, BoundaryType | BoundaryFn, BoundaryType | BoundaryFn]) => Sampler4;
+export declare const resample1: (out: Tensor1, a: Tensor1, sampler: Sampler1) => Tensor1<number>;
+export declare const resample2: (out: ITensor, a: ITensor, [samplerX, samplerY]: Sampler1[]) => ITensor<number>;
+export declare const resample3: (out: ITensor, a: ITensor, [samplerX, samplerY, samplerZ]: Sampler1[]) => ITensor<number>;
+export {};
+//# sourceMappingURL=sample.d.ts.map

package/sample.js

@@ -0,0 +1,290 @@
+import { isArray } from "@thi.ng/checks/is-array";
+import { isString } from "@thi.ng/checks/is-string";
+import { PI } from "@thi.ng/math/api";
+import { clamp } from "@thi.ng/math/interval";
+import { tensor } from "./tensor.js";
+const { abs, floor, sin } = Math;
+const __boundaryClamp = (i, max) => clamp(i, 0, max - 1);
+const __boundaryWrap = (i, max) => (i % max + max) % max;
+const __boundaryMirror = (i, max) => {
+  if (max === 1) return 0;
+  const period = 2 * (max - 1);
+  i = (i % period + period) % period;
+  return i < max ? i : period - i;
+};
+const __boundaryZero = (i, max) => i >= 0 || i < max ? i : -1;
+const BOUNDARY_MODES = {
+  clamp: __boundaryClamp,
+  wrap: __boundaryWrap,
+  mirror: __boundaryMirror,
+  zero: __boundaryZero
+};
+const SAMPLE_NEAREST = {
+  radius: 1,
+  weight: (t) => t >= -0.5 && t < 0.5 ? 1 : 0
+};
+const SAMPLE_LINEAR = {
+  radius: 1,
+  weight: (t) => {
+    t = abs(t);
+    return t < 1 ? 1 - t : 0;
+  }
+};
+const SAMPLE_CUBIC = {
+  radius: 2,
+  weight: (t) => {
+    t = abs(t);
+    const a = -0.5;
+    return t < 2 ? t <= 1 ? ((a + 2) * t - (a + 3)) * t * t + 1 : ((a * t - 5 * a) * t + 8 * a) * t - 4 * a : 0;
+  }
+};
+const SAMPLE_LANCZOS = (r = 2) => ({
+  radius: r,
+  weight: (t) => {
+    if (t === 0) return 1;
+    if (t > -r && t < r) {
+      t *= PI;
+      return r * sin(t) * sin(t / r) / (t * t);
+    }
+    return 0;
+  }
+});
+const SAMPLER_TYPES = {
+  nearest: SAMPLE_NEAREST,
+  linear: SAMPLE_LINEAR,
+  cubic: SAMPLE_CUBIC,
+  lanczos: SAMPLE_LANCZOS(2)
+};
+const defSampler1 = (kernel, boundary = "clamp") => {
+  const index = __resolveBoundary(boundary);
+  const { radius, weight } = __resolveKernel(kernel);
+  return ({ data, shape: [sx], stride: [tx], offset }, x) => {
+    const c = floor(x);
+    let sum = 0;
+    let wsum = 0;
+    for (let k = -radius; k <= radius; k++) {
+      const $x = c + k;
+      const w = weight(x - $x);
+      if (w === 0) continue;
+      const i = index($x, sx);
+      if (i < 0) {
+        wsum += w;
+        continue;
+      }
+      sum += data[offset + i * tx] * w;
+      wsum += w;
+    }
+    return wsum !== 0 ? sum / wsum : 0;
+  };
+};
+const defSampler2 = (kernel, boundary = "clamp") => {
+  const [indexX, indexY] = (isArray(boundary) ? boundary : [boundary, boundary]).map(__resolveBoundary);
+  const [kernelX, kernelY] = isArray(kernel) ? kernel : [kernel, kernel];
+  const { radius: rx, weight: weightX } = __resolveKernel(kernelX);
+  const { radius: ry, weight: weightY } = __resolveKernel(kernelY);
+  const sizeY = 2 * ry + 1;
+  const cacheY = new Array(sizeY);
+  return ({ data, shape: [sx, sy], stride: [tx, ty], offset }, x, y) => {
+    const cx = floor(x);
+    const cy = floor(y);
+    let sum = 0;
+    let wsum = 0;
+    for (let i = 0; i < sizeY; i++) {
+      cacheY[i] = weightY(y - (cy + i - ry));
+    }
+    for (let kx = -rx; kx <= rx; kx++) {
+      const $x = cx + kx;
+      const ix = indexX($x, sx);
+      const wx = weightX(x - $x);
+      const idx = offset + ix * tx;
+      for (let ky = -ry; ky <= ry; ky++) {
+        const wy = cacheY[ky + ry];
+        const weight = wx * wy;
+        if (weight === 0) continue;
+        const iy = indexY(cy + ky, sy);
+        if (ix < 0 || iy < 0) {
+          wsum += weight;
+          continue;
+        }
+        sum += data[idx + iy * ty] * weight;
+        wsum += weight;
+      }
+    }
+    return wsum !== 0 ? sum / wsum : 0;
+  };
+};
+const defSampler3 = (kernel, boundary = "clamp") => {
+  const [indexX, indexY, indexZ] = (isArray(boundary) ? boundary : [boundary, boundary, boundary]).map(__resolveBoundary);
+  const [kernelX, kernelY, kernelZ] = (isArray(kernel) ? kernel : [kernel, kernel, kernel]).map(__resolveKernel);
+  const { radius: rx, weight: weightX } = kernelX;
+  const { radius: ry, weight: weightY } = kernelY;
+  const { radius: rz, weight: weightZ } = kernelZ;
+  const sizeY = 2 * ry + 1;
+  const sizeZ = 2 * rz + 1;
+  const cacheY = new Array(sizeY);
+  const cacheZ = new Array(sizeZ);
+  return ({ data, shape: [sx, sy, sz], stride: [tx, ty, tz], offset }, x, y, z) => {
+    const cx = floor(x);
+    const cy = floor(y);
+    const cz = floor(z);
+    let sum = 0;
+    let wsum = 0;
+    for (let i = 0; i < sizeY; i++) cacheY[i] = weightY(y - (cy + i - ry));
+    for (let i = 0; i < sizeZ; i++) cacheZ[i] = weightZ(z - (cz + i - rz));
+    for (let kx = -rx; kx <= rx; kx++) {
+      const $x = cx + kx;
+      const ix = indexX($x, sx);
+      const wx = weightX(x - $x);
+      const idxX = offset + ix * tx;
+      for (let ky = -ry; ky <= ry; ky++) {
+        const iy = indexY(cy + ky, sy);
+        const wy = cacheY[ky + ry];
+        const idxXY = idxX + iy * ty;
+        for (let kz = -rz; kz <= rz; kz++) {
+          const wz = cacheZ[kz + rz];
+          const weight = wx * wy * wz;
+          if (weight === 0) continue;
+          const iz = indexZ(cz + kz, sz);
+          if (ix < 0 || iy < 0 || iz < 0) {
+            wsum += weight;
+            continue;
+          }
+          sum += data[idxXY + iz * tz] * weight;
+          wsum += weight;
+        }
+      }
+    }
+    return wsum !== 0 ? sum / wsum : 0;
+  };
+};
+const defSampler4 = (kernel, boundary = "clamp") => {
+  const [indexX, indexY, indexZ, indexW] = (isArray(boundary) ? boundary : [boundary, boundary, boundary, boundary]).map(__resolveBoundary);
+  const [kernelX, kernelY, kernelZ, kernelW] = (isArray(kernel) ? kernel : [kernel, kernel, kernel, kernel]).map(__resolveKernel);
+  const { radius: rx, weight: weightX } = kernelX;
+  const { radius: ry, weight: weightY } = kernelY;
+  const { radius: rz, weight: weightZ } = kernelZ;
+  const { radius: rw, weight: weightW } = kernelW;
+  const sizeY = 2 * ry + 1;
+  const sizeZ = 2 * rz + 1;
+  const sizeW = 2 * rw + 1;
+  const cacheY = new Array(sizeY);
+  const cacheZ = new Array(sizeZ);
+  const cacheW = new Array(sizeW);
+  return ({ data, shape: [sx, sy, sz, sw], stride: [tx, ty, tz, tw], offset }, x, y, z, w) => {
+    const cx = floor(x);
+    const cy = floor(y);
+    const cz = floor(z);
+    const cw = floor(w);
+    let sum = 0;
+    let wsum = 0;
+    for (let i = 0; i < sizeY; i++) cacheY[i] = weightY(y - (cy + i - ry));
+    for (let i = 0; i < sizeZ; i++) cacheZ[i] = weightZ(z - (cz + i - rz));
+    for (let i = 0; i < sizeW; i++) cacheW[i] = weightW(w - (cw + i - rw));
+    for (let kx = -rx; kx <= rx; kx++) {
+      const $x = cx + kx;
+      const ix = indexX($x, sx);
+      const wx = weightX(x - $x);
+      const idxX = offset + ix * tx;
+      for (let ky = -ry; ky <= ry; ky++) {
+        const iy = indexY(cy + ky, sy);
+        const wy = cacheY[ky + ry];
+        const idxXY = idxX + iy * ty;
+        for (let kz = -rz; kz <= rz; kz++) {
+          const wz = cacheZ[kz + rz];
+          const iz = indexZ(cz + kz, sz);
+          const idxXYZ = idxXY + iz * tz;
+          for (let kw = -rw; kw <= rw; kw++) {
+            const ww = cacheW[kw + rw];
+            const weight = wx * wy * wz * ww;
+            if (weight === 0) continue;
+            const iw = indexW(cw + kw, sw);
+            if (ix < 0 || iy < 0 || iz < 0 || iw < 0) {
+              wsum += weight;
+              continue;
+            }
+            sum += data[idxXYZ + iw * tw] * weight;
+            wsum += w;
+          }
+        }
+      }
+    }
+    return wsum !== 0 ? sum / wsum : 0;
+  };
+};
+const __resolveBoundary = (mode) => isString(mode) ? BOUNDARY_MODES[mode] : mode ?? __boundaryClamp;
+const __resolveKernel = (kernel) => isString(kernel) ? SAMPLER_TYPES[kernel] : kernel;
+const resample1 = (out, a, sampler) => {
+  const {
+    data: odata,
+    shape: [sxo],
+    stride: [txo],
+    offset: oo
+  } = out;
+  const {
+    shape: [sxa]
+  } = a;
+  const scale = sxa / sxo;
+  for (let i = 0; i < sxo; i++) {
+    odata[oo + i * txo] = sampler(a, (i + 0.5) * scale - 0.5);
+  }
+  return out;
+};
+const resample2 = (out, a, [samplerX, samplerY]) => {
+  const {
+    shape: [_, syo]
+  } = out;
+  const {
+    shape: [sxa]
+  } = a;
+  const tmp = tensor("num", [sxa, syo]);
+  for (let x = 0; x < sxa; x++) {
+    resample1(tmp.pick([x, -1]), a.pick([x, -1]), samplerX);
+  }
+  for (let y = 0; y < syo; y++) {
+    resample1(out.pick([-1, y]), tmp.pick([-1, y]), samplerY);
+  }
+  return out;
+};
+const resample3 = (out, a, [samplerX, samplerY, samplerZ]) => {
+  const {
+    shape: [_, syo, szo]
+  } = out;
+  const {
+    shape: [sxa, sya]
+  } = a;
+  const tmpX = tensor("num", [sxa, sya, szo]);
+  for (let i = 0; i < sxa; i++) {
+    const src = a.pick([i]);
+    const dest = tmpX.pick([i]);
+    for (let j = 0; j < sya; j++) {
+      resample1(dest.pick([j]), src.pick([j]), samplerX);
+    }
+  }
+  const tmpY = tensor("num", [sxa, syo, szo]);
+  for (let i = 0; i < sxa; i++) {
+    const src = tmpX.pick([i]);
+    const dest = tmpY.pick([i]);
+    for (let j = 0; j < szo; j++) {
+      resample1(dest.pick([-1, j]), src.pick([-1, j]), samplerY);
+    }
+  }
+  for (let i = 0; i < syo; i++) {
+    for (let j = 0; j < szo; j++) {
+      resample1(out.pick([-1, i, j]), tmpY.pick([-1, i, j]), samplerZ);
+    }
+  }
+  return out;
+};
+export {
+  SAMPLE_CUBIC,
+  SAMPLE_LANCZOS,
+  SAMPLE_LINEAR,
+  SAMPLE_NEAREST,
+  defSampler1,
+  defSampler2,
+  defSampler3,
+  defSampler4,
+  resample1,
+  resample2,
+  resample3
+};

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
 };