@thi.ng/tensors 0.1.0

package/tensor.js

@@ -0,0 +1,517 @@
+import { swizzle } from "@thi.ng/arrays/swizzle";
+import { isNumber } from "@thi.ng/checks/is-number";
+import { equiv, equivArrayLike } from "@thi.ng/equiv";
+import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
+import { outOfBounds } from "@thi.ng/errors/out-of-bounds";
+import { unsupported } from "@thi.ng/errors/unsupported";
+import { dot2, dot3, dot4 } from "@thi.ng/vectors/dot";
+import { eqDeltaS as _eqDelta } from "@thi.ng/vectors/eqdelta";
+import { product, product2, product3, product4 } from "@thi.ng/vectors/product";
+import { illegalShape } from "./errors.js";
+import { format } from "./format.js";
+import { STORAGE } from "./storage.js";
+const { abs, ceil, min } = Math;
+class ATensor {
+  constructor(type, storage, data, shape, stride, offset = 0) {
+    this.type = type;
+    this.storage = storage;
+    this.data = data;
+    this.shape = shape;
+    this.stride = stride;
+    this.offset = offset;
+  }
+  get order() {
+    return strideOrder(this.stride);
+  }
+  get orderedShape() {
+    return swizzle(this.order)(this.shape);
+  }
+  get orderedStride() {
+    return swizzle(this.order)(this.stride);
+  }
+  copy() {
+    return new this.constructor(
+      this.type,
+      this.storage,
+      this.data,
+      this.shape.slice(),
+      this.stride.slice(),
+      this.offset
+    );
+  }
+  empty(storage = this.storage) {
+    return new this.constructor(
+      this.type,
+      storage,
+      storage.alloc(this.length),
+      this.shape.slice(),
+      shapeToStride(this.shape)
+    );
+  }
+  equiv(o) {
+    return this === o || o instanceof ATensor && equiv(this.shape, o.shape) && equivArrayLike([...this], [...o]);
+  }
+  eqDelta(o, eps = 1e-6) {
+    return this === o || equiv(this.shape, o.shape) && _eqDelta([...this], [...o], this.length, eps);
+  }
+  hi(pos) {
+    return new this.constructor(
+      this.type,
+      this.storage,
+      this.data,
+      __hi(pos, this),
+      this.stride,
+      this.offset
+    );
+  }
+  lo(pos) {
+    const { shape, offset } = __lo(pos, this);
+    return new this.constructor(
+      this.type,
+      this.storage,
+      this.data,
+      shape,
+      this.stride,
+      offset
+    );
+  }
+  step(select) {
+    const { shape, stride, offset } = __step(select, this);
+    return new this.constructor(
+      this.type,
+      this.storage,
+      this.data,
+      shape,
+      stride,
+      offset
+    );
+  }
+  pick(select) {
+    const { shape, stride, offset } = __pick(select, this);
+    return tensor(this.type, shape, {
+      data: this.data,
+      storage: this.storage,
+      copy: false,
+      stride,
+      offset
+    });
+  }
+  pack(storage = this.storage) {
+    return new this.constructor(
+      this.type,
+      storage,
+      storage.from(this),
+      this.shape.slice(),
+      shapeToStride(this.shape)
+    );
+  }
+  reshape(newShape, newStride) {
+    const newLength = product(newShape);
+    if (newLength !== this.length) illegalShape(newShape);
+    return tensor(this.type, newShape, {
+      storage: this.storage,
+      data: this.data,
+      copy: false,
+      stride: newStride ?? shapeToStride(newShape),
+      offset: this.offset
+    });
+  }
+  transpose(order) {
+    const reorder = swizzle(order);
+    return new this.constructor(
+      this.type,
+      this.storage,
+      this.data,
+      reorder(this.shape),
+      reorder(this.stride),
+      this.offset
+    );
+  }
+  toJSON() {
+    return {
+      buf: [...this],
+      shape: this.shape,
+      stride: shapeToStride(this.shape)
+    };
+  }
+}
+class Tensor1 extends ATensor {
+  *[Symbol.iterator]() {
+    let {
+      data,
+      length,
+      stride: [tx],
+      offset
+    } = this;
+    for (; length-- > 0; offset += tx) yield data[offset];
+  }
+  get dim() {
+    return 1;
+  }
+  get order() {
+    return [0];
+  }
+  get length() {
+    return this.shape[0];
+  }
+  index([x]) {
+    return this.offset + x * this.stride[0];
+  }
+  get([x]) {
+    return this.data[this.offset + x * this.stride[0]];
+  }
+  set([x], v) {
+    this.data[this.offset + x * this.stride[0]] = v;
+    return this;
+  }
+  pick([x]) {
+    if (x < 0 && x >= this.length) outOfBounds(x);
+    return new Tensor1(
+      this.type,
+      this.storage,
+      this.data,
+      [1],
+      [1],
+      this.offset + x * this.stride[0]
+    );
+  }
+  resize(newShape, fill, storage = this.storage) {
+    const newLength = product(newShape);
+    const newData = storage.alloc(newLength);
+    if (fill !== void 0) newData.fill(fill);
+    const {
+      data,
+      shape: [sx],
+      stride: [tx]
+    } = this;
+    const n = min(sx, newLength);
+    for (let i = this.offset, ii = 0, x = 0; x < sx && ii < n; x++, i += tx, ii++) {
+      newData[ii] = data[i];
+    }
+    return tensor(this.type, newShape, {
+      storage,
+      data: newData,
+      copy: false
+    });
+  }
+  transpose(_) {
+    return this.copy();
+  }
+  toString() {
+    const res = [];
+    for (let x of this) res.push(format(x));
+    return res.join(" ");
+  }
+}
+class Tensor2 extends ATensor {
+  _n;
+  *[Symbol.iterator]() {
+    const {
+      data,
+      shape: [sx, sy],
+      stride: [tx, ty]
+    } = this;
+    for (let ox = this.offset, x = 0; x < sx; x++, ox += tx) {
+      for (let y = 0; y < sy; y++) {
+        yield data[ox + y * ty];
+      }
+    }
+  }
+  get length() {
+    return this._n || (this._n = product2(this.shape));
+  }
+  get dim() {
+    return 2;
+  }
+  get order() {
+    return abs(this.stride[1]) > abs(this.stride[0]) ? [1, 0] : [0, 1];
+  }
+  index(pos) {
+    return this.offset + dot2(pos, this.stride);
+  }
+  get(pos) {
+    return this.data[this.offset + dot2(pos, this.stride)];
+  }
+  set(pos, v) {
+    this.data[this.offset + dot2(pos, this.stride)] = v;
+    return this;
+  }
+  resize(newShape, fill, storage = this.storage) {
+    const newLength = product(newShape);
+    const newData = storage.alloc(newLength);
+    if (fill !== void 0) newData.fill(fill);
+    const {
+      data,
+      shape: [sx, sy],
+      stride: [tx, ty]
+    } = this;
+    const n = min(this.length, newLength);
+    for (let ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
+      for (let y = 0; y < sy && i < n; y++, i++) {
+        newData[i] = data[ox + y * ty];
+      }
+    }
+    return tensor(this.type, newShape, {
+      storage,
+      data: newData,
+      copy: false
+    });
+  }
+  toString() {
+    const res = [];
+    for (let i = 0; i < this.shape[0]; i++) {
+      res.push(this.pick([i]).toString());
+    }
+    return res.join("\n");
+  }
+}
+class Tensor3 extends ATensor {
+  _n;
+  *[Symbol.iterator]() {
+    const {
+      data,
+      shape: [sx, sy, sz],
+      stride: [tx, ty, tz]
+    } = this;
+    for (let ox = this.offset, x = 0; x < sx; x++, ox += tx) {
+      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (let z = 0; z < sz; z++) {
+          yield data[oy + z * tz];
+        }
+      }
+    }
+  }
+  get length() {
+    return this._n || (this._n = product3(this.shape));
+  }
+  get dim() {
+    return 3;
+  }
+  index(pos) {
+    return this.offset + dot3(pos, this.stride);
+  }
+  get(pos) {
+    return this.data[this.offset + dot3(pos, this.stride)];
+  }
+  set(pos, v) {
+    this.data[this.offset + dot3(pos, this.stride)] = v;
+    return this;
+  }
+  resize(newShape, fill, storage = this.storage) {
+    const newLength = product(newShape);
+    const newData = storage.alloc(newLength);
+    if (fill !== void 0) newData.fill(fill);
+    const {
+      data,
+      shape: [sx, sy, sz],
+      stride: [tx, ty, tz]
+    } = this;
+    const n = min(this.length, newLength);
+    for (let ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
+      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (let z = 0; z < sz && i < n; z++, i++) {
+          newData[i] = data[oy + z * tz];
+        }
+      }
+    }
+    return tensor(this.type, newShape, {
+      storage,
+      data: newData,
+      copy: false
+    });
+  }
+  toString() {
+    const res = [];
+    for (let i = 0; i < this.shape[0]; i++) {
+      res.push(`--- ${i}: ---`, this.pick([i]).toString());
+    }
+    return res.join("\n");
+  }
+}
+class Tensor4 extends ATensor {
+  _n;
+  *[Symbol.iterator]() {
+    const {
+      data,
+      shape: [sx, sy, sz, sw],
+      stride: [tx, ty, tz, tw],
+      offset
+    } = this;
+    for (let ox = offset, x = 0; x < sx; x++, ox += tx) {
+      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (let oz = oy, z = 0; z < sz; z++, oz += tz) {
+          for (let w = 0; w < sw; w++) {
+            yield data[oz + w * tw];
+          }
+        }
+      }
+    }
+  }
+  get length() {
+    return this._n || (this._n = product4(this.shape));
+  }
+  get dim() {
+    return 4;
+  }
+  index(pos) {
+    return this.offset + dot4(pos, this.stride);
+  }
+  get(pos) {
+    return this.data[this.offset + dot4(pos, this.stride)];
+  }
+  set(pos, v) {
+    this.data[this.offset + dot4(pos, this.stride)] = v;
+    return this;
+  }
+  resize(newShape, fill, storage = this.storage) {
+    const newLength = product(newShape);
+    const newData = storage.alloc(newLength);
+    if (fill !== void 0) newData.fill(fill);
+    const {
+      data,
+      shape: [sx, sy, sz, sw],
+      stride: [tx, ty, tz, tw]
+    } = this;
+    const n = min(this.length, newLength);
+    for (let ox = this.offset, i = 0, x = 0; x < sx; x++, ox += tx) {
+      for (let oy = ox, y = 0; y < sy; y++, oy += ty) {
+        for (let oz = oy, z = 0; z < sz; z++, oz += tz) {
+          for (let w = 0; w < sw && i < n; w++, i++) {
+            newData[i] = data[oz + w * tw];
+          }
+        }
+      }
+    }
+    return tensor(this.type, newShape, {
+      storage,
+      data: newData,
+      copy: false
+    });
+  }
+  toString() {
+    const res = [];
+    for (let i = 0; i < this.shape[0]; i++) {
+      res.push(`--- cube ${i}: ---`, this.pick([i]).toString());
+    }
+    return res.join("\n");
+  }
+}
+const TENSOR_IMPLS = [
+  void 0,
+  Tensor1,
+  Tensor2,
+  Tensor3,
+  Tensor4
+];
+function tensor(...args) {
+  if (Array.isArray(args[0])) return tensorFromArray(args[0], args[1]);
+  const type = args[0];
+  const shape = args[1];
+  const opts = args[2];
+  const storage = opts?.storage ?? STORAGE[type];
+  const stride = opts?.stride ?? shapeToStride(shape);
+  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];
+      }
+    }
+  }
+  const ctor = TENSOR_IMPLS[shape.length];
+  return ctor ? new ctor(type, storage, data, shape, stride, offset) : unsupported(`unsupported dimension: ${shape.length}`);
+}
+function tensorFromArray(data, opts) {
+  const shape = [data.length];
+  let $data = data;
+  while (Array.isArray($data[0])) {
+    shape.push($data[0].length);
+    $data = $data.flat();
+  }
+  const $type = opts?.type ?? (isNumber($data[0]) ? "num" : "str");
+  if ($type === "str" && isNumber($data[0]))
+    illegalArgs("mismatched data type");
+  return tensor($type, shape, {
+    data: $data,
+    copy: $type !== "num" && $type !== "str",
+    storage: opts?.storage
+  });
+}
+const shapeToStride = (shape) => {
+  const n = shape.length;
+  const stride = new Array(n);
+  for (let i = n, s = 1; i-- > 0; s *= shape[i]) {
+    stride[i] = s;
+  }
+  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 __lo = (select, { shape, stride, offset }) => {
+  const newShape = [];
+  for (let i = 0, n = shape.length; i < n; i++) {
+    const x = select[i];
+    newShape.push(
+      x >= 0 ? (offset += stride[i] * x, shape[i] - x) : shape[i]
+    );
+  }
+  return { shape: newShape, offset };
+};
+const __hi = (select, { shape }) => {
+  const newShape = [];
+  for (let i = 0, n = shape.length; i < n; i++) {
+    const x = select[i];
+    newShape.push(x > 0 ? x : shape[i]);
+  }
+  return newShape;
+};
+const __step = (select, { shape, stride, offset }) => {
+  const newShape = shape.slice();
+  const newStride = stride.slice();
+  for (let i = 0, n = shape.length; i < n; i++) {
+    const x = select[i];
+    if (x) {
+      if (x < 0) {
+        offset += stride[i] * (shape[i] - 1);
+        newShape[i] = ceil(-shape[i] / x);
+      } else {
+        newShape[i] = ceil(shape[i] / x);
+      }
+      newStride[i] *= x;
+    }
+  }
+  return { shape: newShape, stride: newStride, offset };
+};
+const __pick = (select, { shape, stride, offset }) => {
+  const newShape = [];
+  const newStride = [];
+  for (let i = 0, n = shape.length; i < n; i++) {
+    const x = select[i];
+    if (x >= 0) {
+      offset += stride[i] * x;
+    } else {
+      newShape.push(shape[i]);
+      newStride.push(stride[i]);
+    }
+  }
+  return { shape: newShape, stride: newStride, offset };
+};
+export {
+  ATensor,
+  TENSOR_IMPLS,
+  Tensor1,
+  Tensor2,
+  Tensor3,
+  Tensor4,
+  shapeToStride,
+  strideOrder,
+  tensor,
+  tensorFromArray
+};

package/top.d.ts

@@ -0,0 +1,16 @@
+import type { Maybe } from "@thi.ng/api";
+/**
+ * Specialized / optimized version of
+ * [`thi.ng/defmulti`](https://thi.ng/defmulti) for tensor operations. Uses
+ * simplified logic to dispatch on tensor dimension ({@link ITensor.dim}) of
+ * `dispatch` argument.
+ *
+ * @param dispatch - arg index (default: 1)
+ */
+export declare const top: <T extends Function>(dispatch?: number, fallback?: T, ...optimized: Maybe<T>[]) => {
+    (...args: any[]): any;
+    add(dim: number, fn: T): T;
+    default(fn: T): T;
+    impl(dim?: number): Maybe<T>;
+};
+//# sourceMappingURL=top.d.ts.map

package/top.js

@@ -0,0 +1,15 @@
+import { unsupported } from "@thi.ng/errors/unsupported";
+const top = (dispatch = 1, fallback, ...optimized) => {
+  const impls = [void 0].concat(optimized);
+  const fn = (...args) => {
+    const g = impls[args[dispatch].dim] || fallback;
+    return g ? g(...args) : unsupported(`no impl for dimension ${args[dispatch].dim}`);
+  };
+  fn.add = (dim, fn2) => impls[dim] = fn2;
+  fn.default = (fn2) => fallback = fn2;
+  fn.impl = (dim) => dim != null ? impls[dim] || fallback : fallback;
+  return fn;
+};
+export {
+  top
+};