@danielsimonjr/mathts-matrix 0.8.0 → 0.9.0

package/dist/index.js

@@ -2,102 +2,78 @@ import { BufferPool, BufferPool as BufferPool$1, GPUContext, GPUContext as GPUCo
 import { ComputePool, computePool } from "@danielsimonjr/mathts-parallel";
 import { allocAsHeader } from "@danielsimonjr/mathts-core/internal";
 import { mathTyped } from "@danielsimonjr/mathts-core";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res, err) => () => {
-	if (err) throw err[0];
-	try {
-		return fn && (res = fn(fn = 0)), res;
-	} catch (e) {
-		throw err = [e], e;
+//#region src/types/Matrix.ts
+var Matrix = class {
+	get size() {
+		return {
+			rows: this.rows,
+			cols: this.cols
+		};
 	}
-};
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	get isSquare() {
+		return this.rows === this.cols;
+	}
+	get isVector() {
+		return this.rows === 1 || this.cols === 1;
+	}
+	get isRowVector() {
+		return this.rows === 1;
+	}
+	get isColumnVector() {
+		return this.cols === 1;
+	}
+	get length() {
+		return this.rows * this.cols;
+	}
+	checkBounds(row, col) {
+		if (row < 0 || row >= this.rows || col < 0 || col >= this.cols) throw new RangeError(`Index (${row}, ${col}) out of bounds for matrix of size ${this.rows}×${this.cols}`);
+	}
+	checkDimensionsMatch(other) {
+		if (this.rows !== other.rows || this.cols !== other.cols) throw new Error(`Matrix dimensions must match: ${this.rows}×${this.cols} vs ${other.rows}×${other.cols}`);
+	}
+	checkMultiplyDimensions(other) {
+		if (this.cols !== other.rows) throw new Error(`Cannot multiply ${this.rows}×${this.cols} matrix with ${other.rows}×${other.cols} matrix`);
+	}
+	toString() {
+		const lines = [];
+		for (let i = 0; i < this.rows; i++) {
+			const rowValues = [];
+			for (let j = 0; j < this.cols; j++) rowValues.push(String(this.get(i, j)));
+			lines.push(`[ ${rowValues.join(", ")} ]`);
+		}
+		return lines.join("\n");
+	}
+	equals(other, tolerance = 0) {
+		if (this.rows !== other.rows || this.cols !== other.cols) return false;
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) {
+			const a = this.get(i, j);
+			const b = other.get(i, j);
+			if (typeof a === "number" && typeof b === "number") {
+				if (Math.abs(a - b) > tolerance) return false;
+			} else if (a !== b) return false;
+		}
+		return true;
 	}
-	return to;
 };
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-//#endregion
-//#region src/types/Matrix.ts
 function isMatrix(value) {
 	return value instanceof Matrix || typeof value === "object" && value !== null && "rows" in value && "cols" in value && "get" in value && typeof value.type === "string";
 }
-var Matrix;
-var init_Matrix = __esmMin((() => {
-	Matrix = class {
-		get size() {
-			return {
-				rows: this.rows,
-				cols: this.cols
-			};
-		}
-		get isSquare() {
-			return this.rows === this.cols;
-		}
-		get isVector() {
-			return this.rows === 1 || this.cols === 1;
-		}
-		get isRowVector() {
-			return this.rows === 1;
-		}
-		get isColumnVector() {
-			return this.cols === 1;
-		}
-		get length() {
-			return this.rows * this.cols;
-		}
-		checkBounds(row, col) {
-			if (row < 0 || row >= this.rows || col < 0 || col >= this.cols) throw new RangeError(`Index (${row}, ${col}) out of bounds for matrix of size ${this.rows}×${this.cols}`);
-		}
-		checkDimensionsMatch(other) {
-			if (this.rows !== other.rows || this.cols !== other.cols) throw new Error(`Matrix dimensions must match: ${this.rows}×${this.cols} vs ${other.rows}×${other.cols}`);
-		}
-		checkMultiplyDimensions(other) {
-			if (this.cols !== other.rows) throw new Error(`Cannot multiply ${this.rows}×${this.cols} matrix with ${other.rows}×${other.cols} matrix`);
-		}
-		toString() {
-			const lines = [];
-			for (let i = 0; i < this.rows; i++) {
-				const rowValues = [];
-				for (let j = 0; j < this.cols; j++) rowValues.push(String(this.get(i, j)));
-				lines.push(`[ ${rowValues.join(", ")} ]`);
-			}
-			return lines.join("\n");
-		}
-		equals(other, tolerance = 0) {
-			if (this.rows !== other.rows || this.cols !== other.cols) return false;
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) {
-				const a = this.get(i, j);
-				const b = other.get(i, j);
-				if (typeof a === "number" && typeof b === "number") {
-					if (Math.abs(a - b) > tolerance) return false;
-				} else if (a !== b) return false;
-			}
-			return true;
-		}
-	};
-}));
+//#endregion
+//#region src/types/dense/storage.ts
+function isDenseStorage(m) {
+	const s = m;
+	return typeof s === "object" && s !== null && s.data instanceof Float64Array && typeof s.isView === "boolean" && typeof s.offset === "number" && typeof s.rowStride === "number" && typeof s.toFlatFloat64Array === "function";
+}
+function contiguousDenseData(matrix) {
+	if (!isDenseStorage(matrix)) return null;
+	if (!matrix.isView && matrix.offset === 0 && matrix.rowStride === matrix.cols) return matrix.data;
+	return matrix.toFlatFloat64Array();
+}
 //#endregion
 //#region src/types/dense/arithmetic.ts
 function flat(m) {
+	const dense = contiguousDenseData(m);
+	if (dense !== null) return dense;
 	const maybe = m;
 	if (typeof maybe.toFloat64Array === "function") return maybe.toFloat64Array();
 	const out = new Float64Array(m.rows * m.cols);
@@ -167,11 +143,15 @@ function transpose$2(a) {
 	}
 	return result;
 }
-var init_arithmetic = __esmMin((() => {}));
 //#endregion
 //#region src/types/dense/reduction.ts
 function sum$1(a) {
 	let total = 0;
+	const d = contiguousDenseData(a);
+	if (d !== null) {
+		for (let i = 0; i < d.length; i++) total += d[i];
+		return total;
+	}
 	for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) total += a.get(i, j);
 	return total;
 }
@@ -180,6 +160,14 @@ function mean$1(a) {
 }
 function min$1(a) {
 	let minVal = Infinity;
+	const d = contiguousDenseData(a);
+	if (d !== null) {
+		for (let i = 0; i < d.length; i++) {
+			const val = d[i];
+			if (val < minVal) minVal = val;
+		}
+		return minVal;
+	}
 	for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) {
 		const val = a.get(i, j);
 		if (val < minVal) minVal = val;
@@ -188,6 +176,14 @@ function min$1(a) {
 }
 function max$1(a) {
 	let maxVal = -Infinity;
+	const d = contiguousDenseData(a);
+	if (d !== null) {
+		for (let i = 0; i < d.length; i++) {
+			const val = d[i];
+			if (val > maxVal) maxVal = val;
+		}
+		return maxVal;
+	}
 	for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) {
 		const val = a.get(i, j);
 		if (val > maxVal) maxVal = val;
@@ -196,6 +192,11 @@ function max$1(a) {
 }
 function norm$1(a) {
 	let sumSquared = 0;
+	const d = contiguousDenseData(a);
+	if (d !== null) {
+		for (let i = 0; i < d.length; i++) sumSquared += d[i] * d[i];
+		return Math.sqrt(sumSquared);
+	}
 	for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) {
 		const val = a.get(i, j);
 		sumSquared += val * val;
@@ -208,729 +209,764 @@ function trace$1(a) {
 	for (let i = 0; i < a.rows; i++) traceSum += a.get(i, i);
 	return traceSum;
 }
-var init_reduction = __esmMin((() => {}));
 //#endregion
-//#region src/types/SparseMatrix.ts
-var SparseMatrix_exports = /* @__PURE__ */ __exportAll({
-	SparseMatrix: () => SparseMatrix,
-	isSparseMatrix: () => isSparseMatrix
-});
-function isSparseMatrix(value) {
-	return value instanceof SparseMatrix;
-}
-var SparseMatrix;
-var init_SparseMatrix = __esmMin((() => {
-	init_Matrix();
-	init_DenseMatrix();
-	SparseMatrix = class SparseMatrix extends Matrix {
-		type = "SparseMatrix";
-		rows;
-		cols;
-		_data;
-		_colIndices;
-		_rowPointers;
-		constructor(rows, cols, values, colIndices, rowPointers) {
-			super();
-			if (rows < 0 || cols < 0) throw new Error("Matrix dimensions must be non-negative");
-			this.rows = rows;
-			this.cols = cols;
-			this._data = values instanceof Float64Array ? values : new Float64Array(values);
-			this._colIndices = colIndices instanceof Int32Array ? colIndices : new Int32Array(colIndices);
-			this._rowPointers = rowPointers instanceof Int32Array ? rowPointers : new Int32Array(rowPointers);
-			if (this._rowPointers.length !== rows + 1) throw new Error(`rowPointers length must be ${rows + 1}, got ${this._rowPointers.length}`);
-			if (this._data.length !== this._colIndices.length) throw new Error("values and colIndices must have same length");
-			if (this._rowPointers[rows] !== this._data.length) throw new Error("rowPointers[rows] must equal number of non-zeros");
-		}
-		static fromDense(dense, dropTolerance = 0) {
-			const values = [];
-			const colIndices = [];
-			const rowPointers = [0];
-			for (let i = 0; i < dense.rows; i++) {
-				for (let j = 0; j < dense.cols; j++) {
-					const val = dense.get(i, j);
-					if (Math.abs(val) > dropTolerance) {
-						values.push(val);
-						colIndices.push(j);
+//#region src/types/DenseMatrix.ts
+var DenseMatrix = class DenseMatrix extends Matrix {
+	type = "DenseMatrix";
+	rows;
+	cols;
+	data;
+	isView;
+	offset;
+	rowStride;
+	constructor(rows, cols, data, viewConfig) {
+		super();
+		if (!Number.isInteger(rows) || !Number.isInteger(cols)) throw new TypeError(`Matrix dimensions must be integers, got ${String(rows)}×${String(cols)}`);
+		if (rows < 0 || cols < 0) throw new Error("Matrix dimensions must be non-negative");
+		this.rows = rows;
+		this.cols = cols;
+		if (viewConfig) {
+			this.isView = viewConfig.isView;
+			this.offset = viewConfig.offset;
+			this.rowStride = viewConfig.rowStride;
+			this.data = data;
+		} else {
+			this.isView = false;
+			this.offset = 0;
+			this.rowStride = cols;
+			if (data === void 0) this.data = new Float64Array(rows * cols);
+			else if (data instanceof Float64Array) {
+				if (data.length !== rows * cols) throw new Error(`Data length ${data.length} does not match dimensions ${rows}×${cols}`);
+				this.data = data;
+			} else if (Array.isArray(data)) {
+				if (Array.isArray(data[0])) {
+					const nested = data;
+					if (nested.length !== rows) throw new Error(`Expected ${rows} rows, got ${nested.length}`);
+					this.data = new Float64Array(rows * cols);
+					for (let i = 0; i < rows; i++) {
+						if (nested[i].length !== cols) throw new Error(`Row ${i} has ${nested[i].length} elements, expected ${cols}`);
+						for (let j = 0; j < cols; j++) this.data[i * cols + j] = nested[i][j];
 					}
+				} else {
+					const flat = data;
+					if (flat.length !== rows * cols) throw new Error(`Data length ${flat.length} does not match dimensions ${rows}×${cols}`);
+					this.data = new Float64Array(flat);
 				}
-				rowPointers.push(values.length);
-			}
-			return new SparseMatrix(dense.rows, dense.cols, new Float64Array(values), new Int32Array(colIndices), new Int32Array(rowPointers));
+			} else throw new TypeError(`DenseMatrix data must be a Float64Array, number[] or number[][], got ${typeof data}`);
 		}
-		static fromCOO(rows, cols, entries) {
-			const sorted = [...entries].sort((a, b) => {
-				if (a.row !== b.row) return a.row - b.row;
-				return a.col - b.col;
-			});
-			const values = [];
-			const colIndices = [];
-			const rowPointers = new Array(rows + 1).fill(0);
-			for (const entry of sorted) if (entry.value !== 0) rowPointers[entry.row + 1]++;
-			for (let i = 1; i <= rows; i++) rowPointers[i] += rowPointers[i - 1];
-			for (const entry of sorted) if (entry.value !== 0) {
-				values.push(entry.value);
-				colIndices.push(entry.col);
-			}
-			return new SparseMatrix(rows, cols, new Float64Array(values), new Int32Array(colIndices), new Int32Array(rowPointers));
+	}
+	static fromArray(arr) {
+		const rows = arr.length;
+		const cols = arr[0]?.length ?? 0;
+		return new DenseMatrix(rows, cols, arr);
+	}
+	static fromFlat(rows, cols, data) {
+		return new DenseMatrix(rows, cols, data);
+	}
+	static zeros(rows, cols) {
+		return new DenseMatrix(rows, cols);
+	}
+	static ones(rows, cols) {
+		const data = new Float64Array(rows * cols).fill(1);
+		return new DenseMatrix(rows, cols, data);
+	}
+	static identity(n) {
+		const data = new Float64Array(n * n);
+		for (let i = 0; i < n; i++) data[i * n + i] = 1;
+		return new DenseMatrix(n, n, data);
+	}
+	static diag(values) {
+		const n = values.length;
+		const data = new Float64Array(n * n);
+		for (let i = 0; i < n; i++) data[i * n + i] = values[i];
+		return new DenseMatrix(n, n, data);
+	}
+	static fill(rows, cols, value) {
+		const data = new Float64Array(rows * cols).fill(value);
+		return new DenseMatrix(rows, cols, data);
+	}
+	static random(rows, cols) {
+		const data = new Float64Array(rows * cols);
+		for (let i = 0; i < data.length; i++) data[i] = Math.random();
+		return new DenseMatrix(rows, cols, data);
+	}
+	get(row, col) {
+		this.checkBounds(row, col);
+		return this.data[this.offset + row * this.rowStride + col];
+	}
+	set(row, col, value) {
+		this.checkBounds(row, col);
+		const newData = this.toFlatFloat64Array();
+		newData[row * this.cols + col] = value;
+		return new DenseMatrix(this.rows, this.cols, newData);
+	}
+	toFlatFloat64Array() {
+		if (!this.isView && this.offset === 0 && this.rowStride === this.cols) return new Float64Array(this.data);
+		const result = new Float64Array(this.rows * this.cols);
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) result[i * this.cols + j] = this.data[this.offset + i * this.rowStride + j];
+		return result;
+	}
+	row(index) {
+		if (index < 0 || index >= this.rows) throw new RangeError(`Row index ${index} out of bounds for matrix with ${this.rows} rows`);
+		return new DenseMatrix(1, this.cols, this.data, {
+			isView: true,
+			offset: this.offset + index * this.rowStride,
+			rowStride: this.rowStride
+		});
+	}
+	column(index) {
+		if (index < 0 || index >= this.cols) throw new RangeError(`Column index ${index} out of bounds for matrix with ${this.cols} columns`);
+		const data = new Float64Array(this.rows);
+		for (let i = 0; i < this.rows; i++) data[i] = this.get(i, index);
+		return new DenseMatrix(this.rows, 1, data);
+	}
+	slice(spec) {
+		const rowStart = spec.rowStart ?? 0;
+		const rowEnd = spec.rowEnd ?? this.rows;
+		const colStart = spec.colStart ?? 0;
+		const colEnd = spec.colEnd ?? this.cols;
+		if (rowStart < 0 || rowEnd > this.rows || colStart < 0 || colEnd > this.cols) throw new RangeError("Slice indices out of bounds");
+		if (rowStart >= rowEnd || colStart >= colEnd) throw new Error("Invalid slice: start must be less than end");
+		const newRows = rowEnd - rowStart;
+		const newCols = colEnd - colStart;
+		if (colStart === 0 && colEnd === this.cols) return new DenseMatrix(newRows, newCols, this.data, {
+			isView: true,
+			offset: this.offset + rowStart * this.rowStride,
+			rowStride: this.rowStride
+		});
+		const data = new Float64Array(newRows * newCols);
+		for (let i = 0; i < newRows; i++) for (let j = 0; j < newCols; j++) data[i * newCols + j] = this.get(rowStart + i, colStart + j);
+		return new DenseMatrix(newRows, newCols, data);
+	}
+	diagonal(k = 0) {
+		const diagLength = Math.min(this.rows - Math.max(0, -k), this.cols - Math.max(0, k));
+		if (diagLength <= 0) return new DenseMatrix(0, 1);
+		const data = new Float64Array(diagLength);
+		const rowOffset = Math.max(0, -k);
+		const colOffset = Math.max(0, k);
+		for (let i = 0; i < diagLength; i++) data[i] = this.get(rowOffset + i, colOffset + i);
+		return new DenseMatrix(diagLength, 1, data);
+	}
+	add(other) {
+		this.checkDimensionsMatch(other);
+		return new DenseMatrix(this.rows, this.cols, add$1(this, other));
+	}
+	subtract(other) {
+		this.checkDimensionsMatch(other);
+		return new DenseMatrix(this.rows, this.cols, subtract$1(this, other));
+	}
+	multiplyElementwise(other) {
+		this.checkDimensionsMatch(other);
+		return new DenseMatrix(this.rows, this.cols, multiplyElementwise(this, other));
+	}
+	multiply(other) {
+		this.checkMultiplyDimensions(other);
+		return new DenseMatrix(this.rows, other.cols, multiply$1(this, other));
+	}
+	scale(scalar) {
+		return new DenseMatrix(this.rows, this.cols, scale(this, scalar));
+	}
+	transpose() {
+		return new DenseMatrix(this.cols, this.rows, transpose$2(this));
+	}
+	negate() {
+		return this.scale(-1);
+	}
+	sum() {
+		return sum$1(this);
+	}
+	mean() {
+		return mean$1(this);
+	}
+	min() {
+		return min$1(this);
+	}
+	max() {
+		return max$1(this);
+	}
+	norm() {
+		return norm$1(this);
+	}
+	trace() {
+		return trace$1(this);
+	}
+	toArray() {
+		const result = [];
+		for (let i = 0; i < this.rows; i++) {
+			result[i] = [];
+			for (let j = 0; j < this.cols; j++) result[i][j] = this.get(i, j);
 		}
-		static zeros(rows, cols) {
-			return new SparseMatrix(rows, cols, /* @__PURE__ */ new Float64Array(0), /* @__PURE__ */ new Int32Array(0), new Int32Array(rows + 1).fill(0));
+		return result;
+	}
+	toFlatArray() {
+		return Array.from(this.toFlatFloat64Array());
+	}
+	toFloat64Array() {
+		return this.toFlatFloat64Array();
+	}
+	clone() {
+		return new DenseMatrix(this.rows, this.cols, this.toFlatFloat64Array());
+	}
+	toSparse(dropTolerance = 0) {
+		const values = [];
+		const colIndices = [];
+		const rowPointers = [0];
+		for (let i = 0; i < this.rows; i++) {
+			for (let j = 0; j < this.cols; j++) {
+				const val = this.get(i, j);
+				if (Math.abs(val) > dropTolerance) {
+					values.push(val);
+					colIndices.push(j);
+				}
+			}
+			rowPointers.push(values.length);
 		}
-		static identity(n) {
-			const values = new Float64Array(n).fill(1);
-			const colIndices = new Int32Array(n);
-			const rowPointers = new Int32Array(n + 1);
-			for (let i = 0; i < n; i++) {
-				colIndices[i] = i;
-				rowPointers[i] = i;
+		if (sparseMatrixFactory === void 0) throw new Error("DenseMatrix.toSparse: SparseMatrix is not loaded; import it from @danielsimonjr/mathts-matrix");
+		return sparseMatrixFactory(this.rows, this.cols, new Float64Array(values), new Int32Array(colIndices), new Int32Array(rowPointers));
+	}
+	*entries() {
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) yield {
+			row: i,
+			col: j,
+			value: this.get(i, j)
+		};
+	}
+	*values() {
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) yield this.get(i, j);
+	}
+	[Symbol.iterator]() {
+		return this.values();
+	}
+	map(fn) {
+		const result = new Float64Array(this.rows * this.cols);
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) result[i * this.cols + j] = fn(this.get(i, j), i, j);
+		return new DenseMatrix(this.rows, this.cols, result);
+	}
+	forEach(fn) {
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) fn(this.get(i, j), i, j);
+	}
+};
+function isDenseMatrix(value) {
+	return value instanceof DenseMatrix;
+}
+let sparseMatrixFactory;
+function registerSparseMatrixFactory(factory) {
+	sparseMatrixFactory = factory;
+}
+function denseContiguousData(matrix) {
+	return contiguousDenseData(matrix) ?? matrix.toFloat64Array();
+}
+//#endregion
+//#region src/types/SparseMatrix.ts
+var SparseMatrix = class SparseMatrix extends Matrix {
+	type = "SparseMatrix";
+	rows;
+	cols;
+	_data;
+	_colIndices;
+	_rowPointers;
+	constructor(rows, cols, values, colIndices, rowPointers) {
+		super();
+		if (!Number.isInteger(rows) || !Number.isInteger(cols)) throw new TypeError(`Matrix dimensions must be integers, got ${String(rows)}×${String(cols)}`);
+		if (rows < 0 || cols < 0) throw new Error("Matrix dimensions must be non-negative");
+		this.rows = rows;
+		this.cols = cols;
+		this._data = values instanceof Float64Array ? values : new Float64Array(values);
+		this._colIndices = colIndices instanceof Int32Array ? colIndices : new Int32Array(colIndices);
+		this._rowPointers = rowPointers instanceof Int32Array ? rowPointers : new Int32Array(rowPointers);
+		if (this._rowPointers.length !== rows + 1) throw new Error(`rowPointers length must be ${rows + 1}, got ${this._rowPointers.length}`);
+		if (this._data.length !== this._colIndices.length) throw new Error("values and colIndices must have same length");
+		if (this._rowPointers[rows] !== this._data.length) throw new Error("rowPointers[rows] must equal number of non-zeros");
+		const rp = this._rowPointers;
+		if (rp[0] !== 0) throw new Error("rowPointers[0] must be 0");
+		for (let i = 0; i < rows; i++) if (rp[i + 1] < rp[i]) throw new Error(`rowPointers must be non-decreasing (violated at row ${i})`);
+		const ci = this._colIndices;
+		for (let k = 0; k < ci.length; k++) {
+			const c = ci[k];
+			if (c < 0 || c >= cols) throw new RangeError(`Column index ${c} at position ${k} out of range for ${cols} columns`);
+		}
+	}
+	static validate(m) {
+		const rp = m._rowPointers;
+		const ci = m._colIndices;
+		if (rp.length !== m.rows + 1) throw new Error(`rowPointers length must be ${m.rows + 1}`);
+		if (rp[0] !== 0) throw new Error("rowPointers[0] must be 0");
+		if (rp[m.rows] !== m._data.length) throw new Error("rowPointers[rows] must equal number of non-zeros");
+		for (let i = 0; i < m.rows; i++) {
+			const start = rp[i];
+			const end = rp[i + 1];
+			if (end < start) throw new Error(`rowPointers must be non-decreasing (violated at row ${i})`);
+			for (let k = start; k < end; k++) {
+				const c = ci[k];
+				if (c < 0 || c >= m.cols) throw new RangeError(`Column index ${c} in row ${i} out of range for ${m.cols} columns`);
+				if (k > start && c <= ci[k - 1]) throw new Error(`Column indices in row ${i} must be strictly increasing`);
 			}
-			rowPointers[n] = n;
-			return new SparseMatrix(n, n, values, colIndices, rowPointers);
 		}
-		static diag(values) {
-			const n = values.length;
-			const vals = new Float64Array(values.filter((v) => v !== 0));
-			const colIndices = [];
-			const rowPointers = [0];
-			let idx = 0;
-			for (let i = 0; i < n; i++) {
-				if (values[i] !== 0) {
-					colIndices.push(i);
-					idx++;
+	}
+	static fromDense(dense, dropTolerance = 0) {
+		const values = [];
+		const colIndices = [];
+		const rowPointers = [0];
+		for (let i = 0; i < dense.rows; i++) {
+			for (let j = 0; j < dense.cols; j++) {
+				const val = dense.get(i, j);
+				if (Math.abs(val) > dropTolerance) {
+					values.push(val);
+					colIndices.push(j);
 				}
-				rowPointers.push(idx);
 			}
-			return new SparseMatrix(n, n, vals, new Int32Array(colIndices), new Int32Array(rowPointers));
-		}
-		get nnz() {
-			return this._data.length;
-		}
-		get sparsity() {
-			const total = this.rows * this.cols;
-			return total === 0 ? 1 : 1 - this.nnz / total;
+			rowPointers.push(values.length);
 		}
-		get density() {
-			return 1 - this.sparsity;
+		return new SparseMatrix(dense.rows, dense.cols, new Float64Array(values), new Int32Array(colIndices), new Int32Array(rowPointers));
+	}
+	static fromCOO(rows, cols, entries) {
+		if (!Number.isInteger(rows) || !Number.isInteger(cols) || rows < 0 || cols < 0) throw new Error(`Invalid matrix dimensions ${String(rows)}×${String(cols)}`);
+		for (const e of entries) {
+			if (!Number.isInteger(e.row) || e.row < 0 || e.row >= rows) throw new RangeError(`COO row index ${e.row} out of range for ${rows} rows`);
+			if (!Number.isInteger(e.col) || e.col < 0 || e.col >= cols) throw new RangeError(`COO column index ${e.col} out of range for ${cols} columns`);
 		}
-		get(row, col) {
-			this.checkBounds(row, col);
-			const start = this._rowPointers[row];
-			const end = this._rowPointers[row + 1];
-			let left = start;
-			let right = end - 1;
-			while (left <= right) {
-				const mid = Math.floor((left + right) / 2);
-				const midCol = this._colIndices[mid];
-				if (midCol === col) return this._data[mid];
-				else if (midCol < col) left = mid + 1;
-				else right = mid - 1;
+		const sorted = [...entries].sort((a, b) => {
+			if (a.row !== b.row) return a.row - b.row;
+			return a.col - b.col;
+		});
+		const values = [];
+		const colIndices = [];
+		const rowPointers = new Array(rows + 1).fill(0);
+		let idx = 0;
+		while (idx < sorted.length) {
+			const { row, col } = sorted[idx];
+			let value = sorted[idx].value;
+			idx++;
+			while (idx < sorted.length && sorted[idx].row === row && sorted[idx].col === col) {
+				value += sorted[idx].value;
+				idx++;
+			}
+			if (value !== 0) {
+				values.push(value);
+				colIndices.push(col);
+				rowPointers[row + 1]++;
 			}
-			return 0;
 		}
-		set(row, col, value) {
-			this.checkBounds(row, col);
-			const start = this._rowPointers[row];
-			const end = this._rowPointers[row + 1];
-			let insertPos = start;
-			let found = false;
-			for (let i = start; i < end; i++) if (this._colIndices[i] === col) {
-				insertPos = i;
-				found = true;
-				break;
-			} else if (this._colIndices[i] > col) {
-				insertPos = i;
-				break;
-			} else insertPos = i + 1;
-			if (found) {
-				if (value === 0) {
-					const newData = new Float64Array(this._data.length - 1);
-					const newColIndices = new Int32Array(this._colIndices.length - 1);
-					const newRowPointers = new Int32Array(this._rowPointers.length);
-					for (let i = 0; i < insertPos; i++) {
-						newData[i] = this._data[i];
-						newColIndices[i] = this._colIndices[i];
-					}
-					for (let i = insertPos + 1; i < this._data.length; i++) {
-						newData[i - 1] = this._data[i];
-						newColIndices[i - 1] = this._colIndices[i];
-					}
-					for (let i = 0; i <= row; i++) newRowPointers[i] = this._rowPointers[i];
-					for (let i = row + 1; i <= this.rows; i++) newRowPointers[i] = this._rowPointers[i] - 1;
-					return new SparseMatrix(this.rows, this.cols, newData, newColIndices, newRowPointers);
-				} else {
-					const newData = new Float64Array(this._data);
-					newData[insertPos] = value;
-					return new SparseMatrix(this.rows, this.cols, newData, this._colIndices, this._rowPointers);
-				}
-			} else {
-				if (value === 0) return this;
-				const newData = new Float64Array(this._data.length + 1);
-				const newColIndices = new Int32Array(this._colIndices.length + 1);
+		for (let i = 1; i <= rows; i++) rowPointers[i] += rowPointers[i - 1];
+		return new SparseMatrix(rows, cols, new Float64Array(values), new Int32Array(colIndices), new Int32Array(rowPointers));
+	}
+	static zeros(rows, cols) {
+		return new SparseMatrix(rows, cols, /* @__PURE__ */ new Float64Array(0), /* @__PURE__ */ new Int32Array(0), new Int32Array(rows + 1).fill(0));
+	}
+	static identity(n) {
+		const values = new Float64Array(n).fill(1);
+		const colIndices = new Int32Array(n);
+		const rowPointers = new Int32Array(n + 1);
+		for (let i = 0; i < n; i++) {
+			colIndices[i] = i;
+			rowPointers[i] = i;
+		}
+		rowPointers[n] = n;
+		return new SparseMatrix(n, n, values, colIndices, rowPointers);
+	}
+	static diag(values) {
+		const n = values.length;
+		const vals = new Float64Array(values.filter((v) => v !== 0));
+		const colIndices = [];
+		const rowPointers = [0];
+		let idx = 0;
+		for (let i = 0; i < n; i++) {
+			if (values[i] !== 0) {
+				colIndices.push(i);
+				idx++;
+			}
+			rowPointers.push(idx);
+		}
+		return new SparseMatrix(n, n, vals, new Int32Array(colIndices), new Int32Array(rowPointers));
+	}
+	get nnz() {
+		return this._data.length;
+	}
+	get sparsity() {
+		const total = this.rows * this.cols;
+		return total === 0 ? 1 : 1 - this.nnz / total;
+	}
+	get density() {
+		return 1 - this.sparsity;
+	}
+	get(row, col) {
+		this.checkBounds(row, col);
+		const start = this._rowPointers[row];
+		const end = this._rowPointers[row + 1];
+		let left = start;
+		let right = end - 1;
+		while (left <= right) {
+			const mid = Math.floor((left + right) / 2);
+			const midCol = this._colIndices[mid];
+			if (midCol === col) return this._data[mid];
+			else if (midCol < col) left = mid + 1;
+			else right = mid - 1;
+		}
+		return 0;
+	}
+	set(row, col, value) {
+		this.checkBounds(row, col);
+		const start = this._rowPointers[row];
+		const end = this._rowPointers[row + 1];
+		let insertPos = start;
+		let found = false;
+		for (let i = start; i < end; i++) if (this._colIndices[i] === col) {
+			insertPos = i;
+			found = true;
+			break;
+		} else if (this._colIndices[i] > col) {
+			insertPos = i;
+			break;
+		} else insertPos = i + 1;
+		if (found) {
+			if (value === 0) {
+				const newData = new Float64Array(this._data.length - 1);
+				const newColIndices = new Int32Array(this._colIndices.length - 1);
 				const newRowPointers = new Int32Array(this._rowPointers.length);
 				for (let i = 0; i < insertPos; i++) {
 					newData[i] = this._data[i];
 					newColIndices[i] = this._colIndices[i];
 				}
-				newData[insertPos] = value;
-				newColIndices[insertPos] = col;
-				for (let i = insertPos; i < this._data.length; i++) {
-					newData[i + 1] = this._data[i];
-					newColIndices[i + 1] = this._colIndices[i];
+				for (let i = insertPos + 1; i < this._data.length; i++) {
+					newData[i - 1] = this._data[i];
+					newColIndices[i - 1] = this._colIndices[i];
 				}
 				for (let i = 0; i <= row; i++) newRowPointers[i] = this._rowPointers[i];
-				for (let i = row + 1; i <= this.rows; i++) newRowPointers[i] = this._rowPointers[i] + 1;
+				for (let i = row + 1; i <= this.rows; i++) newRowPointers[i] = this._rowPointers[i] - 1;
 				return new SparseMatrix(this.rows, this.cols, newData, newColIndices, newRowPointers);
+			} else {
+				const newData = new Float64Array(this._data);
+				newData[insertPos] = value;
+				return new SparseMatrix(this.rows, this.cols, newData, this._colIndices, this._rowPointers);
 			}
-		}
-		row(index) {
-			if (index < 0 || index >= this.rows) throw new RangeError(`Row index ${index} out of bounds for matrix with ${this.rows} rows`);
-			const start = this._rowPointers[index];
-			const nnzCount = this._rowPointers[index + 1] - start;
-			const data = new Float64Array(nnzCount);
-			const colIndices = new Int32Array(nnzCount);
-			const rowPointers = new Int32Array([0, nnzCount]);
-			for (let i = 0; i < nnzCount; i++) {
-				data[i] = this._data[start + i];
-				colIndices[i] = this._colIndices[start + i];
-			}
-			return new SparseMatrix(1, this.cols, data, colIndices, rowPointers);
-		}
-		column(index) {
-			if (index < 0 || index >= this.cols) throw new RangeError(`Column index ${index} out of bounds for matrix with ${this.cols} columns`);
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) if (this._colIndices[j] === index) {
-					entries.push({
-						row: i,
-						col: 0,
-						value: this._data[j]
-					});
-					break;
-				}
+		} else {
+			if (value === 0) return this;
+			const newData = new Float64Array(this._data.length + 1);
+			const newColIndices = new Int32Array(this._colIndices.length + 1);
+			const newRowPointers = new Int32Array(this._rowPointers.length);
+			for (let i = 0; i < insertPos; i++) {
+				newData[i] = this._data[i];
+				newColIndices[i] = this._colIndices[i];
 			}
-			return SparseMatrix.fromCOO(this.rows, 1, entries);
-		}
-		slice(spec) {
-			const rowStart = spec.rowStart ?? 0;
-			const rowEnd = spec.rowEnd ?? this.rows;
-			const colStart = spec.colStart ?? 0;
-			const colEnd = spec.colEnd ?? this.cols;
-			if (rowStart < 0 || rowEnd > this.rows || colStart < 0 || colEnd > this.cols) throw new RangeError("Slice indices out of bounds");
-			if (rowStart >= rowEnd || colStart >= colEnd) throw new Error("Invalid slice: start must be less than end");
-			const entries = [];
-			for (let i = rowStart; i < rowEnd; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) {
-					const col = this._colIndices[j];
-					if (col >= colStart && col < colEnd) entries.push({
-						row: i - rowStart,
-						col: col - colStart,
-						value: this._data[j]
-					});
-				}
+			newData[insertPos] = value;
+			newColIndices[insertPos] = col;
+			for (let i = insertPos; i < this._data.length; i++) {
+				newData[i + 1] = this._data[i];
+				newColIndices[i + 1] = this._colIndices[i];
 			}
-			return SparseMatrix.fromCOO(rowEnd - rowStart, colEnd - colStart, entries);
-		}
-		diagonal(k = 0) {
-			const diagLength = Math.min(this.rows - Math.max(0, -k), this.cols - Math.max(0, k));
-			if (diagLength <= 0) return SparseMatrix.zeros(0, 1);
-			const entries = [];
-			const rowOffset = Math.max(0, -k);
-			const colOffset = Math.max(0, k);
-			for (let i = 0; i < diagLength; i++) {
-				const val = this.get(rowOffset + i, colOffset + i);
-				if (val !== 0) entries.push({
+			for (let i = 0; i <= row; i++) newRowPointers[i] = this._rowPointers[i];
+			for (let i = row + 1; i <= this.rows; i++) newRowPointers[i] = this._rowPointers[i] + 1;
+			return new SparseMatrix(this.rows, this.cols, newData, newColIndices, newRowPointers);
+		}
+	}
+	row(index) {
+		if (index < 0 || index >= this.rows) throw new RangeError(`Row index ${index} out of bounds for matrix with ${this.rows} rows`);
+		const start = this._rowPointers[index];
+		const nnzCount = this._rowPointers[index + 1] - start;
+		const data = new Float64Array(nnzCount);
+		const colIndices = new Int32Array(nnzCount);
+		const rowPointers = new Int32Array([0, nnzCount]);
+		for (let i = 0; i < nnzCount; i++) {
+			data[i] = this._data[start + i];
+			colIndices[i] = this._colIndices[start + i];
+		}
+		return new SparseMatrix(1, this.cols, data, colIndices, rowPointers);
+	}
+	column(index) {
+		if (index < 0 || index >= this.cols) throw new RangeError(`Column index ${index} out of bounds for matrix with ${this.cols} columns`);
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) {
+			const start = this._rowPointers[i];
+			const end = this._rowPointers[i + 1];
+			for (let j = start; j < end; j++) if (this._colIndices[j] === index) {
+				entries.push({
 					row: i,
 					col: 0,
-					value: val
+					value: this._data[j]
 				});
+				break;
 			}
-			return SparseMatrix.fromCOO(diagLength, 1, entries);
 		}
-		add(other) {
-			this.checkDimensionsMatch(other);
-			if (other instanceof SparseMatrix) return this.addSparse(other);
-			const result = this.toDense().add(other);
-			return SparseMatrix.fromDense(result);
-		}
-		addSparse(other) {
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const thisStart = this._rowPointers[i];
-				const thisEnd = this._rowPointers[i + 1];
-				const otherStart = other._rowPointers[i];
-				const otherEnd = other._rowPointers[i + 1];
-				let thisIdx = thisStart;
-				let otherIdx = otherStart;
-				while (thisIdx < thisEnd || otherIdx < otherEnd) {
-					const thisCol = thisIdx < thisEnd ? this._colIndices[thisIdx] : this.cols;
-					const otherCol = otherIdx < otherEnd ? other._colIndices[otherIdx] : this.cols;
-					if (thisCol < otherCol) {
-						entries.push({
-							row: i,
-							col: thisCol,
-							value: this._data[thisIdx]
-						});
-						thisIdx++;
-					} else if (otherCol < thisCol) {
-						entries.push({
-							row: i,
-							col: otherCol,
-							value: other._data[otherIdx]
-						});
-						otherIdx++;
-					} else {
-						const sum = this._data[thisIdx] + other._data[otherIdx];
-						if (sum !== 0) entries.push({
-							row: i,
-							col: thisCol,
-							value: sum
-						});
-						thisIdx++;
-						otherIdx++;
-					}
-				}
+		return SparseMatrix.fromCOO(this.rows, 1, entries);
+	}
+	slice(spec) {
+		const rowStart = spec.rowStart ?? 0;
+		const rowEnd = spec.rowEnd ?? this.rows;
+		const colStart = spec.colStart ?? 0;
+		const colEnd = spec.colEnd ?? this.cols;
+		if (rowStart < 0 || rowEnd > this.rows || colStart < 0 || colEnd > this.cols) throw new RangeError("Slice indices out of bounds");
+		if (rowStart >= rowEnd || colStart >= colEnd) throw new Error("Invalid slice: start must be less than end");
+		const entries = [];
+		for (let i = rowStart; i < rowEnd; i++) {
+			const start = this._rowPointers[i];
+			const end = this._rowPointers[i + 1];
+			for (let j = start; j < end; j++) {
+				const col = this._colIndices[j];
+				if (col >= colStart && col < colEnd) entries.push({
+					row: i - rowStart,
+					col: col - colStart,
+					value: this._data[j]
+				});
 			}
-			return SparseMatrix.fromCOO(this.rows, this.cols, entries);
 		}
-		subtract(other) {
-			this.checkDimensionsMatch(other);
-			if (other instanceof SparseMatrix) return this.addSparse(other.scale(-1));
-			const result = this.toDense().subtract(other);
-			return SparseMatrix.fromDense(result);
+		return SparseMatrix.fromCOO(rowEnd - rowStart, colEnd - colStart, entries);
+	}
+	diagonal(k = 0) {
+		const diagLength = Math.min(this.rows - Math.max(0, -k), this.cols - Math.max(0, k));
+		if (diagLength <= 0) return SparseMatrix.zeros(0, 1);
+		const entries = [];
+		const rowOffset = Math.max(0, -k);
+		const colOffset = Math.max(0, k);
+		for (let i = 0; i < diagLength; i++) {
+			const val = this.get(rowOffset + i, colOffset + i);
+			if (val !== 0) entries.push({
+				row: i,
+				col: 0,
+				value: val
+			});
 		}
-		multiplyElementwise(other) {
-			this.checkDimensionsMatch(other);
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) {
-					const col = this._colIndices[j];
-					const product = this._data[j] * other.get(i, col);
-					if (product !== 0) entries.push({
+		return SparseMatrix.fromCOO(diagLength, 1, entries);
+	}
+	add(other) {
+		this.checkDimensionsMatch(other);
+		if (other instanceof SparseMatrix) return this.addSparse(other);
+		const result = this.toDense().add(other);
+		return SparseMatrix.fromDense(result);
+	}
+	addSparse(other) {
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) {
+			const thisStart = this._rowPointers[i];
+			const thisEnd = this._rowPointers[i + 1];
+			const otherStart = other._rowPointers[i];
+			const otherEnd = other._rowPointers[i + 1];
+			let thisIdx = thisStart;
+			let otherIdx = otherStart;
+			while (thisIdx < thisEnd || otherIdx < otherEnd) {
+				const thisCol = thisIdx < thisEnd ? this._colIndices[thisIdx] : this.cols;
+				const otherCol = otherIdx < otherEnd ? other._colIndices[otherIdx] : this.cols;
+				if (thisCol < otherCol) {
+					entries.push({
 						row: i,
-						col,
-						value: product
+						col: thisCol,
+						value: this._data[thisIdx]
 					});
-				}
-			}
-			return SparseMatrix.fromCOO(this.rows, this.cols, entries);
-		}
-		multiply(other) {
-			this.checkMultiplyDimensions(other);
-			if (other instanceof SparseMatrix) return this.multiplySparse(other);
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const rowStart = this._rowPointers[i];
-				const rowEnd = this._rowPointers[i + 1];
-				for (let j = 0; j < other.cols; j++) {
-					let sum = 0;
-					for (let k = rowStart; k < rowEnd; k++) {
-						const col = this._colIndices[k];
-						sum += this._data[k] * other.get(col, j);
-					}
+					thisIdx++;
+				} else if (otherCol < thisCol) {
+					entries.push({
+						row: i,
+						col: otherCol,
+						value: other._data[otherIdx]
+					});
+					otherIdx++;
+				} else {
+					const sum = this._data[thisIdx] + other._data[otherIdx];
 					if (sum !== 0) entries.push({
 						row: i,
-						col: j,
+						col: thisCol,
 						value: sum
 					});
+					thisIdx++;
+					otherIdx++;
 				}
 			}
-			return SparseMatrix.fromCOO(this.rows, other.cols, entries);
 		}
-		multiplySparse(other) {
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const rowStart = this._rowPointers[i];
-				const rowEnd = this._rowPointers[i + 1];
-				const rowResult = /* @__PURE__ */ new Map();
-				for (let k = rowStart; k < rowEnd; k++) {
-					const colA = this._colIndices[k];
-					const valA = this._data[k];
-					const otherRowStart = other._rowPointers[colA];
-					const otherRowEnd = other._rowPointers[colA + 1];
-					for (let l = otherRowStart; l < otherRowEnd; l++) {
-						const colB = other._colIndices[l];
-						const valB = other._data[l];
-						const existing = rowResult.get(colB) || 0;
-						rowResult.set(colB, existing + valA * valB);
-					}
-				}
-				for (const [col, value] of rowResult.entries()) if (value !== 0) entries.push({
+		return SparseMatrix.fromCOO(this.rows, this.cols, entries);
+	}
+	subtract(other) {
+		this.checkDimensionsMatch(other);
+		if (other instanceof SparseMatrix) return this.addSparse(other.scale(-1));
+		const result = this.toDense().subtract(other);
+		return SparseMatrix.fromDense(result);
+	}
+	multiplyElementwise(other) {
+		this.checkDimensionsMatch(other);
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) {
+			const start = this._rowPointers[i];
+			const end = this._rowPointers[i + 1];
+			for (let j = start; j < end; j++) {
+				const col = this._colIndices[j];
+				const product = this._data[j] * other.get(i, col);
+				if (product !== 0) entries.push({
 					row: i,
 					col,
-					value
-				});
-			}
-			return SparseMatrix.fromCOO(this.rows, other.cols, entries);
-		}
-		scale(scalar) {
-			if (scalar === 0) return SparseMatrix.zeros(this.rows, this.cols);
-			const newData = new Float64Array(this._data.length);
-			for (let i = 0; i < this._data.length; i++) newData[i] = this._data[i] * scalar;
-			return new SparseMatrix(this.rows, this.cols, newData, this._colIndices, this._rowPointers);
-		}
-		transpose() {
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) entries.push({
-					row: this._colIndices[j],
-					col: i,
-					value: this._data[j]
+					value: product
 				});
 			}
-			return SparseMatrix.fromCOO(this.cols, this.rows, entries);
-		}
-		negate() {
-			return this.scale(-1);
-		}
-		sum() {
-			let total = 0;
-			for (let i = 0; i < this._data.length; i++) total += this._data[i];
-			return total;
-		}
-		norm() {
-			let sumSq = 0;
-			for (let i = 0; i < this._data.length; i++) sumSq += this._data[i] * this._data[i];
-			return Math.sqrt(sumSq);
-		}
-		trace() {
-			if (!this.isSquare) throw new Error("Trace is only defined for square matrices");
-			let sum = 0;
-			for (let i = 0; i < this.rows; i++) sum += this.get(i, i);
-			return sum;
-		}
-		toDense() {
-			const data = new Float64Array(this.rows * this.cols);
-			for (let i = 0; i < this.rows; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) data[i * this.cols + this._colIndices[j]] = this._data[j];
-			}
-			return new DenseMatrix(this.rows, this.cols, data);
-		}
-		toArray() {
-			return this.toDense().toArray();
-		}
-		toFlatArray() {
-			return this.toDense().toFlatArray();
-		}
-		clone() {
-			return new SparseMatrix(this.rows, this.cols, new Float64Array(this._data), new Int32Array(this._colIndices), new Int32Array(this._rowPointers));
-		}
-		getCSR() {
-			return {
-				values: new Float64Array(this._data),
-				colIndices: new Int32Array(this._colIndices),
-				rowPointers: new Int32Array(this._rowPointers)
-			};
-		}
-		*entries() {
-			for (let i = 0; i < this.rows; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) yield {
-					row: i,
-					col: this._colIndices[j],
-					value: this._data[j]
-				};
-			}
 		}
-		*values() {
-			for (let i = 0; i < this._data.length; i++) yield this._data[i];
-		}
-		*allValues() {
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) yield this.get(i, j);
-		}
-		[Symbol.iterator]() {
-			return this.values();
-		}
-		mapNonZeros(fn) {
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) {
-				const start = this._rowPointers[i];
-				const end = this._rowPointers[i + 1];
-				for (let j = start; j < end; j++) {
-					const col = this._colIndices[j];
-					const newVal = fn(this._data[j], i, col);
-					if (newVal !== 0) entries.push({
-						row: i,
-						col,
-						value: newVal
-					});
+		return SparseMatrix.fromCOO(this.rows, this.cols, entries);
+	}
+	multiply(other) {
+		this.checkMultiplyDimensions(other);
+		if (other instanceof SparseMatrix) return this.multiplySparse(other);
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) {
+			const rowStart = this._rowPointers[i];
+			const rowEnd = this._rowPointers[i + 1];
+			for (let j = 0; j < other.cols; j++) {
+				let sum = 0;
+				for (let k = rowStart; k < rowEnd; k++) {
+					const col = this._colIndices[k];
+					sum += this._data[k] * other.get(col, j);
 				}
-			}
-			return SparseMatrix.fromCOO(this.rows, this.cols, entries);
-		}
-		map(fn) {
-			const entries = [];
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) {
-				const newVal = fn(this.get(i, j), i, j);
-				if (newVal !== 0) entries.push({
+				if (sum !== 0) entries.push({
 					row: i,
 					col: j,
-					value: newVal
+					value: sum
 				});
 			}
-			return SparseMatrix.fromCOO(this.rows, this.cols, entries);
 		}
-	};
-}));
-//#endregion
-//#region src/types/DenseMatrix.ts
-function isDenseMatrix(value) {
-	return value instanceof DenseMatrix;
-}
-function denseContiguousData(matrix) {
-	const m = matrix;
-	if (!m.isView && m.offset === 0 && m.rowStride === m.cols) return m.data;
-	return m.toFlatFloat64Array();
-}
-var DenseMatrix;
-var init_DenseMatrix = __esmMin((() => {
-	init_Matrix();
-	init_arithmetic();
-	init_reduction();
-	DenseMatrix = class DenseMatrix extends Matrix {
-		type = "DenseMatrix";
-		rows;
-		cols;
-		data;
-		isView;
-		offset;
-		rowStride;
-		constructor(rows, cols, data, viewConfig) {
-			super();
-			if (rows < 0 || cols < 0) throw new Error("Matrix dimensions must be non-negative");
-			this.rows = rows;
-			this.cols = cols;
-			if (viewConfig) {
-				this.isView = viewConfig.isView;
-				this.offset = viewConfig.offset;
-				this.rowStride = viewConfig.rowStride;
-				this.data = data;
-			} else {
-				this.isView = false;
-				this.offset = 0;
-				this.rowStride = cols;
-				if (data === void 0) this.data = new Float64Array(rows * cols);
-				else if (data instanceof Float64Array) {
-					if (data.length !== rows * cols) throw new Error(`Data length ${data.length} does not match dimensions ${rows}×${cols}`);
-					this.data = data;
-				} else if (Array.isArray(data)) {
-					if (Array.isArray(data[0])) {
-						const nested = data;
-						if (nested.length !== rows) throw new Error(`Expected ${rows} rows, got ${nested.length}`);
-						this.data = new Float64Array(rows * cols);
-						for (let i = 0; i < rows; i++) {
-							if (nested[i].length !== cols) throw new Error(`Row ${i} has ${nested[i].length} elements, expected ${cols}`);
-							for (let j = 0; j < cols; j++) this.data[i * cols + j] = nested[i][j];
-						}
-					} else {
-						const flat = data;
-						if (flat.length !== rows * cols) throw new Error(`Data length ${flat.length} does not match dimensions ${rows}×${cols}`);
-						this.data = new Float64Array(flat);
-					}
+		return SparseMatrix.fromCOO(this.rows, other.cols, entries);
+	}
+	multiplySparse(other) {
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) {
+			const rowStart = this._rowPointers[i];
+			const rowEnd = this._rowPointers[i + 1];
+			const rowResult = /* @__PURE__ */ new Map();
+			for (let k = rowStart; k < rowEnd; k++) {
+				const colA = this._colIndices[k];
+				const valA = this._data[k];
+				const otherRowStart = other._rowPointers[colA];
+				const otherRowEnd = other._rowPointers[colA + 1];
+				for (let l = otherRowStart; l < otherRowEnd; l++) {
+					const colB = other._colIndices[l];
+					const valB = other._data[l];
+					const existing = rowResult.get(colB) || 0;
+					rowResult.set(colB, existing + valA * valB);
 				}
 			}
-		}
-		static fromArray(arr) {
-			const rows = arr.length;
-			const cols = arr[0]?.length ?? 0;
-			return new DenseMatrix(rows, cols, arr);
-		}
-		static fromFlat(rows, cols, data) {
-			return new DenseMatrix(rows, cols, data);
-		}
-		static zeros(rows, cols) {
-			return new DenseMatrix(rows, cols);
-		}
-		static ones(rows, cols) {
-			const data = new Float64Array(rows * cols).fill(1);
-			return new DenseMatrix(rows, cols, data);
-		}
-		static identity(n) {
-			const data = new Float64Array(n * n);
-			for (let i = 0; i < n; i++) data[i * n + i] = 1;
-			return new DenseMatrix(n, n, data);
-		}
-		static diag(values) {
-			const n = values.length;
-			const data = new Float64Array(n * n);
-			for (let i = 0; i < n; i++) data[i * n + i] = values[i];
-			return new DenseMatrix(n, n, data);
-		}
-		static fill(rows, cols, value) {
-			const data = new Float64Array(rows * cols).fill(value);
-			return new DenseMatrix(rows, cols, data);
-		}
-		static random(rows, cols) {
-			const data = new Float64Array(rows * cols);
-			for (let i = 0; i < data.length; i++) data[i] = Math.random();
-			return new DenseMatrix(rows, cols, data);
-		}
-		get(row, col) {
-			this.checkBounds(row, col);
-			return this.data[this.offset + row * this.rowStride + col];
-		}
-		set(row, col, value) {
-			this.checkBounds(row, col);
-			const newData = this.toFlatFloat64Array();
-			newData[row * this.cols + col] = value;
-			return new DenseMatrix(this.rows, this.cols, newData);
-		}
-		toFlatFloat64Array() {
-			if (!this.isView && this.offset === 0 && this.rowStride === this.cols) return new Float64Array(this.data);
-			const result = new Float64Array(this.rows * this.cols);
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) result[i * this.cols + j] = this.data[this.offset + i * this.rowStride + j];
-			return result;
-		}
-		row(index) {
-			if (index < 0 || index >= this.rows) throw new RangeError(`Row index ${index} out of bounds for matrix with ${this.rows} rows`);
-			return new DenseMatrix(1, this.cols, this.data, {
-				isView: true,
-				offset: this.offset + index * this.rowStride,
-				rowStride: this.rowStride
-			});
-		}
-		column(index) {
-			if (index < 0 || index >= this.cols) throw new RangeError(`Column index ${index} out of bounds for matrix with ${this.cols} columns`);
-			const data = new Float64Array(this.rows);
-			for (let i = 0; i < this.rows; i++) data[i] = this.get(i, index);
-			return new DenseMatrix(this.rows, 1, data);
-		}
-		slice(spec) {
-			const rowStart = spec.rowStart ?? 0;
-			const rowEnd = spec.rowEnd ?? this.rows;
-			const colStart = spec.colStart ?? 0;
-			const colEnd = spec.colEnd ?? this.cols;
-			if (rowStart < 0 || rowEnd > this.rows || colStart < 0 || colEnd > this.cols) throw new RangeError("Slice indices out of bounds");
-			if (rowStart >= rowEnd || colStart >= colEnd) throw new Error("Invalid slice: start must be less than end");
-			const newRows = rowEnd - rowStart;
-			const newCols = colEnd - colStart;
-			if (colStart === 0 && colEnd === this.cols) return new DenseMatrix(newRows, newCols, this.data, {
-				isView: true,
-				offset: this.offset + rowStart * this.rowStride,
-				rowStride: this.rowStride
+			for (const [col, value] of rowResult.entries()) if (value !== 0) entries.push({
+				row: i,
+				col,
+				value
 			});
-			const data = new Float64Array(newRows * newCols);
-			for (let i = 0; i < newRows; i++) for (let j = 0; j < newCols; j++) data[i * newCols + j] = this.get(rowStart + i, colStart + j);
-			return new DenseMatrix(newRows, newCols, data);
-		}
-		diagonal(k = 0) {
-			const diagLength = Math.min(this.rows - Math.max(0, k), this.cols - Math.max(0, -k));
-			if (diagLength <= 0) return new DenseMatrix(0, 1);
-			const data = new Float64Array(diagLength);
-			const rowOffset = Math.max(0, -k);
-			const colOffset = Math.max(0, k);
-			for (let i = 0; i < diagLength; i++) data[i] = this.get(rowOffset + i, colOffset + i);
-			return new DenseMatrix(diagLength, 1, data);
-		}
-		add(other) {
-			this.checkDimensionsMatch(other);
-			return new DenseMatrix(this.rows, this.cols, add$1(this, other));
-		}
-		subtract(other) {
-			this.checkDimensionsMatch(other);
-			return new DenseMatrix(this.rows, this.cols, subtract$1(this, other));
-		}
-		multiplyElementwise(other) {
-			this.checkDimensionsMatch(other);
-			return new DenseMatrix(this.rows, this.cols, multiplyElementwise(this, other));
-		}
-		multiply(other) {
-			this.checkMultiplyDimensions(other);
-			return new DenseMatrix(this.rows, other.cols, multiply$1(this, other));
-		}
-		scale(scalar) {
-			return new DenseMatrix(this.rows, this.cols, scale(this, scalar));
-		}
-		transpose() {
-			return new DenseMatrix(this.cols, this.rows, transpose$2(this));
-		}
-		negate() {
-			return this.scale(-1);
-		}
-		sum() {
-			return sum$1(this);
 		}
-		mean() {
-			return mean$1(this);
-		}
-		min() {
-			return min$1(this);
-		}
-		max() {
-			return max$1(this);
-		}
-		norm() {
-			return norm$1(this);
-		}
-		trace() {
-			return trace$1(this);
-		}
-		toArray() {
-			const result = [];
-			for (let i = 0; i < this.rows; i++) {
-				result[i] = [];
-				for (let j = 0; j < this.cols; j++) result[i][j] = this.get(i, j);
+		return SparseMatrix.fromCOO(this.rows, other.cols, entries);
+	}
+	scale(scalar) {
+		if (scalar === 0) return SparseMatrix.zeros(this.rows, this.cols);
+		const newData = new Float64Array(this._data.length);
+		for (let i = 0; i < this._data.length; i++) newData[i] = this._data[i] * scalar;
+		return new SparseMatrix(this.rows, this.cols, newData, this._colIndices, this._rowPointers);
+	}
+	transpose() {
+		const nnz = this._data.length;
+		const outPtr = new Int32Array(this.cols + 1);
+		for (let k = 0; k < nnz; k++) outPtr[this._colIndices[k] + 1]++;
+		for (let c = 0; c < this.cols; c++) outPtr[c + 1] += outPtr[c];
+		const next = outPtr.slice(0, this.cols);
+		const outIdx = new Int32Array(nnz);
+		const outVal = new Float64Array(nnz);
+		for (let i = 0; i < this.rows; i++) {
+			const end = this._rowPointers[i + 1];
+			for (let k = this._rowPointers[i]; k < end; k++) {
+				const pos = next[this._colIndices[k]]++;
+				outIdx[pos] = i;
+				outVal[pos] = this._data[k];
 			}
-			return result;
 		}
-		toFlatArray() {
-			return Array.from(this.toFlatFloat64Array());
-		}
-		toFloat64Array() {
-			return this.toFlatFloat64Array();
+		return new SparseMatrix(this.cols, this.rows, outVal, outIdx, outPtr);
+	}
+	negate() {
+		return this.scale(-1);
+	}
+	sum() {
+		let total = 0;
+		for (let i = 0; i < this._data.length; i++) total += this._data[i];
+		return total;
+	}
+	norm() {
+		let sumSq = 0;
+		for (let i = 0; i < this._data.length; i++) sumSq += this._data[i] * this._data[i];
+		return Math.sqrt(sumSq);
+	}
+	trace() {
+		if (!this.isSquare) throw new Error("Trace is only defined for square matrices");
+		let sum = 0;
+		for (let i = 0; i < this.rows; i++) sum += this.get(i, i);
+		return sum;
+	}
+	toDense() {
+		const data = new Float64Array(this.rows * this.cols);
+		for (let i = 0; i < this.rows; i++) {
+			const start = this._rowPointers[i];
+			const end = this._rowPointers[i + 1];
+			for (let j = start; j < end; j++) data[i * this.cols + this._colIndices[j]] = this._data[j];
 		}
-		clone() {
-			return new DenseMatrix(this.rows, this.cols, this.toFlatFloat64Array());
+		return new DenseMatrix(this.rows, this.cols, data);
+	}
+	toArray() {
+		return this.toDense().toArray();
+	}
+	toFlatArray() {
+		return this.toDense().toFlatArray();
+	}
+	clone() {
+		return new SparseMatrix(this.rows, this.cols, new Float64Array(this._data), new Int32Array(this._colIndices), new Int32Array(this._rowPointers));
+	}
+	getCSR() {
+		return {
+			values: new Float64Array(this._data),
+			colIndices: new Int32Array(this._colIndices),
+			rowPointers: new Int32Array(this._rowPointers)
+		};
+	}
+	*entries() {
+		for (let i = 0; i < this.rows; i++) {
+			const start = this._rowPointers[i];
+			const end = this._rowPointers[i + 1];
+			for (let j = start; j < end; j++) yield {
+				row: i,
+				col: this._colIndices[j],
+				value: this._data[j]
+			};
 		}
-		toSparse(dropTolerance = 0) {
-			const values = [];
-			const colIndices = [];
-			const rowPointers = [0];
-			for (let i = 0; i < this.rows; i++) {
-				for (let j = 0; j < this.cols; j++) {
-					const val = this.get(i, j);
-					if (Math.abs(val) > dropTolerance) {
-						values.push(val);
-						colIndices.push(j);
-					}
-				}
-				rowPointers.push(values.length);
+	}
+	*values() {
+		for (let i = 0; i < this._data.length; i++) yield this._data[i];
+	}
+	*allValues() {
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) yield this.get(i, j);
+	}
+	[Symbol.iterator]() {
+		return this.values();
+	}
+	mapNonZeros(fn) {
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) {
+			const start = this._rowPointers[i];
+			const end = this._rowPointers[i + 1];
+			for (let j = start; j < end; j++) {
+				const col = this._colIndices[j];
+				const newVal = fn(this._data[j], i, col);
+				if (newVal !== 0) entries.push({
+					row: i,
+					col,
+					value: newVal
+				});
 			}
-			return new (init_SparseMatrix(), __toCommonJS(SparseMatrix_exports)).SparseMatrix(this.rows, this.cols, new Float64Array(values), new Int32Array(colIndices), new Int32Array(rowPointers));
 		}
-		*entries() {
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) yield {
+		return SparseMatrix.fromCOO(this.rows, this.cols, entries);
+	}
+	map(fn) {
+		const entries = [];
+		for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) {
+			const newVal = fn(this.get(i, j), i, j);
+			if (newVal !== 0) entries.push({
 				row: i,
 				col: j,
-				value: this.get(i, j)
-			};
-		}
-		*values() {
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) yield this.get(i, j);
-		}
-		[Symbol.iterator]() {
-			return this.values();
-		}
-		map(fn) {
-			const result = new Float64Array(this.rows * this.cols);
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) result[i * this.cols + j] = fn(this.get(i, j), i, j);
-			return new DenseMatrix(this.rows, this.cols, result);
-		}
-		forEach(fn) {
-			for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) fn(this.get(i, j), i, j);
+				value: newVal
+			});
 		}
-	};
-}));
+		return SparseMatrix.fromCOO(this.rows, this.cols, entries);
+	}
+};
+registerSparseMatrixFactory((rows, cols, values, colIndices, rowPointers) => new SparseMatrix(rows, cols, values, colIndices, rowPointers));
+function isSparseMatrix(value) {
+	return value instanceof SparseMatrix;
+}
 //#endregion
 //#region src/backends/Backend.ts
 const DEFAULT_BACKEND_HINTS = {
@@ -987,8 +1023,6 @@ var BackendRegistry = class {
 const backendRegistry = new BackendRegistry();
 //#endregion
 //#region src/backends/JSBackend.ts
-init_DenseMatrix();
-init_reduction();
 var JSBackend = class {
 	type = "js";
 	isAvailable() {
@@ -997,36 +1031,52 @@ var JSBackend = class {
 	async initialize() {}
 	add(a, b) {
 		this.checkDimensionsMatch(a, b);
-		const result = new Float64Array(a.rows * a.cols);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i * a.cols + j] = a.get(i, j) + b.get(i, j);
+		const ad = denseContiguousData(a);
+		const bd = denseContiguousData(b);
+		const n = ad.length;
+		const result = new Float64Array(n);
+		for (let i = 0; i < n; i++) result[i] = ad[i] + bd[i];
 		return new DenseMatrix(a.rows, a.cols, result);
 	}
 	subtract(a, b) {
 		this.checkDimensionsMatch(a, b);
-		const result = new Float64Array(a.rows * a.cols);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i * a.cols + j] = a.get(i, j) - b.get(i, j);
+		const ad = denseContiguousData(a);
+		const bd = denseContiguousData(b);
+		const n = ad.length;
+		const result = new Float64Array(n);
+		for (let i = 0; i < n; i++) result[i] = ad[i] - bd[i];
 		return new DenseMatrix(a.rows, a.cols, result);
 	}
 	multiplyElementwise(a, b) {
 		this.checkDimensionsMatch(a, b);
-		const result = new Float64Array(a.rows * a.cols);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i * a.cols + j] = a.get(i, j) * b.get(i, j);
+		const ad = denseContiguousData(a);
+		const bd = denseContiguousData(b);
+		const n = ad.length;
+		const result = new Float64Array(n);
+		for (let i = 0; i < n; i++) result[i] = ad[i] * bd[i];
 		return new DenseMatrix(a.rows, a.cols, result);
 	}
 	divideElementwise(a, b) {
 		this.checkDimensionsMatch(a, b);
-		const result = new Float64Array(a.rows * a.cols);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i * a.cols + j] = a.get(i, j) / b.get(i, j);
+		const ad = denseContiguousData(a);
+		const bd = denseContiguousData(b);
+		const n = ad.length;
+		const result = new Float64Array(n);
+		for (let i = 0; i < n; i++) result[i] = ad[i] / bd[i];
 		return new DenseMatrix(a.rows, a.cols, result);
 	}
 	scale(a, scalar) {
-		const result = new Float64Array(a.rows * a.cols);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i * a.cols + j] = a.get(i, j) * scalar;
+		const ad = denseContiguousData(a);
+		const n = ad.length;
+		const result = new Float64Array(n);
+		for (let i = 0; i < n; i++) result[i] = ad[i] * scalar;
 		return new DenseMatrix(a.rows, a.cols, result);
 	}
 	abs(a) {
-		const result = new Float64Array(a.rows * a.cols);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i * a.cols + j] = Math.abs(a.get(i, j));
+		const ad = denseContiguousData(a);
+		const n = ad.length;
+		const result = new Float64Array(n);
+		for (let i = 0; i < n; i++) result[i] = Math.abs(ad[i]);
 		return new DenseMatrix(a.rows, a.cols, result);
 	}
 	negate(a) {
@@ -1052,24 +1102,42 @@ var JSBackend = class {
 		return new DenseMatrix(m, n, result);
 	}
 	transpose(a) {
-		const result = new Float64Array(a.cols * a.rows);
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[j * a.rows + i] = a.get(i, j);
-		return new DenseMatrix(a.cols, a.rows, result);
+		const rows = a.rows;
+		const cols = a.cols;
+		const ad = denseContiguousData(a);
+		const result = new Float64Array(cols * rows);
+		for (let i = 0; i < rows; i++) {
+			const ai = i * cols;
+			for (let j = 0; j < cols; j++) result[j * rows + i] = ad[ai + j];
+		}
+		return new DenseMatrix(cols, rows, result);
 	}
 	sum(a) {
+		const ad = denseContiguousData(a);
 		let total = 0;
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) total += a.get(i, j);
+		for (let i = 0; i < ad.length; i++) total += ad[i];
 		return total;
 	}
 	sumAxis(a, axis) {
+		const rows = a.rows;
+		const cols = a.cols;
+		const ad = denseContiguousData(a);
 		if (axis === 0) {
-			const result = new Float64Array(a.cols);
-			for (let j = 0; j < a.cols; j++) for (let i = 0; i < a.rows; i++) result[j] += a.get(i, j);
-			return new DenseMatrix(1, a.cols, result);
+			const result = new Float64Array(cols);
+			for (let i = 0; i < rows; i++) {
+				const ai = i * cols;
+				for (let j = 0; j < cols; j++) result[j] += ad[ai + j];
+			}
+			return new DenseMatrix(1, cols, result);
 		} else {
-			const result = new Float64Array(a.rows);
-			for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) result[i] += a.get(i, j);
-			return new DenseMatrix(a.rows, 1, result);
+			const result = new Float64Array(rows);
+			for (let i = 0; i < rows; i++) {
+				const ai = i * cols;
+				let acc = 0;
+				for (let j = 0; j < cols; j++) acc += ad[ai + j];
+				result[i] = acc;
+			}
+			return new DenseMatrix(rows, 1, result);
 		}
 	}
 	norm(a) {
@@ -1079,9 +1147,9 @@ var JSBackend = class {
 		if (!a.isVector || !b.isVector) throw new Error("Dot product requires two vectors");
 		if (a.length !== b.length) throw new Error(`Vector lengths must match: ${a.length} vs ${b.length}`);
 		let sum = 0;
-		const aValues = Array.from(a.values());
-		const bValues = Array.from(b.values());
-		for (let i = 0; i < aValues.length; i++) sum += aValues[i] * bValues[i];
+		const ad = denseContiguousData(a);
+		const bd = denseContiguousData(b);
+		for (let i = 0; i < ad.length; i++) sum += ad[i] * bd[i];
 		return sum;
 	}
 	checkDimensionsMatch(a, b) {
@@ -1094,7 +1162,6 @@ var JSBackend = class {
 const jsBackend = new JSBackend();
 //#endregion
 //#region src/backends/ParallelBackend.ts
-init_DenseMatrix();
 var ParallelBackend = class {
 	type = "parallel";
 	pool;
@@ -1493,7 +1560,6 @@ function allocAsTypedView(module, byteLength, length, typeId, Ctor) {
 }
 //#endregion
 //#region src/backends/WASMBackend.ts
-init_DenseMatrix();
 var AsAllocCache = class {
 	free = /* @__PURE__ */ new Map();
 	acquire(module, length) {
@@ -1701,7 +1767,7 @@ var WASMBackend = class {
 		try {
 			mod.matrix_multiply_simd_ptr(aAlloc.bufferPtr, a.rows, a.cols, bAlloc.bufferPtr, b.cols, rAlloc.bufferPtr);
 			const result = readAsFloat64Array(mod, rAlloc);
-			return DenseMatrix.fromFlat(a.rows, b.cols, Array.from(result));
+			return new DenseMatrix(a.rows, b.cols, result);
 		} finally {
 			this.allocCache.release(aAlloc);
 			this.allocCache.release(bAlloc);
@@ -1744,7 +1810,7 @@ var WASMBackend = class {
 			for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) combined[i * n + j] = i > j ? lFlat[i * n + j] : uFlat[i * n + j];
 			const perm = readAsInt32Array(mod, permAlloc);
 			return {
-				lu: DenseMatrix.fromFlat(n, n, Array.from(combined)),
+				lu: new DenseMatrix(n, n, combined),
 				perm,
 				singular: false
 			};
@@ -1772,7 +1838,7 @@ var WASMBackend = class {
 				}
 			}
 			if (maxVal < 1e-14) return {
-				lu: DenseMatrix.fromFlat(n, n, Array.from(data)),
+				lu: new DenseMatrix(n, n, data),
 				perm,
 				singular: true
 			};
@@ -1794,7 +1860,7 @@ var WASMBackend = class {
 			}
 		}
 		return {
-			lu: DenseMatrix.fromFlat(n, n, Array.from(data)),
+			lu: new DenseMatrix(n, n, data),
 			perm,
 			singular: false
 		};
@@ -1813,8 +1879,8 @@ var WASMBackend = class {
 			const qFlat = readAsFloat64Array(mod, qAlloc);
 			const rFlat = readAsFloat64Array(mod, rAlloc);
 			return {
-				q: DenseMatrix.fromFlat(m, m, Array.from(qFlat)),
-				r: DenseMatrix.fromFlat(m, n, Array.from(rFlat))
+				q: new DenseMatrix(m, m, qFlat),
+				r: new DenseMatrix(m, n, rFlat)
 			};
 		} finally {
 			this.allocCache.release(aAlloc);
@@ -1862,8 +1928,8 @@ var WASMBackend = class {
 			}
 		}
 		return {
-			q: DenseMatrix.fromFlat(m, m, Array.from(q)),
-			r: DenseMatrix.fromFlat(m, n, Array.from(r))
+			q: new DenseMatrix(m, m, q),
+			r: new DenseMatrix(m, n, r)
 		};
 	}
 	async inverse(a) {
@@ -1879,9 +1945,8 @@ var WASMBackend = class {
 				inverse: DenseMatrix.zeros(n, n),
 				singular: true
 			};
-			const result = readAsFloat64Array(mod, resultAlloc);
 			return {
-				inverse: DenseMatrix.fromFlat(n, n, Array.from(result)),
+				inverse: new DenseMatrix(n, n, readAsFloat64Array(mod, resultAlloc)),
 				singular: false
 			};
 		} finally {
@@ -1916,7 +1981,7 @@ var WASMBackend = class {
 			for (let i = 0; i < n; i++) result[i * n + col] = x[i];
 		}
 		return {
-			inverse: DenseMatrix.fromFlat(n, n, Array.from(result)),
+			inverse: new DenseMatrix(n, n, result),
 			singular: false
 		};
 	}
@@ -1966,9 +2031,8 @@ var WASMBackend = class {
 				l: DenseMatrix.zeros(n, n),
 				positiveDefinite: false
 			};
-			const result = readAsFloat64Array(mod, lAlloc);
 			return {
-				l: DenseMatrix.fromFlat(n, n, Array.from(result)),
+				l: new DenseMatrix(n, n, readAsFloat64Array(mod, lAlloc)),
 				positiveDefinite: true
 			};
 		} finally {
@@ -1993,7 +2057,7 @@ var WASMBackend = class {
 			} else l[i * n + j] = sum / l[j * n + j];
 		}
 		return {
-			l: DenseMatrix.fromFlat(n, n, Array.from(l)),
+			l: new DenseMatrix(n, n, l),
 			positiveDefinite: true
 		};
 	}
@@ -2524,7 +2588,6 @@ async function gpuOrJs(useGpu, js, gpu, executeWithFallback) {
 }
 //#endregion
 //#region src/backends/GPUMatrixBackend.ts
-init_DenseMatrix();
 const DEFAULT_CONFIG$1 = {
 	minElements: 65536,
 	useGlobalBackend: true,
@@ -2596,7 +2659,7 @@ var GPUMatrixBackend = class {
 			const aData = new Float32Array(a.toFloat64Array());
 			const bData = new Float32Array(b.toFloat64Array());
 			const result = await this.backend.add(aData, bData, a.rows, a.cols);
-			return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
+			return new DenseMatrix(a.rows, a.cols, new Float64Array(result));
 		}, (gpuOp, fallback) => this.executeWithFallback(gpuOp, fallback));
 	}
 	subtract(a, b) {
@@ -2624,7 +2687,7 @@ var GPUMatrixBackend = class {
 		return gpuOrJs(this.shouldUseGPU(elementCount), () => jsBackend.scale(a, scalar), async () => {
 			const aData = new Float32Array(a.toFloat64Array());
 			const result = await this.backend.scale(aData, scalar);
-			return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
+			return new DenseMatrix(a.rows, a.cols, new Float64Array(result));
 		}, (gpuOp, fallback) => this.executeWithFallback(gpuOp, fallback));
 	}
 	abs(a) {
@@ -2644,7 +2707,7 @@ var GPUMatrixBackend = class {
 			const aData = new Float32Array(a.toFloat64Array());
 			const bData = new Float32Array(b.toFloat64Array());
 			const result = await this.backend.matmul(aData, bData, a.rows, a.cols, b.cols);
-			return DenseMatrix.fromFlat(a.rows, b.cols, Array.from(result));
+			return new DenseMatrix(a.rows, b.cols, new Float64Array(result));
 		}, (gpuOp, fallback) => this.executeWithFallback(gpuOp, fallback));
 	}
 	transpose(a) {
@@ -2658,7 +2721,7 @@ var GPUMatrixBackend = class {
 		return this.executeWithFallback(async () => {
 			const aData = new Float32Array(a.toFloat64Array());
 			const result = await this.backend.transpose(aData, a.rows, a.cols);
-			return DenseMatrix.fromFlat(a.cols, a.rows, Array.from(result));
+			return new DenseMatrix(a.cols, a.rows, new Float64Array(result));
 		}, () => jsBackend.transpose(a));
 	}
 	sum(a) {
@@ -4513,7 +4576,6 @@ async function svdWasm(matrix, options) {
 }
 //#endregion
 //#region src/operations/pinv.ts
-init_DenseMatrix();
 function pinv(A, opts) {
 	const rcond = opts?.rcond ?? 1e-10;
 	const m = A.rows;
@@ -4533,7 +4595,6 @@ function pinv(A, opts) {
 }
 //#endregion
 //#region src/operations/qr.ts
-init_DenseMatrix();
 function qr(A, opts) {
 	const mode = opts?.mode ?? "reduced";
 	const m = A.rows;
@@ -4622,12 +4683,10 @@ function qr(A, opts) {
 }
 //#endregion
 //#region src/operations/lu.ts
-init_DenseMatrix();
 function lu(A) {
 	const n = A.rows;
 	if (A.cols !== n) throw new Error(`lu: matrix must be square (got ${A.rows}×${A.cols})`);
-	const flat = A.toFloat64Array();
-	const W = new Float64Array(flat);
+	const W = A.toFloat64Array();
 	const perm = new Array(n);
 	for (let i = 0; i < n; i++) perm[i] = i;
 	for (let k = 0; k < n; k++) {
@@ -4693,7 +4752,6 @@ function luSolve(fac, b) {
 }
 //#endregion
 //#region src/operations/cholesky.ts
-init_DenseMatrix();
 function cholesky(A) {
 	const n = A.rows;
 	if (A.cols !== n) throw new Error(`cholesky: matrix must be square (got ${A.rows}×${A.cols})`);
@@ -4715,7 +4773,6 @@ function cholesky(A) {
 }
 //#endregion
 //#region src/operations/expm.ts
-init_DenseMatrix();
 const THETA_13 = 5.371920351148152;
 const B = [
 	0xe6173304aa2000,
@@ -4777,7 +4834,6 @@ function matrixExpm(A) {
 }
 //#endregion
 //#region src/operations/schur.ts
-init_DenseMatrix();
 function hessenbergReduce(A) {
 	const n = A.length;
 	const H = cloneMatrix(A);
@@ -4987,7 +5043,6 @@ function schurInternal(A, maxIterations = 1e3, tolerance = 1e-12) {
 }
 //#endregion
 //#region src/operations/sqrtm.ts
-init_DenseMatrix();
 function symmetrize(A) {
 	const n = A.length;
 	return Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (A[i][j] + A[j][i]) / 2));
@@ -5189,7 +5244,6 @@ function matrixSqrtNewtonInternal(A) {
 }
 //#endregion
 //#region src/operations/logm.ts
-init_DenseMatrix();
 const GL16_NODES = [
 	.00529953674226076,
 	.02771248846338012,
@@ -5350,7 +5404,6 @@ function matrixLogm(A, opts) {
 }
 //#endregion
 //#region src/operations/qr-pivoted.ts
-init_DenseMatrix();
 function qrPivoted(A, opts) {
 	const m = A.rows;
 	const n = A.cols;
@@ -5423,7 +5476,6 @@ function qrPivoted(A, opts) {
 }
 //#endregion
 //#region src/operations/qr-family.ts
-init_DenseMatrix();
 function flipDense(M, axis) {
 	const m = M.rows;
 	const n = M.cols;
@@ -5550,7 +5602,6 @@ function condest(A, p = 1) {
 }
 //#endregion
 //#region src/typed-operations.ts
-init_DenseMatrix();
 const matrix = mathTyped("matrix", {
 	Array: (arr) => DenseMatrix.fromArray(arr),
 	"number, number": (rows, cols) => DenseMatrix.zeros(rows, cols),
@@ -5689,7 +5740,6 @@ const typedMatrixOperations = {
 };
 //#endregion
 //#region src/parallel-matrix.ts
-init_DenseMatrix();
 const computePool$1 = computePool;
 async function pSum(data) {
 	return computePool$1.sum(data);
@@ -6153,9 +6203,4 @@ async function terminateParallelMatrix() {
 	await computePool$1.terminate();
 }
 //#endregion
-//#region src/index.ts
-init_Matrix();
-init_SparseMatrix();
-init_DenseMatrix();
-//#endregion
 export { BUILTIN_SHADERS, BackendManager, BackendRegistry, BatchExecutor, BufferPool, DEFAULT_BACKEND_HINTS, DEFAULT_EXTENDED_HINTS, DenseMatrix, GPUBackend, GPUContext, GPUMatrixBackend, JSBackend, Matrix, ParallelBackend, ShaderManager, SparseMatrix, SyncManager, WASMBackend, abs, add, backendManager, backendRegistry, cholesky, clearFeatureCache, column, cond, condest, createBackendManager, createGPUMatrixBackend, createParallelBackend, createSyncManager, createWASMBackend, destroyGlobalGPU, destroyGlobalGPUBackend, detectGPUCapabilities, detectWasmFeatures, diag, diagonal, divide, dotMultiply, eig, eigWasm, eigvals, eigvalsWasm, exp, getCachedFeatures, getGlobalGPUBackend, getGlobalGPUContext, getRecommendedWorkgroupSize, gpuMatrixBackend, hasWebGPU, identity, initializeGlobalGPUBackend, initializeParallelMatrix, isAtomicsAvailable, isDenseMatrix, isMatrix, isSharedMemoryAvailable, isSparseMatrix, isWasmAvailable, jsBackend, log, lowRankApprox, lq, lu, luSolve, matMul, matrix, matrixExpm, matrixLogm, pinv as matrixPinv, matrixSchur, matrixSqrtm, max, mean, min, multiply, norm, norm2, normFro, ones, parallelBackend, parallelDiag, parallelDotMultiply, parallelIdentity, parallelMatrix, parallelMatrixAbs, parallelMatrixAdd, parallelMatrixColumn, parallelMatrixCos, parallelMatrixDiagonal, parallelMatrixDistance, parallelMatrixDivide, parallelMatrixDot, parallelMatrixExp, parallelMatrixHistogram, parallelMatrixLog, parallelMatrixMatvec, parallelMatrixMax, parallelMatrixMean, parallelMatrixMin, parallelMatrixMultiply, parallelMatrixNorm, parallelMatrixOperations, parallelMatrixOuter, parallelMatrixRow, parallelMatrixSin, parallelMatrixSize, parallelMatrixSqrt, parallelMatrixSquare, parallelMatrixStd, parallelMatrixSubset, parallelMatrixSubtract, parallelMatrixSum, parallelMatrixTan, parallelMatrixTrace, parallelMatrixTranspose, parallelMatrixVariance, parallelOnes, parallelRandom, parallelUnaryMinus, parallelZeros, pinv$1 as pinv, pow, powerIteration, ql, qr, qrPivoted, random, row, rq, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, transpose$1 as transposeNestedArray, typedMatrixOperations, unaryMinus, wasmBackend, zeros };