@thi.ng/tensors 0.1.0

package/addn.d.ts

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

package/addn.js

@@ -0,0 +1,15 @@
+import { $add } from "@thi.ng/vectors/ops";
+import { defOpTN } from "./defoptn.js";
+const [a, b, c, d, e] = defOpTN($add);
+const addN = a;
+const addN1 = b;
+const addN2 = c;
+const addN3 = d;
+const addN4 = e;
+export {
+  addN,
+  addN1,
+  addN2,
+  addN3,
+  addN4
+};

package/api.d.ts

@@ -0,0 +1,137 @@
+import type { Type as $Type, Fn2, Fn3, Fn4, ICopy, IEqualsDelta, IEquiv, ILength, Maybe, NumericArray } from "@thi.ng/api";
+import type { 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 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 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 {
+    u8: number;
+    u8c: number;
+    i8: number;
+    u16: number;
+    i16: number;
+    u32: number;
+    i32: number;
+    f32: number;
+    f64: number;
+    num: number;
+    str: string;
+}
+export interface TensorOpts<T, S extends Shape> {
+    /**
+     * Tensor data. Unless {@link TensorOpts.copy} is false, by default will be
+     * copied to memory obtained from configured storage.
+     */
+    data?: TensorData<T>;
+    /**
+     * Optionally configured storage provider. By default uses the
+     * datatype-specific implementation from global {@link STORAGE} registry.
+     */
+    storage?: ITensorStorage<T>;
+    /**
+     * Optionally configured stride tuple. By default the strides will be
+     * obtained from the tensor shape and will be in row-major order.
+     */
+    stride?: S;
+    /**
+     * Optional start index of the data values (only inteded to be used if
+     * {@link TensorOpts.data} is given).
+     */
+    offset?: number;
+    /**
+     * Only used if {@link TensorOpts.data} is given. If true (default), the
+     * data will be copied to memory obtained from configured storage.
+     */
+    copy?: boolean;
+}
+export interface TensorFromArrayOpts<T extends Type, V> {
+    type: T;
+    storage?: ITensorStorage<V>;
+}
+export interface ITensor<T = number> extends ICopy<ITensor<T>>, IEquiv, IEqualsDelta<ITensor<T>> {
+    readonly type: Type;
+    readonly storage: ITensorStorage<T>;
+    readonly data: TensorData<T>;
+    readonly shape: number[];
+    readonly stride: number[];
+    readonly offset: number;
+    readonly length: number;
+    readonly dim: number;
+    readonly order: number[];
+    orderedShape: number[];
+    orderedStride: number[];
+    [Symbol.iterator](): IterableIterator<T>;
+    empty(storage?: ITensorStorage<T>): this;
+    index(pos: NumericArray): number;
+    get(pos: NumericArray): T;
+    set(pos: NumericArray, value: T): this;
+    lo(pos: NumericArray): this;
+    hi(pos: NumericArray): this;
+    step(select: NumericArray): this;
+    pick(select: NumericArray): ITensor<T>;
+    pack(storage?: ITensorStorage<T>): this;
+    reshape<S extends Shape>(newShape: S, newStride?: S): ShapeTensor<S, T>;
+    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
+    transpose(order: NumericArray): this;
+    toJSON(): any;
+}
+export interface TensorCtor<T = number> {
+    new (type: Type, storage: ITensorStorage<T>, data: TensorData<T>, shape: number[], stride: number[], offset?: number): ITensor<T>;
+}
+export interface ITensorStorage<T> {
+    alloc(size: number): TensorData<T>;
+    from(iter: Iterable<T>): TensorData<T>;
+    release(buf: TensorData<T>): boolean;
+}
+export type StorageRegistry = Record<Type, ITensorStorage<any>>;
+export type TensorOpN<A = number, B = A, TB extends ITensor<B> = ITensor<B>> = Fn2<TB, A, TB>;
+export type TensorOpT<A = number, B = A, TA extends ITensor<A> = ITensor<A>, TB extends ITensor<B> = ITensor<B>> = Fn2<TB | null, TA, TB>;
+export type TensorOpTN<A = number, B = A, TA extends ITensor<A> = ITensor<A>, TB extends ITensor<B> = ITensor<B>> = Fn3<TB | null, TA, A, TB>;
+export type TensorOpTNN<A = number, B = A, TA extends ITensor<A> = ITensor<A>, TB extends ITensor<B> = ITensor<B>> = Fn4<TB | null, TA, A, A, TB>;
+export type TensorOpTT<A = number, B = A, TA extends ITensor<A> = ITensor<A>, TB extends ITensor<B> = ITensor<B>> = Fn3<TB | null, TA, TA, TB>;
+export type TensorOpTTT<A = number, B = A, TA extends ITensor<A> = ITensor<A>, TB extends ITensor<B> = ITensor<B>> = Fn4<TB | null, TA, TA, TA, TB>;
+export type TensorOpRT<A, B, TA extends ITensor<A> = ITensor<A>> = (a: TA) => B;
+export type TensorOpRTT<A, B, TA extends ITensor<A> = ITensor<A>> = (a: TA, b: TA) => B;
+export interface MultiTensorOp<TOP> {
+    /**
+     * Adds / overwrites implementation for given tensor dimension.
+     *
+     * @param dim -
+     * @param op -
+     */
+    add(dim: number, op: TOP): TOP;
+    /**
+     * Adds / overwrites default implementation (SHOULD support arbitrary tensor
+     * dimensions).
+     *
+     * @param op -
+     */
+    default(op: TOP): TOP;
+    /**
+     * Returns implementation for given tensor dimension or default
+     * implementation.
+     *
+     * @param dim -
+     */
+    impl(dim?: number): Maybe<TOP>;
+}
+export type MultiTensorOpImpl<T> = T & MultiTensorOp<T>;
+export type MultiTensorOpN<A = number, B = A> = MultiTensorOpImpl<TensorOpN<A, B>>;
+export type MultiTensorOpT<A = number, B = A> = MultiTensorOpImpl<TensorOpT<A, B>>;
+export type MultiTensorOpTN<A = number, B = A> = MultiTensorOpImpl<TensorOpTN<A, B>>;
+export type MultiTensorOpTNN<A = number, B = A> = MultiTensorOpImpl<TensorOpTNN<A, B>>;
+export type MultiTensorOpTT<A = number, B = A> = MultiTensorOpImpl<TensorOpTT<A, B>>;
+export type MultiTensorOpTTT<A = number, B = A> = MultiTensorOpImpl<TensorOpTTT<A, B>>;
+export type MultiTensorOpRT<A = number, B = A> = MultiTensorOpImpl<TensorOpRT<A, B>>;
+export type MultiTensorOpRTT<A = number, B = A> = MultiTensorOpImpl<TensorOpRTT<A, B>>;
+//# sourceMappingURL=api.d.ts.map

package/clamp.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Componentwise clamps nD tensor `a` to closed interval defined by `[b,c]`.
+ * Writes result to `out`. If `out` is null, mutates `a`. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - input tensor (min)
+ * @param c - input tensor (max)
+ */
+export declare const clamp: import("./api.js").MultiTensorOpTTT<number>;
+/**
+ * Same as {@link clamp} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - input tensor (min)
+ * @param c - input tensor (max)
+ */
+export declare const clamp1: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link clamp} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - input tensor (min)
+ * @param c - input tensor (max)
+ */
+export declare const clamp2: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link clamp} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - input tensor (min)
+ * @param c - input tensor (max)
+ */
+export declare const clamp3: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link clamp} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - input tensor (min)
+ * @param c - input tensor (max)
+ */
+export declare const clamp4: import("./api.js").TensorOpTTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=clamp.d.ts.map

package/clamp.js

@@ -0,0 +1,15 @@
+import { clamp as op } from "@thi.ng/math/interval";
+import { defOpTTT } from "./defopttt.js";
+const [a, b, c, d, e] = defOpTTT(op);
+const clamp = a;
+const clamp1 = b;
+const clamp2 = c;
+const clamp3 = d;
+const clamp4 = e;
+export {
+  clamp,
+  clamp1,
+  clamp2,
+  clamp3,
+  clamp4
+};

package/clampn.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Componentwise clamps nD tensor `a` to closed interval defined by `[b,c]`.
+ * Writes result to `out`. If `out` is null, mutates `a`. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - scalar (min)
+ * @param c - scalar (max)
+ */
+export declare const clampN: import("./api.js").MultiTensorOpTNN<number>;
+/**
+ * Same as {@link clampN} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - scalar (min)
+ * @param c - scalar (max)
+ */
+export declare const clampN1: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link clampN} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - scalar (min)
+ * @param c - scalar (max)
+ */
+export declare const clampN2: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link clampN} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - scalar (min)
+ * @param c - scalar (max)
+ */
+export declare const clampN3: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link clampN} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param b - scalar (min)
+ * @param c - scalar (max)
+ */
+export declare const clampN4: import("./api.js").TensorOpTNN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=clampn.d.ts.map

package/clampn.js

@@ -0,0 +1,15 @@
+import { clamp as op } from "@thi.ng/math/interval";
+import { defOpTNN } from "./defoptnn.js";
+const [a, b, c, d, e] = defOpTNN(op);
+const clampN = a;
+const clampN1 = b;
+const clampN2 = c;
+const clampN3 = d;
+const clampN4 = e;
+export {
+  clampN,
+  clampN1,
+  clampN2,
+  clampN3,
+  clampN4
+};

package/cos.d.ts

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

package/cos.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.cos);
+const cos = a;
+const cos1 = b;
+const cos2 = c;
+const cos3 = d;
+const cos4 = e;
+export {
+  cos,
+  cos1,
+  cos2,
+  cos3,
+  cos4
+};

package/defopn.d.ts

@@ -0,0 +1,13 @@
+import type { Fn } from "@thi.ng/api";
+import type { MultiTensorOpN, TensorOpN } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+/**
+ * Higher order tensor op factory. Takes given `fn` and returns a 4-tuple of
+ * {@link TensorOpN}s applying the given function component-wise. The result
+ * tuple uses this order: `[polymorphic, 1d, 2d, 3d, 4d]`.
+ *
+ * @param fn
+ * @param dispatch
+ */
+export declare const defOpN: <A = number, B = A>(fn: Fn<A, B>) => [MultiTensorOpN<A, B>, TensorOpN<A, B, Tensor1<B>>, TensorOpN<A, B, Tensor2<B>>, TensorOpN<A, B, Tensor3<B>>, TensorOpN<A, B, Tensor4<B>>];
+//# sourceMappingURL=defopn.d.ts.map

package/defopn.js

@@ -0,0 +1,65 @@
+import { top } from "./top.js";
+const defOpN = (fn) => {
+  const f1 = (out, a) => {
+    const {
+      data,
+      offset,
+      shape: [sx],
+      stride: [tx]
+    } = out;
+    for (let x = 0; x < sx; x++) data[offset + x * tx] = fn(a);
+    return out;
+  };
+  const f2 = (out, a) => {
+    const {
+      data,
+      shape: [sx, sy],
+      stride: [tx, ty],
+      offset
+    } = out;
+    for (let x = 0; x < sx; x++) {
+      const ox = offset + x * tx;
+      for (let y = 0; y < sy; y++) data[ox + y * ty] = fn(a);
+    }
+    return out;
+  };
+  const f3 = (out, a) => {
+    const {
+      data,
+      shape: [sx, sy, sz],
+      stride: [tx, ty, tz],
+      offset
+    } = out;
+    for (let x = 0; x < sx; x++) {
+      const ox = offset + x * tx;
+      for (let y = 0; y < sy; y++) {
+        const oy = ox + y * ty;
+        for (let z = 0; z < sz; z++) data[oy + z * tz] = fn(a);
+      }
+    }
+    return out;
+  };
+  const f4 = (out, a) => {
+    const {
+      data,
+      shape: [sx, sy, sz, sw],
+      stride: [tx, ty, tz, tw],
+      offset
+    } = out;
+    for (let x = 0; x < sx; x++) {
+      const ox = offset + x * tx;
+      for (let y = 0; y < sy; y++) {
+        const oy = ox + y * ty;
+        for (let z = 0; z < sz; z++) {
+          const oz = oy + z * tz;
+          for (let w = 0; w < sw; w++) data[oz + w * tw] = fn(a);
+        }
+      }
+    }
+    return out;
+  };
+  return [top(0, void 0, f1, f2, f3, f4), f1, f2, f3, f4];
+};
+export {
+  defOpN
+};

package/defoprt.d.ts

@@ -0,0 +1,14 @@
+import type { Fn0, Fn2 } from "@thi.ng/api";
+import type { MultiTensorOpRT, TensorOpRT } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+/**
+ * Higher order tensor reduction op factory. Takes given reduction `rfn` and
+ * `init` function to produce an initial result. Returns a 4-tuple of
+ * {@link TensorOpRT}s applying the given function component-wise. The result
+ * tuple uses this order: `[polymorphic, 1d, 2d, 3d]`.
+ *
+ * @param rfn
+ * @param init
+ */
+export declare const defOpRT: <A = number, B = A>(rfn: Fn2<B, A, B>, init: Fn0<B>) => [MultiTensorOpRT<A, B>, TensorOpRT<A, B, Tensor1<A>>, TensorOpRT<A, B, Tensor2<A>>, TensorOpRT<A, B, Tensor3<A>>, TensorOpRT<A, B, Tensor4<A>>];
+//# sourceMappingURL=defoprt.d.ts.map

package/defoprt.js

@@ -0,0 +1,77 @@
+import { top } from "./top.js";
+const defOpRT = (rfn, init) => {
+  const f1 = (a) => {
+    const {
+      data,
+      offset,
+      shape: [sx],
+      stride: [tx]
+    } = a;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      res = rfn(res, data[offset + x * tx]);
+    }
+    return res;
+  };
+  const f2 = (a) => {
+    const {
+      data,
+      offset,
+      shape: [sx, sy],
+      stride: [tx, ty]
+    } = a;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      const ox = offset + x * tx;
+      for (let y = 0; y < sy; y++) {
+        res = rfn(res, data[ox + y * ty]);
+      }
+    }
+    return res;
+  };
+  const f3 = (a) => {
+    const {
+      data,
+      offset,
+      shape: [sx, sy, sz],
+      stride: [tx, ty, tz]
+    } = a;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      const ox = offset + x * tx;
+      for (let y = 0; y < sy; y++) {
+        const oy = ox + y * ty;
+        for (let z = 0; z < sz; z++) {
+          res = rfn(res, data[oy + z * tz]);
+        }
+      }
+    }
+    return res;
+  };
+  const f4 = (a) => {
+    const {
+      data,
+      offset,
+      shape: [sx, sy, sz, sw],
+      stride: [tx, ty, tz, tw]
+    } = a;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      const ox = offset + x * tx;
+      for (let y = 0; y < sy; y++) {
+        const oy = ox + y * ty;
+        for (let z = 0; z < sz; z++) {
+          const oz = oy + z * tz;
+          for (let w = 0; w < sw; w++) {
+            res = rfn(res, data[oz + w * tw]);
+          }
+        }
+      }
+    }
+    return res;
+  };
+  return [top(0, void 0, f1, f2, f3, f4), f1, f2, f3, f4];
+};
+export {
+  defOpRT
+};

package/defoprtt.d.ts

@@ -0,0 +1,14 @@
+import type { Fn0, Fn3 } from "@thi.ng/api";
+import type { MultiTensorOpRTT, TensorOpRTT } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+/**
+ * Higher order tensor reduction op factory. Takes given reduction `rfn` and
+ * `init` function to produce an initial result. Returns a 4-tuple of
+ * {@link TensorOpRTT}s applying the given function component-wise. The result
+ * tuple uses this order: `[polymorphic, 1d, 2d, 3d]`.
+ *
+ * @param rfn
+ * @param init
+ */
+export declare const defOpRTT: <A = number, B = A>(rfn: Fn3<B, A, A, B>, init: Fn0<B>) => [MultiTensorOpRTT<A, B>, TensorOpRTT<A, B, Tensor1<A>>, TensorOpRTT<A, B, Tensor2<A>>, TensorOpRTT<A, B, Tensor3<A>>, TensorOpRTT<A, B, Tensor4<A>>];
+//# sourceMappingURL=defoprtt.d.ts.map

package/defoprtt.js

@@ -0,0 +1,113 @@
+import { top } from "./top.js";
+const defOpRTT = (rfn, init) => {
+  const f1 = (a, b) => {
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx],
+      stride: [txa]
+    } = a;
+    const {
+      data: bdata,
+      offset: ob,
+      stride: [txb]
+    } = b;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      res = rfn(res, adata[oa + x * txa], bdata[ob + x * txb]);
+    }
+    return res;
+  };
+  const f2 = (a, b) => {
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx, sy],
+      stride: [txa, tya]
+    } = a;
+    const {
+      data: bdata,
+      offset: ob,
+      stride: [txb, tyb]
+    } = b;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      const oax = oa + x * txa;
+      const obx = ob + x * txb;
+      for (let y = 0; y < sy; y++) {
+        res = rfn(res, adata[oax + y * tya], bdata[obx + y * tyb]);
+      }
+    }
+    return res;
+  };
+  const f3 = (a, b) => {
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx, sy, sz],
+      stride: [txa, tya, tza]
+    } = a;
+    const {
+      data: bdata,
+      offset: ob,
+      stride: [txb, tyb, tzb]
+    } = b;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      const oax = oa + x * txa;
+      const obx = ob + x * txb;
+      for (let y = 0; y < sy; y++) {
+        const oay = oax + y * tya;
+        const oby = obx + y * tyb;
+        for (let z = 0; z < sz; z++) {
+          res = rfn(res, adata[oay + z * tza], bdata[oby + z * tzb]);
+        }
+      }
+    }
+    return res;
+  };
+  const f4 = (a, b) => {
+    const {
+      data: adata,
+      offset: oa,
+      shape: [sx, sy, sz, sw],
+      stride: [txa, tya, tza, twa]
+    } = a;
+    const {
+      data: bdata,
+      offset: ob,
+      stride: [txb, tyb, tzb, twb]
+    } = b;
+    let res = init();
+    for (let x = 0; x < sx; x++) {
+      const oax = oa + x * txa;
+      const obx = ob + x * txb;
+      for (let y = 0; y < sy; y++) {
+        const oay = oax + y * tya;
+        const oby = obx + y * tyb;
+        for (let z = 0; z < sz; z++) {
+          const oaz = oay + z * tza;
+          const obz = oby + z * tzb;
+          for (let w = 0; w < sw; w++) {
+            res = rfn(
+              res,
+              adata[oaz + w * twa],
+              bdata[obz + w * twb]
+            );
+          }
+        }
+      }
+    }
+    return res;
+  };
+  return [
+    top(0, void 0, f1, f2, f3, f4),
+    f1,
+    f2,
+    f3,
+    f4
+  ];
+};
+export {
+  defOpRTT
+};