@danielsimonjr/mathts-tensor 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Tensor — rank-N, Float64Array-backed, row-major dense tensor. The
+ * compute primitive behind @danielsimonjr/mathts-tensor. Construction +
+ * elementwise here; einsum / matMul / transpose / reshape in the same
+ * file, added by the next task.
+ *
+ * Naive O(n) algorithms — a correctness baseline. Mirrors the storage
+ * pattern of DenseMatrix (Float64Array, row-major) but generalised to
+ * arbitrary rank, filling the `Matrix<T>` base class's documented
+ * "generic template for future rank-N support".
+ */
+type NestedArray = number | NestedArray[];
+interface EinsumSpec {
+    readonly contractions: ReadonlyArray<{
+        readonly pair: readonly [readonly [number, number], readonly [number, number]];
+    }>;
+    readonly free: ReadonlyArray<{
+        readonly operand: number;
+        readonly axis: number;
+    }>;
+}
+declare class Tensor {
+    readonly shape: ReadonlyArray<number>;
+    readonly data: Float64Array;
+    constructor(shape: ReadonlyArray<number>, data: Float64Array);
+    static sizeOf(shape: ReadonlyArray<number>): number;
+    static rowMajorStrides(shape: ReadonlyArray<number>): number[];
+    static fromNested(data: NestedArray, shape: ReadonlyArray<number>): Tensor;
+    static identity(n: number): Tensor;
+    toNested(): NestedArray;
+    private sameShape;
+    private elementwise;
+    add(other: Tensor): Tensor;
+    sub(other: Tensor): Tensor;
+    mul(other: Tensor): Tensor;
+    scale(k: number): Tensor;
+    normInf(): number;
+    private static forEachIndex;
+    private static flatIndex;
+    reshape(shape: ReadonlyArray<number>): Tensor;
+    transpose(perm?: ReadonlyArray<number>): Tensor;
+    matMul(other: Tensor): Tensor;
+    static einsum(spec: EinsumSpec, ...operands: Tensor[]): Tensor;
+}
+
+export { type EinsumSpec, type NestedArray, Tensor };

package/dist/index.js

@@ -0,0 +1,217 @@
+// src/Tensor.ts
+var Tensor = class _Tensor {
+  shape;
+  data;
+  constructor(shape, data) {
+    if (data.length !== _Tensor.sizeOf(shape)) {
+      throw new Error(`Tensor: data length ${data.length} does not match shape [${shape}] (size ${_Tensor.sizeOf(shape)})`);
+    }
+    this.shape = shape;
+    this.data = data;
+  }
+  static sizeOf(shape) {
+    return shape.reduce((a, b) => a * b, 1);
+  }
+  static rowMajorStrides(shape) {
+    const strides = new Array(shape.length);
+    let acc = 1;
+    for (let k = shape.length - 1; k >= 0; k--) {
+      strides[k] = acc;
+      acc *= shape[k];
+    }
+    return strides;
+  }
+  static fromNested(data, shape) {
+    const size = _Tensor.sizeOf(shape);
+    const out = new Float64Array(size);
+    let cursor = 0;
+    const walk = (node, depth) => {
+      if (depth === shape.length) {
+        if (typeof node !== "number") {
+          throw new Error(`Tensor.fromNested: expected a number at depth ${depth}`);
+        }
+        out[cursor++] = node;
+        return;
+      }
+      if (!Array.isArray(node) || node.length !== shape[depth]) {
+        throw new Error(`Tensor.fromNested: shape mismatch at depth ${depth}`);
+      }
+      for (const child of node) walk(child, depth + 1);
+    };
+    walk(data, 0);
+    if (cursor !== size) throw new Error(`Tensor.fromNested: filled ${cursor} of ${size}`);
+    return new _Tensor([...shape], out);
+  }
+  static identity(n) {
+    const out = new Float64Array(n * n);
+    for (let i = 0; i < n; i++) out[i * n + i] = 1;
+    return new _Tensor([n, n], out);
+  }
+  toNested() {
+    if (this.shape.length === 0) return this.data[0];
+    const strides = _Tensor.rowMajorStrides(this.shape);
+    const build = (depth, offset) => {
+      if (depth === this.shape.length - 1) {
+        const row = [];
+        for (let i = 0; i < this.shape[depth]; i++) row.push(this.data[offset + i]);
+        return row;
+      }
+      const out = [];
+      for (let i = 0; i < this.shape[depth]; i++) {
+        out.push(build(depth + 1, offset + i * strides[depth]));
+      }
+      return out;
+    };
+    return build(0, 0);
+  }
+  sameShape(other) {
+    return this.shape.length === other.shape.length && this.shape.every((v, i) => v === other.shape[i]);
+  }
+  elementwise(other, op, f) {
+    if (!this.sameShape(other)) {
+      throw new Error(`Tensor.${op}: shape mismatch [${this.shape}] vs [${other.shape}]`);
+    }
+    const out = new Float64Array(this.data.length);
+    for (let i = 0; i < this.data.length; i++) out[i] = f(this.data[i], other.data[i]);
+    return new _Tensor(this.shape, out);
+  }
+  add(other) {
+    return this.elementwise(other, "add", (x, y) => x + y);
+  }
+  sub(other) {
+    return this.elementwise(other, "sub", (x, y) => x - y);
+  }
+  mul(other) {
+    return this.elementwise(other, "mul", (x, y) => x * y);
+  }
+  scale(k) {
+    const out = new Float64Array(this.data.length);
+    for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] * k;
+    return new _Tensor(this.shape, out);
+  }
+  normInf() {
+    let max = 0;
+    for (let i = 0; i < this.data.length; i++) {
+      const a = Math.abs(this.data[i]);
+      if (a > max) max = a;
+    }
+    return max;
+  }
+  static forEachIndex(shape, visit) {
+    if (shape.length === 0) {
+      visit([]);
+      return;
+    }
+    const idx = new Array(shape.length).fill(0);
+    const total = _Tensor.sizeOf(shape);
+    for (let n = 0; n < total; n++) {
+      visit(idx);
+      for (let k = shape.length - 1; k >= 0; k--) {
+        if (++idx[k] < shape[k]) break;
+        idx[k] = 0;
+      }
+    }
+  }
+  static flatIndex(idx, strides) {
+    let f = 0;
+    for (let k = 0; k < idx.length; k++) f += idx[k] * strides[k];
+    return f;
+  }
+  reshape(shape) {
+    if (_Tensor.sizeOf(shape) !== this.data.length) {
+      throw new Error(`Tensor.reshape: size mismatch [${this.shape}] -> [${shape}]`);
+    }
+    return new _Tensor([...shape], this.data.slice());
+  }
+  transpose(perm) {
+    const rank = this.shape.length;
+    const p = perm ?? Array.from({ length: rank }, (_, i) => rank - 1 - i);
+    if (p.length !== rank) throw new Error(`Tensor.transpose: perm length ${p.length} != rank ${rank}`);
+    const outShape = p.map((axis) => this.shape[axis]);
+    const inStrides = _Tensor.rowMajorStrides(this.shape);
+    const outStrides = _Tensor.rowMajorStrides(outShape);
+    const out = new Float64Array(this.data.length);
+    _Tensor.forEachIndex(outShape, (outIdx) => {
+      const inIdx = new Array(rank);
+      for (let k = 0; k < rank; k++) inIdx[p[k]] = outIdx[k];
+      out[_Tensor.flatIndex(outIdx, outStrides)] = this.data[_Tensor.flatIndex(inIdx, inStrides)];
+    });
+    return new _Tensor(outShape, out);
+  }
+  matMul(other) {
+    if (this.shape.length !== 2 || other.shape.length !== 2) {
+      throw new Error(`Tensor.matMul: both operands must be rank-2`);
+    }
+    const [m, k] = this.shape;
+    const [k2, n] = other.shape;
+    if (k !== k2) throw new Error(`Tensor.matMul: inner dimension mismatch ${k} != ${k2}`);
+    const out = new Float64Array(m * n);
+    for (let i = 0; i < m; i++) {
+      for (let j = 0; j < n; j++) {
+        let sum = 0;
+        for (let q = 0; q < k; q++) sum += this.data[i * k + q] * other.data[q * n + j];
+        out[i * n + j] = sum;
+      }
+    }
+    return new _Tensor([m, n], out);
+  }
+  static einsum(spec, ...operands) {
+    const inStrides = operands.map((o) => _Tensor.rowMajorStrides(o.shape));
+    const freeSizes = spec.free.map((fa) => operands[fa.operand].shape[fa.axis]);
+    const contractSizes = spec.contractions.map((c) => {
+      const [[oa, axa], [ob, axb]] = c.pair;
+      const sa = operands[oa]?.shape[axa];
+      const sb = operands[ob]?.shape[axb];
+      if (sa === void 0 || sb === void 0 || sa !== sb) {
+        throw new Error(`Tensor.einsum: contraction pair size mismatch`);
+      }
+      return sa;
+    });
+    const outStrides = _Tensor.rowMajorStrides(freeSizes);
+    const out = new Float64Array(_Tensor.sizeOf(freeSizes));
+    for (let o = 0; o < operands.length; o++) {
+      if (operands[o].shape.length === 0) continue;
+      const covered = /* @__PURE__ */ new Set();
+      spec.free.forEach((fa) => {
+        if (fa.operand === o) covered.add(fa.axis);
+      });
+      spec.contractions.forEach((c) => {
+        const [[oa, axa], [ob, axb]] = c.pair;
+        if (oa === o) covered.add(axa);
+        if (ob === o) covered.add(axb);
+      });
+      if (covered.size !== operands[o].shape.length) {
+        throw new Error(
+          `Tensor.einsum: operand ${o} has axes not referenced by the spec`
+        );
+      }
+    }
+    const operandFlatIndex = (opIndex, freeVals, contractVals) => {
+      const idx = new Array(operands[opIndex].shape.length).fill(0);
+      spec.free.forEach((fa, v) => {
+        if (fa.operand === opIndex) idx[fa.axis] = freeVals[v];
+      });
+      spec.contractions.forEach((c, v) => {
+        const [[oa, axa], [ob, axb]] = c.pair;
+        if (oa === opIndex) idx[axa] = contractVals[v];
+        if (ob === opIndex) idx[axb] = contractVals[v];
+      });
+      return _Tensor.flatIndex(idx, inStrides[opIndex]);
+    };
+    _Tensor.forEachIndex(freeSizes, (freeVals) => {
+      let acc = 0;
+      _Tensor.forEachIndex(contractSizes, (contractVals) => {
+        let product = 1;
+        for (let o = 0; o < operands.length; o++) {
+          product *= operands[o].data[operandFlatIndex(o, freeVals, contractVals)];
+        }
+        acc += product;
+      });
+      out[_Tensor.flatIndex(freeVals, outStrides)] = acc;
+    });
+    return new _Tensor(freeSizes, out);
+  }
+};
+export {
+  Tensor
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@danielsimonjr/mathts-tensor",
+  "version": "0.1.0",
+  "description": "Rank-N dense Tensor type for MathTS with Float64Array-backed storage",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "tensor"
+  },
+  "keywords": [
+    "math",
+    "tensor",
+    "linear-algebra",
+    "typescript"
+  ]
+}