@thi.ng/tensors 0.1.0

package/select.d.ts

@@ -0,0 +1,91 @@
+import type { Fn, Predicate2 } from "@thi.ng/api";
+import type { ITensor } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3 } from "./tensor.js";
+/**
+ * Result type of {@link select}.
+ */
+export type SelectResult<T> = {
+    arg: number[];
+    value: T;
+};
+/**
+ * Same as {@link select} for 1D tensors.
+ *
+ * @param a
+ * @param xform
+ * @param pred
+ * @param initial
+ */
+export declare const select1: <T>(a: Tensor1<T>, xform: Fn<T, T>, pred: Predicate2<T>, initial: T) => SelectResult<T>;
+/**
+ * Same as {@link select} for 2D tensors.
+ *
+ * @param a
+ * @param xform
+ * @param pred
+ * @param initial
+ */
+export declare const select2: <T>(a: Tensor2<T>, xform: Fn<T, T>, pred: Predicate2<T>, initial: T) => SelectResult<T>;
+/**
+ * Same as {@link select} for 3D tensors.
+ *
+ * @param a
+ * @param xform
+ * @param pred
+ * @param initial
+ */
+export declare const select3: <T>(a: Tensor3<T>, xform: Fn<T, T>, pred: Predicate2<T>, initial: T) => SelectResult<T>;
+/**
+ * Same as {@link select} for 4D tensors.
+ *
+ * @param a
+ * @param xform
+ * @param pred
+ * @param initial
+ */
+export declare const select4: <T>(a: Tensor3<T>, xform: Fn<T, T>, pred: Predicate2<T>, initial: T) => SelectResult<T>;
+/**
+ * Uses given value transform `xform` and predicate `pred` to select a specific
+ * component value and its position in the tensor. The `initial` value is used
+ * to seed the search.
+ *
+ * @remarks
+ * This function is a generalization of {@link argMin}/{@link argMax}-like
+ * functionality and customizable via arbitrary predicates.
+ *
+ * @example
+ * ```ts
+ * import { select, tensor } from "@thi.ng/tensors";
+ *
+ * const a = tensor("i8", [2, 2], { data: [1, -2, -3, 4] });
+ *
+ * // select smallest value
+ * console.log(select(a, (x) => x, (a,b) => a < b, Infinity));
+ * // { arg: [1, 0], value: -3 }
+ *
+ * // select smallest absolute value
+ * console.log(select(a, Math.abs, (a,b) => a < b, Infinity));
+ * // { arg: [0, 0], value: 1 }
+ * ```
+ *
+ * @param a
+ * @param xform
+ * @param pred
+ * @param initial
+ */
+export declare const select: <T>(a: ITensor<T>, xform: Fn<T, T>, pred: Predicate2<T>, initial: T) => SelectResult<T>;
+/**
+ * Syntax sugar for {@link select} to find the minimum component value and its
+ * position in a tensor.
+ *
+ * @param a
+ */
+export declare const argMin: (a: ITensor) => SelectResult<number>;
+/**
+ * Syntax sugar for {@link select} to find the maximum component value and its
+ * position in a tensor.
+ *
+ * @param a
+ */
+export declare const argMax: (a: ITensor) => SelectResult<number>;
+//# sourceMappingURL=select.d.ts.map

package/select.js

@@ -0,0 +1,111 @@
+import { identity } from "@thi.ng/api/fn";
+import { top } from "./top.js";
+const select1 = (a, xform, pred, initial) => {
+  const {
+    data,
+    offset,
+    shape: [sx],
+    stride: [tx]
+  } = a;
+  const arg = [-1];
+  let value = initial;
+  for (let x = 0; x < sx; x++) {
+    const v = xform(data[offset + x * tx]);
+    if (pred(v, value)) {
+      value = v;
+      arg[0] = x;
+    }
+  }
+  return { arg, value };
+};
+const select2 = (a, xform, pred, initial) => {
+  const {
+    data,
+    offset,
+    shape: [sx, sy],
+    stride: [tx, ty]
+  } = a;
+  const arg = [-1, -1];
+  let value = initial;
+  for (let x = 0; x < sx; x++) {
+    const ox = offset + x * tx;
+    for (let y = 0; y < sy; y++) {
+      const v = xform(data[ox + y * ty]);
+      if (pred(v, value)) {
+        value = v;
+        arg[0] = x;
+        arg[1] = y;
+      }
+    }
+  }
+  return { arg, value };
+};
+const select3 = (a, xform, pred, initial) => {
+  const {
+    data,
+    offset,
+    shape: [sx, sy, sz],
+    stride: [tx, ty, tz]
+  } = a;
+  const arg = [-1, -1, -1];
+  let value = initial;
+  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 v = xform(data[oy + z * tz]);
+        if (pred(v, value)) {
+          value = v;
+          arg[0] = x;
+          arg[1] = y;
+          arg[2] = z;
+        }
+      }
+    }
+  }
+  return { arg, value };
+};
+const select4 = (a, xform, pred, initial) => {
+  const {
+    data,
+    offset,
+    shape: [sx, sy, sz, sw],
+    stride: [tx, ty, tz, tw]
+  } = a;
+  const arg = [-1, -1, -1, -1];
+  let value = initial;
+  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++) {
+          const v = xform(data[oz + w * tw]);
+          if (pred(v, value)) {
+            value = v;
+            arg[0] = x;
+            arg[1] = y;
+            arg[2] = z;
+            arg[3] = w;
+          }
+        }
+      }
+    }
+  }
+  return { arg, value };
+};
+const __select = top(0, void 0, select1, select2, select3, select4);
+const select = (a, xform, pred, initial) => __select(a, xform, pred, initial);
+const argMin = (a) => __select(a, identity, (a2, b) => a2 < b, Infinity);
+const argMax = (a) => __select(a, identity, (a2, b) => a2 > b, -Infinity);
+export {
+  argMax,
+  argMin,
+  select,
+  select1,
+  select2,
+  select3,
+  select4
+};

package/set.d.ts

@@ -0,0 +1,8 @@
+import type { ITensor } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+export declare const set: <T>(out: ITensor<T>, src: ITensor<T>) => ITensor<any>;
+export declare const set1: <T>(out: Tensor1<T>, src: Tensor1<T>) => Tensor1<any>;
+export declare const set2: <T>(out: Tensor2<T>, src: Tensor2<T>) => Tensor2<any>;
+export declare const set3: <T>(out: Tensor3<T>, src: Tensor3<T>) => Tensor3<any>;
+export declare const set4: <T>(out: Tensor4<T>, src: Tensor4<T>) => Tensor4<any>;
+//# sourceMappingURL=set.d.ts.map

package/set.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT((x) => x);
+const set = (out, src) => a(out, src);
+const set1 = (out, src) => b(out, src);
+const set2 = (out, src) => c(out, src);
+const set3 = (out, src) => d(out, src);
+const set4 = (out, src) => e(out, src);
+export {
+  set,
+  set1,
+  set2,
+  set3,
+  set4
+};

package/setn.d.ts

@@ -0,0 +1,8 @@
+import type { ITensor } from "./api.js";
+import type { Tensor1, Tensor2, Tensor3, Tensor4 } from "./tensor.js";
+export declare const setN: <T>(out: ITensor<T>, n: T) => ITensor<any>;
+export declare const setN1: <T>(out: Tensor1<T>, n: T) => Tensor1<any>;
+export declare const setN2: <T>(out: Tensor2<T>, n: T) => Tensor2<any>;
+export declare const setN3: <T>(out: Tensor3<T>, n: T) => Tensor3<any>;
+export declare const setN4: <T>(out: Tensor4<T>, n: T) => Tensor4<any>;
+//# sourceMappingURL=setn.d.ts.map

package/setn.js

@@ -0,0 +1,14 @@
+import { defOpN } from "./defopn.js";
+const [a, b, c, d, e] = defOpN((x) => x);
+const setN = (out, n) => a(out, n);
+const setN1 = (out, n) => b(out, n);
+const setN2 = (out, n) => c(out, n);
+const setN3 = (out, n) => d(out, n);
+const setN4 = (out, n) => e(out, n);
+export {
+  setN,
+  setN1,
+  setN2,
+  setN3,
+  setN4
+};

package/sigmoid.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Componentwise computes Sigmoid activation of given nD tensor. Writes result
+ * to `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * Reference: https://en.wikipedia.org/wiki/Sigmoid_function
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sigmoid: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link sigmoid} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sigmoid1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link sigmoid} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sigmoid2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link sigmoid} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sigmoid3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link sigmoid} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sigmoid4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=sigmoid.d.ts.map

package/sigmoid.js

@@ -0,0 +1,15 @@
+import { defOpT } from "./defopt.js";
+const { exp } = Math;
+const [a, b, c, d, e] = defOpT((x) => 1 / (1 + exp(-x)));
+const sigmoid = a;
+const sigmoid1 = b;
+const sigmoid2 = c;
+const sigmoid3 = d;
+const sigmoid4 = e;
+export {
+  sigmoid,
+  sigmoid1,
+  sigmoid2,
+  sigmoid3,
+  sigmoid4
+};

package/sin.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.sin` 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 sin: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link sin} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sin1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link sin} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sin2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link sin} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sin3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link sin} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sin4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=sin.d.ts.map

package/sin.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.sin);
+const sin = a;
+const sin1 = b;
+const sin2 = c;
+const sin3 = d;
+const sin4 = e;
+export {
+  sin,
+  sin1,
+  sin2,
+  sin3,
+  sin4
+};

package/softmax.d.ts

@@ -0,0 +1,27 @@
+import type { ITensor } from "./api.js";
+/**
+ * Computes softmax (aka normalized {@link exp}) of input tensor `src` and
+ * writes results to `out` (or if null, back into `src`). The optional
+ * `temperature` (should be >= 1) can be used to adjust the emphasis/scaling of
+ * normalized values: Higher temperatures reduce the contrast ratio between
+ * min/max components.
+ *
+ * @remarks
+ * Computes: `smax = exp(src / temp) / sum(exp(src / temp))`. The result
+ * vector's components will all be in the [0,1] range and sum to 1.0.
+ *
+ * This function is often used as the last activation function in a neural
+ * network to normalize the output to a probability distribution over predicted
+ * output classes.
+ *
+ * References:
+ *
+ * - https://en.wikipedia.org/wiki/Softmax_function
+ * - https://victorzhou.com/blog/softmax/
+ *
+ * @param out -
+ * @param src -
+ * @param temperature -
+ */
+export declare const softMax: (out: ITensor | null, src: ITensor, temperature?: number) => ITensor<number>;
+//# sourceMappingURL=softmax.d.ts.map

package/softmax.js

@@ -0,0 +1,10 @@
+import { divN } from "./divn.js";
+import { exp } from "./exp.js";
+import { sum } from "./sum.js";
+const softMax = (out, src, temperature) => {
+  const e = temperature !== void 0 ? exp(null, divN(src.empty(), src, temperature)) : exp(src.empty(), src);
+  return divN(out || src, e, sum(e));
+};
+export {
+  softMax
+};

package/softplus.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Componentwise computes Softplus activation of given nD tensor with given `k`
+ * (sharpness param, should be >= 1). Writes result to `out`. If `out` is null,
+ * mutates original. Multi-method.
+ *
+ * @remarks
+ *
+ * - Reference: https://en.wikipedia.org/wiki/Softplus
+ * - Interactive calculator: https://www.desmos.com/calculator/54pfflbsbv
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - sharpness
+ */
+export declare const softPlus: import("./api.js").MultiTensorOpTN<number>;
+/**
+ * Same as {@link softPlus} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - sharpness
+ */
+export declare const softPlus1: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link softPlus} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - sharpness
+ */
+export declare const softPlus2: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link softPlus} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - sharpness
+ */
+export declare const softPlus3: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link softPlus} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - sharpness
+ */
+export declare const softPlus4: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=softplus.d.ts.map

package/softplus.js

@@ -0,0 +1,15 @@
+import { defOpTN } from "./defoptn.js";
+const { exp, log } = Math;
+const [a, b, c, d, e] = defOpTN((x, k) => log(1 + exp(x * k)) / k);
+const softPlus = a;
+const softPlus1 = b;
+const softPlus2 = c;
+const softPlus3 = d;
+const softPlus4 = e;
+export {
+  softPlus,
+  softPlus1,
+  softPlus2,
+  softPlus3,
+  softPlus4
+};

package/sqrt.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.sqrt` 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 sqrt: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link sqrt} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sqrt1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link sqrt} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sqrt2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link sqrt} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sqrt3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link sqrt} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const sqrt4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=sqrt.d.ts.map

package/sqrt.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.sqrt);
+const sqrt = a;
+const sqrt1 = b;
+const sqrt2 = c;
+const sqrt3 = d;
+const sqrt4 = e;
+export {
+  sqrt,
+  sqrt1,
+  sqrt2,
+  sqrt3,
+  sqrt4
+};

package/step.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Componentwise computes step function for given nD tensor and uniform scalar
+ * threshold `n`. Writes result to `out`. If `out` is null, mutates `a`.
+ * Multi-method.
+ *
+ * @remarks
+ * Same logic as GLSL `step()` (but with different order of arguments). If
+ * `n=0`, the op becomes the Heaviside function:
+ * https://en.wikipedia.org/wiki/Heaviside_step_function
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const stepN: import("./api.js").MultiTensorOpTN<number>;
+/**
+ * Same as {@link stepN} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const stepN1: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link stepN} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const stepN2: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link stepN} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const stepN3: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link stepN} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const stepN4: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=step.d.ts.map

package/step.js

@@ -0,0 +1,14 @@
+import { defOpTN } from "./defoptn.js";
+const [a, b, c, d, e] = defOpTN((a2, b2) => a2 >= b2 ? 1 : 0);
+const stepN = a;
+const stepN1 = b;
+const stepN2 = c;
+const stepN3 = d;
+const stepN4 = e;
+export {
+  stepN,
+  stepN1,
+  stepN2,
+  stepN3,
+  stepN4
+};

package/storage.d.ts

@@ -0,0 +1,3 @@
+import type { StorageRegistry } from "./api.js";
+export declare const STORAGE: StorageRegistry;
+//# sourceMappingURL=storage.d.ts.map

package/storage.js

@@ -0,0 +1,32 @@
+import {} from "@thi.ng/api";
+import { always } from "@thi.ng/api/fn";
+import { typedArray, TYPEDARRAY_CTORS } from "@thi.ng/api/typedarray";
+const impl = (type) => ({
+  alloc: (size) => typedArray(type, size),
+  from: (iter) => TYPEDARRAY_CTORS[type].from(iter),
+  release: always
+});
+const STORAGE = {
+  u8: impl("u8"),
+  u8c: impl("u8c"),
+  i8: impl("i8"),
+  u16: impl("u16"),
+  i16: impl("i16"),
+  u32: impl("u32"),
+  i32: impl("i32"),
+  f32: impl("f32"),
+  f64: impl("f64"),
+  num: {
+    alloc: (size) => new Array(size).fill(0),
+    from: (iter) => [...iter],
+    release: always
+  },
+  str: {
+    alloc: (size) => new Array(size).fill(""),
+    from: (iter) => [...iter],
+    release: always
+  }
+};
+export {
+  STORAGE
+};

package/sub.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Componentwise nD tensor subtraction. 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 sub: import("./api.js").MultiTensorOpTT<number>;
+/**
+ * Same as {@link sub} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const sub1: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link sub} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const sub2: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link sub} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const sub3: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link sub} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const sub4: import("./api.js").TensorOpTT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=sub.d.ts.map

package/sub.js

@@ -0,0 +1,15 @@
+import { $sub } from "@thi.ng/vectors/ops";
+import { defOpTT } from "./defoptt.js";
+const [a, b, c, d, e] = defOpTT($sub);
+const sub = a;
+const sub1 = b;
+const sub2 = c;
+const sub3 = d;
+const sub4 = e;
+export {
+  sub,
+  sub1,
+  sub2,
+  sub3,
+  sub4
+};