@danielsimonjr/mathts-matrix 0.7.9 → 0.8.1

package/dist/index.js

@@ -1,5 +1,6 @@
 import { BufferPool, BufferPool as BufferPool$1, GPUContext, GPUContext as GPUContext$1, GPU_MIN_ELEMENTS, ShaderManager, ShaderManager as ShaderManager$1, destroyGlobalGPU, detectGPUCapabilities, detectGPUCapabilities as detectGPUCapabilities$1, getGlobalGPUContext, getGlobalGPUContext as getGlobalGPUContext$1, getRecommendedWorkgroupSize, getRecommendedWorkgroupSize as getRecommendedWorkgroupSize$1, hasWebGPU, hasWebGPU as hasWebGPU$1 } from "@danielsimonjr/mathts-gpu";
 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;
@@ -136,8 +137,14 @@ function multiply$1(a, b) {
 		const ri = i * m;
 		for (let k = 0; k < p; k++) {
 			const aik = ad[ai + k];
-			if (aik === 0) continue;
 			const bk = k * m;
+			if (aik === 0) {
+				for (let j = 0; j < m; j++) {
+					const bij = bd[bk + j];
+					if (bij !== 0 && !Number.isFinite(bij)) result[ri + j] += aik * bij;
+				}
+				continue;
+			}
 			for (let j = 0; j < m; j++) result[ri + j] += aik * bd[bk + j];
 		}
 	}
@@ -680,6 +687,11 @@ var init_SparseMatrix = __esmMin((() => {
 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();
@@ -976,6 +988,7 @@ const backendRegistry = new BackendRegistry();
 //#endregion
 //#region src/backends/JSBackend.ts
 init_DenseMatrix();
+init_reduction();
 var JSBackend = class {
 	type = "js";
 	isAvailable() {
@@ -1024,10 +1037,17 @@ var JSBackend = class {
 		const m = a.rows;
 		const n = b.cols;
 		const k = a.cols;
+		const ad = denseContiguousData(a);
+		const bd = denseContiguousData(b);
 		const result = new Float64Array(m * n);
-		for (let i = 0; i < m; i++) for (let p = 0; p < k; p++) {
-			const aip = a.get(i, p);
-			for (let j = 0; j < n; j++) result[i * n + j] += aip * b.get(p, j);
+		for (let i = 0; i < m; i++) {
+			const ai = i * k;
+			const ri = i * n;
+			for (let p = 0; p < k; p++) {
+				const aip = ad[ai + p];
+				const bp = p * n;
+				for (let j = 0; j < n; j++) result[ri + j] += aip * bd[bp + j];
+			}
 		}
 		return new DenseMatrix(m, n, result);
 	}
@@ -1053,12 +1073,7 @@ var JSBackend = class {
 		}
 	}
 	norm(a) {
-		let sumSq = 0;
-		for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) {
-			const val = a.get(i, j);
-			sumSq += val * val;
-		}
-		return Math.sqrt(sumSq);
+		return norm$1(a);
 	}
 	dot(a, b) {
 		if (!a.isVector || !b.isVector) throw new Error("Dot product requires two vectors");
@@ -1105,51 +1120,24 @@ var ParallelBackend = class {
 		return elementCount >= this.parallelThreshold;
 	}
 	async add(a, b) {
-		this.checkDimensionsMatch(a, b);
-		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) return a.add(b);
-		const aData = a.toFloat64Array();
-		const bData = b.toFloat64Array();
-		const result = await this.pool.elementwise(aData, bData, "add");
-		return new DenseMatrix(a.rows, a.cols, result.result);
+		return this.parallelBinary(a, b, "add", (x, y) => x.add(y));
 	}
 	async subtract(a, b) {
-		this.checkDimensionsMatch(a, b);
-		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) return a.subtract(b);
-		const aData = a.toFloat64Array();
-		const bData = b.toFloat64Array();
-		const result = await this.pool.elementwise(aData, bData, "subtract");
-		return new DenseMatrix(a.rows, a.cols, result.result);
+		return this.parallelBinary(a, b, "subtract", (x, y) => x.subtract(y));
 	}
 	async multiplyElementwise(a, b) {
-		this.checkDimensionsMatch(a, b);
-		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) return a.multiplyElementwise(b);
-		const aData = a.toFloat64Array();
-		const bData = b.toFloat64Array();
-		const result = await this.pool.elementwise(aData, bData, "multiply");
-		return new DenseMatrix(a.rows, a.cols, result.result);
+		return this.parallelBinary(a, b, "multiply", (x, y) => x.multiplyElementwise(y));
 	}
 	async divideElementwise(a, b) {
-		this.checkDimensionsMatch(a, b);
-		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) {
-			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);
-			return new DenseMatrix(a.rows, a.cols, result);
-		}
-		const aData = a.toFloat64Array();
-		const bData = b.toFloat64Array();
-		const result = await this.pool.elementwise(aData, bData, "divide");
-		return new DenseMatrix(a.rows, a.cols, result.result);
+		return this.parallelBinary(a, b, "divide", (x, y) => jsBackend.divideElementwise(x, y));
 	}
 	async scale(a, scalar) {
 		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) return a.scale(scalar);
-		const aData = a.toFloat64Array();
-		const result = await this.pool.scale(aData, scalar);
-		return new DenseMatrix(a.rows, a.cols, result.result);
+		return this.whenParallel(elementCount, () => a.scale(scalar), async () => {
+			const aData = a.toFloat64Array();
+			const result = await this.pool.scale(aData, scalar);
+			return new DenseMatrix(a.rows, a.cols, result.result);
+		});
 	}
 	abs(a) {
 		return a.map((v) => Math.abs(v));
@@ -1160,35 +1148,30 @@ var ParallelBackend = class {
 	async multiply(a, b) {
 		this.checkMultiplyDimensions(a, b);
 		const resultSize = a.rows * b.cols;
-		if (!this.shouldParallelize(resultSize) || !this.isReady()) return a.multiply(b);
-		const aData = a.toFloat64Array();
-		const bData = b.toFloat64Array();
-		const result = await this.pool.matmul(aData, a.rows, a.cols, bData, b.cols);
-		return new DenseMatrix(a.rows, b.cols, result.result);
+		return this.whenParallel(resultSize, () => a.multiply(b), async () => {
+			const aData = a.toFloat64Array();
+			const bData = b.toFloat64Array();
+			const result = await this.pool.matmul(aData, a.rows, a.cols, bData, b.cols);
+			return new DenseMatrix(a.rows, b.cols, result.result);
+		});
 	}
 	async transpose(a) {
 		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) return a.transpose();
-		const aData = a.toFloat64Array();
-		const result = await this.pool.transpose(aData, a.rows, a.cols);
-		return new DenseMatrix(a.cols, a.rows, result.result);
+		return this.whenParallel(elementCount, () => a.transpose(), async () => {
+			const aData = a.toFloat64Array();
+			const result = await this.pool.transpose(aData, a.rows, a.cols);
+			return new DenseMatrix(a.cols, a.rows, result.result);
+		});
 	}
 	async sum(a) {
 		const elementCount = a.rows * a.cols;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) return a.sum();
-		const aData = a.toFloat64Array();
-		return (await this.pool.sum(aData)).result;
+		return this.whenParallel(elementCount, () => a.sum(), async () => {
+			const aData = a.toFloat64Array();
+			return (await this.pool.sum(aData)).result;
+		});
 	}
 	sumAxis(a, axis) {
-		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);
-		} 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);
-		}
+		return jsBackend.sumAxis(a, axis);
 	}
 	norm(a) {
 		return a.norm();
@@ -1197,16 +1180,11 @@ var ParallelBackend = 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}`);
 		const elementCount = a.length;
-		if (!this.shouldParallelize(elementCount) || !this.isReady()) {
-			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];
-			return sum;
-		}
-		const aData = a.toFloat64Array();
-		const bData = b.toFloat64Array();
-		return (await this.pool.dot(aData, bData)).result;
+		return this.whenParallel(elementCount, () => jsBackend.dot(a, b), async () => {
+			const aData = a.toFloat64Array();
+			const bData = b.toFloat64Array();
+			return (await this.pool.dot(aData, bData)).result;
+		});
 	}
 	async terminate() {
 		if (this.initialized) {
@@ -1217,6 +1195,19 @@ var ParallelBackend = class {
 	getStats() {
 		return this.pool.stats();
 	}
+	whenParallel(elementCount, sequential, parallel) {
+		if (!this.shouldParallelize(elementCount) || !this.isReady()) return sequential();
+		return parallel();
+	}
+	async parallelBinary(a, b, op, sequential) {
+		this.checkDimensionsMatch(a, b);
+		const elementCount = a.rows * a.cols;
+		if (!this.shouldParallelize(elementCount) || !this.isReady()) return sequential(a, b);
+		const aData = a.toFloat64Array();
+		const bData = b.toFloat64Array();
+		const result = await this.pool.elementwise(aData, bData, op);
+		return new DenseMatrix(a.rows, a.cols, result.result);
+	}
 	checkDimensionsMatch(a, b) {
 		if (a.rows !== b.rows || a.cols !== b.cols) throw new Error(`Matrix dimensions must match: ${a.rows}×${a.cols} vs ${b.rows}×${b.cols}`);
 	}
@@ -1489,14 +1480,20 @@ function getCachedFeatures() {
 	return cachedFeatures;
 }
 //#endregion
+//#region src/backends/wasm/as-typed-array.ts
+function allocAsTypedView(module, byteLength, length, typeId, Ctor) {
+	const { headerPtr, bufferPtr } = allocAsHeader(module, byteLength, typeId);
+	return {
+		headerPtr,
+		bufferPtr,
+		view: new Ctor(module.memory.buffer, bufferPtr, length),
+		byteLength,
+		length
+	};
+}
+//#endregion
 //#region src/backends/WASMBackend.ts
 init_DenseMatrix();
-const AS_ID_ARRAY_BUFFER$1 = 1;
-const AS_ID_FLOAT64_ARRAY$1 = 5;
-const AS_ID_INT32_ARRAY$1 = 6;
-const AS_F64_ALIGN_SHIFT = 3;
-const AS_I32_ALIGN_SHIFT = 2;
-const AS_HEADER_BYTES$1 = 12;
 var AsAllocCache = class {
 	free = /* @__PURE__ */ new Map();
 	acquire(module, length) {
@@ -1517,22 +1514,22 @@ var AsAllocCache = class {
 		pool.push(alloc);
 	}
 	allocate(module, length) {
-		const byteLength = length << AS_F64_ALIGN_SHIFT;
-		const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER$1)) >>> 0;
-		const headerPtr = module.__new(AS_HEADER_BYTES$1, AS_ID_FLOAT64_ARRAY$1) >>> 0;
-		module.__pin(headerPtr);
-		const dv = new DataView(module.memory.buffer);
-		dv.setUint32(headerPtr + 0, bufferPtr, true);
-		dv.setUint32(headerPtr + 4, bufferPtr, true);
-		dv.setUint32(headerPtr + 8, byteLength, true);
-		return {
-			headerPtr,
-			bufferPtr,
-			view: new Float64Array(module.memory.buffer, bufferPtr, length),
-			length
-		};
+		return allocHeader(module, length, {
+			shift: 3,
+			typeId: 5,
+			Ctor: Float64Array
+		});
 	}
 };
+function allocHeader(module, length, opts) {
+	const { headerPtr, bufferPtr, view } = allocAsTypedView(module, length << opts.shift, length, opts.typeId, opts.Ctor);
+	return {
+		headerPtr,
+		bufferPtr,
+		view,
+		length
+	};
+}
 function writeAsFloat64Array(cache, module, data) {
 	const alloc = cache.acquire(module, data.length);
 	alloc.view.set(data);
@@ -1546,20 +1543,11 @@ function readAsFloat64Array(module, alloc) {
 	return new Float64Array(view);
 }
 function allocAsInt32Array(module, length) {
-	const byteLength = length << AS_I32_ALIGN_SHIFT;
-	const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER$1)) >>> 0;
-	const headerPtr = module.__new(AS_HEADER_BYTES$1, AS_ID_INT32_ARRAY$1) >>> 0;
-	module.__pin(headerPtr);
-	const dv = new DataView(module.memory.buffer);
-	dv.setUint32(headerPtr + 0, bufferPtr, true);
-	dv.setUint32(headerPtr + 4, bufferPtr, true);
-	dv.setUint32(headerPtr + 8, byteLength, true);
-	return {
-		headerPtr,
-		bufferPtr,
-		view: new Int32Array(module.memory.buffer, bufferPtr, length),
-		length
-	};
+	return allocHeader(module, length, {
+		shift: 2,
+		typeId: 6,
+		Ctor: Int32Array
+	});
 }
 function readAsInt32Array(module, alloc) {
 	const view = new Int32Array(module.memory.buffer, alloc.bufferPtr, alloc.length);
@@ -2190,6 +2178,165 @@ function registerBuiltinShaders(sm) {
 	for (const [name, code] of Object.entries(BUILTIN_SHADERS)) sm.registerShader(name, code);
 }
 //#endregion
+//#region src/backends/gpu/run-shader.ts
+const UNIFORM_BYTES = 16;
+function planRunShaderFromAdd(a, b, rows, cols, workgroups) {
+	const size = rows * cols * 4;
+	return {
+		pipeline: "matrixAdd",
+		bytes: [
+			size,
+			size,
+			size
+		],
+		storageLabels: [
+			"matrix-a",
+			"matrix-b",
+			"matrix-result"
+		],
+		writes: [a, b],
+		bindEntries: [
+			{
+				binding: 0,
+				bufferIndex: 0
+			},
+			{
+				binding: 1,
+				bufferIndex: 1
+			},
+			{
+				binding: 2,
+				bufferIndex: 2
+			},
+			{
+				binding: 3,
+				bufferIndex: -1
+			}
+		],
+		params: new Uint32Array([
+			rows,
+			cols,
+			0,
+			0
+		]),
+		workgroups,
+		resultBufferIndex: 2
+	};
+}
+function planRunShaderFromMatmul(a, b, M, K, N, workgroups) {
+	return {
+		pipeline: "matmul",
+		bytes: [
+			M * K * 4,
+			K * N * 4,
+			M * N * 4
+		],
+		storageLabels: [
+			"matmul-a",
+			"matmul-b",
+			"matmul-result"
+		],
+		writes: [a, b],
+		bindEntries: [
+			{
+				binding: 0,
+				bufferIndex: 0
+			},
+			{
+				binding: 1,
+				bufferIndex: 1
+			},
+			{
+				binding: 2,
+				bufferIndex: 2
+			},
+			{
+				binding: 3,
+				bufferIndex: -1
+			}
+		],
+		params: new Uint32Array([
+			M,
+			N,
+			K,
+			0
+		]),
+		workgroups,
+		resultBufferIndex: 2
+	};
+}
+function planRunShaderFromTranspose(a, rows, cols, workgroups) {
+	const size = rows * cols * 4;
+	return {
+		pipeline: "transpose",
+		bytes: [size, size],
+		storageLabels: ["transpose-a", "transpose-result"],
+		writes: [a],
+		bindEntries: [
+			{
+				binding: 0,
+				bufferIndex: 0
+			},
+			{
+				binding: 1,
+				bufferIndex: 1
+			},
+			{
+				binding: 2,
+				bufferIndex: -1
+			}
+		],
+		params: new Uint32Array([
+			rows,
+			cols,
+			0,
+			0
+		]),
+		workgroups,
+		resultBufferIndex: 1
+	};
+}
+async function runShader(backend, plan) {
+	const ctx = backend.getContext();
+	const pool = backend.getBufferPool();
+	const shaders = backend.getShaderManager();
+	const storageBuffers = [];
+	let bufferParams;
+	try {
+		for (let idx = 0; idx < plan.bytes.length; idx++) {
+			const byteSize = plan.bytes[idx];
+			if (byteSize === void 0) throw new Error(`runShader: missing byte size at index ${idx}`);
+			storageBuffers.push(pool.acquireStorageBuffer(byteSize, plan.storageLabels[idx] ?? `storage-${idx}`, true, idx !== plan.resultBufferIndex));
+		}
+		bufferParams = pool.acquireUniformBuffer(UNIFORM_BYTES, "params");
+		for (let i = 0; i < plan.writes.length; i++) {
+			const target = storageBuffers[i];
+			const payload = plan.writes[i];
+			if (target === void 0 || payload === void 0) throw new Error(`runShader: missing write target at index ${i}`);
+			ctx.writeBuffer(target, payload);
+		}
+		ctx.writeBuffer(bufferParams, plan.params);
+		const pipeline = shaders.getRegisteredPipeline(plan.pipeline);
+		const bindResources = plan.bindEntries.map((entry) => {
+			const buffer = entry.bufferIndex === -1 ? bufferParams : storageBuffers[entry.bufferIndex];
+			if (buffer === void 0) throw new Error(`runShader: missing buffer for binding ${entry.binding}`);
+			return {
+				binding: entry.binding,
+				resource: { buffer }
+			};
+		});
+		const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), bindResources);
+		ctx.dispatchCompute(pipeline, [bindGroup], plan.workgroups);
+		const resultBuf = storageBuffers[plan.resultBufferIndex];
+		if (resultBuf === void 0) throw new Error(`runShader: missing result buffer at index ${plan.resultBufferIndex}`);
+		const resultData = await ctx.readBuffer(resultBuf);
+		return new Float32Array(resultData);
+	} finally {
+		for (const buf of storageBuffers) pool.release(buf);
+		if (bufferParams !== void 0) pool.release(bufferParams);
+	}
+}
+//#endregion
 //#region src/backends/GPUBackend.ts
 const DEFAULT_THRESHOLD = 256;
 var GPUBackend = class {
@@ -2283,131 +2430,13 @@ var GPUBackend = class {
 		return this.shaderManager;
 	}
 	async add(a, b, rows, cols) {
-		const ctx = this.getContext();
-		const pool = this.getBufferPool();
-		const shaders = this.getShaderManager();
-		const size = rows * cols * 4;
-		const bufferA = pool.acquireStorageBuffer(size, "matrix-a", true, true);
-		const bufferB = pool.acquireStorageBuffer(size, "matrix-b", true, true);
-		const bufferResult = pool.acquireStorageBuffer(size, "matrix-result", true, false);
-		const bufferParams = pool.acquireUniformBuffer(16, "params");
-		ctx.writeBuffer(bufferA, a);
-		ctx.writeBuffer(bufferB, b);
-		ctx.writeBuffer(bufferParams, new Uint32Array([
-			rows,
-			cols,
-			0,
-			0
-		]));
-		const pipeline = shaders.getRegisteredPipeline("matrixAdd");
-		const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-			{
-				binding: 0,
-				resource: { buffer: bufferA }
-			},
-			{
-				binding: 1,
-				resource: { buffer: bufferB }
-			},
-			{
-				binding: 2,
-				resource: { buffer: bufferResult }
-			},
-			{
-				binding: 3,
-				resource: { buffer: bufferParams }
-			}
-		]);
-		ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(rows, cols));
-		const resultData = await ctx.readBuffer(bufferResult);
-		pool.release(bufferA);
-		pool.release(bufferB);
-		pool.release(bufferResult);
-		pool.release(bufferParams);
-		return new Float32Array(resultData);
+		return runShader(this, planRunShaderFromAdd(a, b, rows, cols, this.calculateWorkgroups(rows, cols)));
 	}
 	async matmul(a, b, M, K, N) {
-		const ctx = this.getContext();
-		const pool = this.getBufferPool();
-		const shaders = this.getShaderManager();
-		const sizeA = M * K * 4;
-		const sizeB = K * N * 4;
-		const sizeResult = M * N * 4;
-		const bufferA = pool.acquireStorageBuffer(sizeA, "matmul-a", true, true);
-		const bufferB = pool.acquireStorageBuffer(sizeB, "matmul-b", true, true);
-		const bufferResult = pool.acquireStorageBuffer(sizeResult, "matmul-result", true, false);
-		const bufferParams = pool.acquireUniformBuffer(16, "params");
-		ctx.writeBuffer(bufferA, a);
-		ctx.writeBuffer(bufferB, b);
-		ctx.writeBuffer(bufferParams, new Uint32Array([
-			M,
-			N,
-			K,
-			0
-		]));
-		const pipeline = shaders.getRegisteredPipeline("matmul");
-		const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-			{
-				binding: 0,
-				resource: { buffer: bufferA }
-			},
-			{
-				binding: 1,
-				resource: { buffer: bufferB }
-			},
-			{
-				binding: 2,
-				resource: { buffer: bufferResult }
-			},
-			{
-				binding: 3,
-				resource: { buffer: bufferParams }
-			}
-		]);
-		ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(M, N));
-		const resultData = await ctx.readBuffer(bufferResult);
-		pool.release(bufferA);
-		pool.release(bufferB);
-		pool.release(bufferResult);
-		pool.release(bufferParams);
-		return new Float32Array(resultData);
+		return runShader(this, planRunShaderFromMatmul(a, b, M, K, N, this.calculateWorkgroups(M, N)));
 	}
 	async transpose(a, rows, cols) {
-		const ctx = this.getContext();
-		const pool = this.getBufferPool();
-		const shaders = this.getShaderManager();
-		const size = rows * cols * 4;
-		const bufferA = pool.acquireStorageBuffer(size, "transpose-a", true, true);
-		const bufferResult = pool.acquireStorageBuffer(size, "transpose-result", true, false);
-		const bufferParams = pool.acquireUniformBuffer(16, "params");
-		ctx.writeBuffer(bufferA, a);
-		ctx.writeBuffer(bufferParams, new Uint32Array([
-			rows,
-			cols,
-			0,
-			0
-		]));
-		const pipeline = shaders.getRegisteredPipeline("transpose");
-		const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-			{
-				binding: 0,
-				resource: { buffer: bufferA }
-			},
-			{
-				binding: 1,
-				resource: { buffer: bufferResult }
-			},
-			{
-				binding: 2,
-				resource: { buffer: bufferParams }
-			}
-		]);
-		ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(rows, cols));
-		const resultData = await ctx.readBuffer(bufferResult);
-		pool.release(bufferA);
-		pool.release(bufferResult);
-		pool.release(bufferParams);
-		return new Float32Array(resultData);
+		return runShader(this, planRunShaderFromTranspose(a, rows, cols, this.calculateWorkgroups(rows, cols)));
 	}
 	async scale(a, scalar) {
 		const ctx = this.getContext();
@@ -2488,6 +2517,12 @@ function destroyGlobalGPUBackend() {
 	}
 }
 //#endregion
+//#region src/backends/gpu/gpu-or-js.ts
+async function gpuOrJs(useGpu, js, gpu, executeWithFallback) {
+	if (!useGpu) return js();
+	return executeWithFallback(gpu, js);
+}
+//#endregion
 //#region src/backends/GPUMatrixBackend.ts
 init_DenseMatrix();
 const DEFAULT_CONFIG$1 = {
@@ -2557,13 +2592,12 @@ var GPUMatrixBackend = class {
 	}
 	async addAsync(a, b) {
 		const elementCount = a.rows * a.cols;
-		if (!this.shouldUseGPU(elementCount)) return jsBackend.add(a, b);
-		return this.executeWithFallback(async () => {
+		return gpuOrJs(this.shouldUseGPU(elementCount), () => jsBackend.add(a, b), async () => {
 			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));
-		}, () => jsBackend.add(a, b));
+		}, (gpuOp, fallback) => this.executeWithFallback(gpuOp, fallback));
 	}
 	subtract(a, b) {
 		const elementCount = a.rows * a.cols;
@@ -2587,12 +2621,11 @@ var GPUMatrixBackend = class {
 	}
 	async scaleAsync(a, scalar) {
 		const elementCount = a.rows * a.cols;
-		if (!this.shouldUseGPU(elementCount)) return jsBackend.scale(a, scalar);
-		return this.executeWithFallback(async () => {
+		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));
-		}, () => jsBackend.scale(a, scalar));
+		}, (gpuOp, fallback) => this.executeWithFallback(gpuOp, fallback));
 	}
 	abs(a) {
 		return jsBackend.abs(a);
@@ -2607,13 +2640,12 @@ var GPUMatrixBackend = class {
 	}
 	async multiplyAsync(a, b) {
 		const elementCount = a.rows * b.cols * a.cols;
-		if (!this.shouldUseGPU(elementCount)) return jsBackend.multiply(a, b);
-		return this.executeWithFallback(async () => {
+		return gpuOrJs(this.shouldUseGPU(elementCount), () => jsBackend.multiply(a, b), async () => {
 			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));
-		}, () => jsBackend.multiply(a, b));
+		}, (gpuOp, fallback) => this.executeWithFallback(gpuOp, fallback));
 	}
 	transpose(a) {
 		const elementCount = a.rows * a.cols;
@@ -2659,7 +2691,9 @@ const gpuMatrixBackend = new GPUMatrixBackend();
 function createGPUMatrixBackend(config) {
 	return new GPUMatrixBackend(config);
 }
-let currentConfig = {
+//#endregion
+//#region src/config.ts
+const DEFAULT_CONFIG = {
 	backends: {
 		js: {
 			enabled: true,
@@ -2670,21 +2704,21 @@ let currentConfig = {
 		wasm: {
 			enabled: true,
 			preference: "auto",
-			threshold: 1e3,
+			threshold: DEFAULT_BACKEND_HINTS.wasmThreshold,
 			operationThresholds: {
-				multiply: 500,
+				multiply: 256,
 				decomposition: 100,
 				transpose: 2e3
 			}
 		},
 		gpu: {
-			enabled: true,
+			enabled: false,
 			preference: "auto",
-			threshold: 1e5,
+			threshold: DEFAULT_BACKEND_HINTS.gpuThreshold,
 			operationThresholds: {
-				multiply: 5e4,
-				decomposition: 1e4,
-				transpose: 2e5
+				multiply: DEFAULT_BACKEND_HINTS.gpuThreshold,
+				decomposition: DEFAULT_BACKEND_HINTS.gpuThreshold,
+				transpose: DEFAULT_BACKEND_HINTS.gpuThreshold
 			}
 		}
 	},
@@ -2703,6 +2737,7 @@ let currentConfig = {
 	precision: "double",
 	debug: false
 };
+let currentConfig = { ...DEFAULT_CONFIG };
 const listeners = /* @__PURE__ */ new Set();
 function getConfig() {
 	return currentConfig;
@@ -2717,25 +2752,33 @@ backendRegistry.register(jsBackend);
 backendRegistry.register(wasmBackend);
 //#endregion
 //#region src/backends/BackendManager.ts
-const DEFAULT_EXTENDED_HINTS = {
-	...DEFAULT_BACKEND_HINTS,
-	operationThresholds: {
-		multiply: {
-			wasm: 256,
-			gpu: GPU_MIN_ELEMENTS
-		},
-		decomposition: {
-			wasm: 100,
-			gpu: GPU_MIN_ELEMENTS
+function extendedHintsFromConfig(config) {
+	const { wasm, gpu } = config.backends;
+	const wasmOps = wasm.operationThresholds ?? {};
+	const gpuOps = gpu.operationThresholds ?? {};
+	return {
+		wasmThreshold: wasm.threshold,
+		gpuThreshold: gpu.threshold,
+		preferredBackend: DEFAULT_BACKEND_HINTS.preferredBackend,
+		operationThresholds: {
+			multiply: {
+				wasm: wasmOps.multiply ?? wasm.threshold,
+				gpu: gpuOps.multiply ?? gpu.threshold
+			},
+			decomposition: {
+				wasm: wasmOps.decomposition ?? wasm.threshold,
+				gpu: gpuOps.decomposition ?? gpu.threshold
+			},
+			transpose: {
+				wasm: wasmOps.transpose ?? wasm.threshold,
+				gpu: gpuOps.transpose ?? gpu.threshold
+			}
 		},
-		transpose: {
-			wasm: 2e3,
-			gpu: GPU_MIN_ELEMENTS
-		}
-	},
-	autoSIMD: true,
-	fallbackOnError: true
-};
+		autoSIMD: true,
+		fallbackOnError: true
+	};
+}
+const DEFAULT_EXTENDED_HINTS = extendedHintsFromConfig(DEFAULT_CONFIG);
 var BackendManager = class {
 	hints;
 	initialized = false;
@@ -3018,387 +3061,6 @@ function createBackendManager(hints) {
 	return new BackendManager(hints);
 }
 //#endregion
-//#region src/backends/WasmLoader.ts
-const AS_ID_ARRAY_BUFFER = 1;
-const AS_ID_INT32_ARRAY = 4;
-const AS_ID_FLOAT64_ARRAY = 5;
-const AS_HEADER_BYTES = 12;
-(class WasmLoader {
-	static instance = null;
-	wasmModule = null;
-	compiledModule = null;
-	loading = null;
-	isNode;
-	lastMetrics = null;
-	float64Pool = [];
-	int32Pool = [];
-	poolSizeThreshold = 1048576;
-	constructor() {
-		this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-	}
-	static getInstance() {
-		if (!WasmLoader.instance) WasmLoader.instance = new WasmLoader();
-		return WasmLoader.instance;
-	}
-	async load(wasmPath) {
-		if (this.wasmModule) return this.wasmModule;
-		if (this.loading) return this.loading;
-		this.loading = this.loadModule(wasmPath);
-		try {
-			this.wasmModule = await this.loading;
-		} catch (error) {
-			this.compiledModule = null;
-			throw error;
-		} finally {
-			this.loading = null;
-		}
-		return this.wasmModule;
-	}
-	async precompile(wasmPath) {
-		if (this.compiledModule) return;
-		const path = wasmPath || await this.getDefaultWasmPath();
-		const startTime = performance.now();
-		const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-Hbf0W3mK.js");
-		if (this.isNode) {
-			const fs = await import("fs");
-			const { promisify } = await import("util");
-			const buffer = await promisify(fs.readFile)(path);
-			await verifyWasmIntegrity(buffer, path);
-			this.compiledModule = await WebAssembly.compile(buffer);
-		} else {
-			const manifest = await loadWasmManifest(path);
-			if (!manifest && typeof WebAssembly.compileStreaming === "function") this.compiledModule = await WebAssembly.compileStreaming(fetch(path));
-			else {
-				const buffer = await (await fetch(path)).arrayBuffer();
-				await verifyWasmIntegrity(buffer, path, { manifest });
-				this.compiledModule = await WebAssembly.compile(buffer);
-			}
-		}
-		this.lastMetrics = {
-			fileReadMs: 0,
-			compileMs: performance.now() - startTime,
-			instantiateMs: 0,
-			totalMs: performance.now() - startTime,
-			fromCache: false
-		};
-	}
-	async loadModule(wasmPath) {
-		const path = wasmPath || await this.getDefaultWasmPath();
-		const totalStart = performance.now();
-		if (this.compiledModule) {
-			const instStart = performance.now();
-			const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
-			this.lastMetrics = {
-				fileReadMs: 0,
-				compileMs: 0,
-				instantiateMs: performance.now() - instStart,
-				totalMs: performance.now() - totalStart,
-				fromCache: true
-			};
-			return instance.exports;
-		}
-		if (this.isNode) return this.loadNodeWasm(path, totalStart);
-		else return this.loadBrowserWasm(path, totalStart);
-	}
-	async getDefaultWasmPath() {
-		const wasmFile = "mathts-as.wasm";
-		if (this.isNode) {
-			const { resolvePackagedWasm } = await import("./resolve-BzZxSO28.js");
-			const found = await resolvePackagedWasm(import.meta.url, wasmFile);
-			if (found) return found;
-			const { defaultWasmLocation } = await import("./resolve-BzZxSO28.js");
-			return defaultWasmLocation(import.meta.url, wasmFile);
-		}
-		const { defaultWasmLocation } = await import("./resolve-BzZxSO28.js");
-		return defaultWasmLocation(import.meta.url, wasmFile, { browser: true });
-	}
-	async loadNodeWasm(path, totalStart) {
-		const fs = await import("fs");
-		const { promisify } = await import("util");
-		const readFile = promisify(fs.readFile);
-		const { verifyWasmIntegrity } = await import("./integrity-Hbf0W3mK.js");
-		const readStart = performance.now();
-		const buffer = await readFile(path);
-		const readEnd = performance.now();
-		await verifyWasmIntegrity(buffer, path);
-		const compileStart = performance.now();
-		this.compiledModule = await WebAssembly.compile(buffer);
-		const compileEnd = performance.now();
-		const instStart = performance.now();
-		const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
-		const instEnd = performance.now();
-		this.lastMetrics = {
-			fileReadMs: readEnd - readStart,
-			compileMs: compileEnd - compileStart,
-			instantiateMs: instEnd - instStart,
-			totalMs: performance.now() - totalStart,
-			fromCache: false
-		};
-		return instance.exports;
-	}
-	async loadBrowserWasm(path, totalStart) {
-		const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-Hbf0W3mK.js");
-		const manifest = await loadWasmManifest(path);
-		if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
-			const instStart = performance.now();
-			const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
-			this.compiledModule = result.module;
-			this.lastMetrics = {
-				fileReadMs: 0,
-				compileMs: 0,
-				instantiateMs: performance.now() - instStart,
-				totalMs: performance.now() - totalStart,
-				fromCache: false
-			};
-			return result.instance.exports;
-		}
-		const readStart = performance.now();
-		const buffer = await (await fetch(path)).arrayBuffer();
-		const readEnd = performance.now();
-		await verifyWasmIntegrity(buffer, path, { manifest });
-		const compileStart = performance.now();
-		this.compiledModule = await WebAssembly.compile(buffer);
-		const compileEnd = performance.now();
-		const instStart = performance.now();
-		const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
-		const instEnd = performance.now();
-		this.lastMetrics = {
-			fileReadMs: readEnd - readStart,
-			compileMs: compileEnd - compileStart,
-			instantiateMs: instEnd - instStart,
-			totalMs: performance.now() - totalStart,
-			fromCache: false
-		};
-		return instance.exports;
-	}
-	getImports() {
-		return {
-			env: {
-				abort: (msg, file, line, column) => {
-					console.error("WASM abort", {
-						msg,
-						file,
-						line,
-						column
-					});
-					throw new Error("WASM abort");
-				},
-				seed: () => Date.now()
-			},
-			Math,
-			Date
-		};
-	}
-	getModule() {
-		return this.wasmModule;
-	}
-	getCompiledModule() {
-		return this.compiledModule;
-	}
-	isLoaded() {
-		return this.wasmModule !== null;
-	}
-	isPrecompiled() {
-		return this.compiledModule !== null;
-	}
-	getLoadingMetrics() {
-		return this.lastMetrics;
-	}
-	allocateFloat64Array(data) {
-		const module = this.wasmModule;
-		if (!module) throw new Error("WASM module not loaded");
-		const length = data.length;
-		const alloc = this.allocateAsFloat64(module, length);
-		alloc.array.set(data);
-		return alloc;
-	}
-	readReturnedFloat64Array(headerPtr) {
-		const module = this.wasmModule;
-		if (!module) throw new Error("WASM module not loaded");
-		const hdr = headerPtr >>> 0;
-		const dv = new DataView(module.memory.buffer);
-		const dataStart = dv.getUint32(hdr + 4, true);
-		const byteLength = dv.getUint32(hdr + 8, true);
-		const view = new Float64Array(module.memory.buffer, dataStart, byteLength >>> 3);
-		return new Float64Array(view);
-	}
-	allocateFloat64ArrayEmpty(length) {
-		const module = this.wasmModule;
-		if (!module) throw new Error("WASM module not loaded");
-		const alloc = this.allocateAsFloat64(module, length);
-		alloc.array.fill(0);
-		return alloc;
-	}
-	allocateInt32Array(data) {
-		const module = this.wasmModule;
-		if (!module) throw new Error("WASM module not loaded");
-		const length = data.length;
-		const alloc = this.allocateAsInt32(module, length);
-		alloc.array.set(data);
-		return alloc;
-	}
-	allocateInt32ArrayEmpty(length) {
-		const module = this.wasmModule;
-		if (!module) throw new Error("WASM module not loaded");
-		const alloc = this.allocateAsInt32(module, length);
-		alloc.array.fill(0);
-		return alloc;
-	}
-	allocateAsFloat64(module, length) {
-		const byteLength = length * 8;
-		if (byteLength <= this.poolSizeThreshold) {
-			const recycled = this.acquireFromAsPool(module, this.float64Pool, byteLength);
-			if (recycled) {
-				const array = new Float64Array(module.memory.buffer, recycled.dataPtr, length);
-				return {
-					ptr: recycled.ptr,
-					dataPtr: recycled.dataPtr,
-					array,
-					length
-				};
-			}
-		}
-		return this.makeAsFloat64(module, length);
-	}
-	allocateAsInt32(module, length) {
-		const byteLength = length * 4;
-		if (byteLength <= this.poolSizeThreshold) {
-			const recycled = this.acquireFromAsPool(module, this.int32Pool, byteLength);
-			if (recycled) {
-				const array = new Int32Array(module.memory.buffer, recycled.dataPtr, length);
-				return {
-					ptr: recycled.ptr,
-					dataPtr: recycled.dataPtr,
-					array,
-					length
-				};
-			}
-		}
-		return this.makeAsInt32(module, length);
-	}
-	makeAsFloat64(module, length) {
-		const byteLength = length * 8;
-		const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER)) >>> 0;
-		const headerPtr = module.__new(AS_HEADER_BYTES, AS_ID_FLOAT64_ARRAY) >>> 0;
-		module.__pin(headerPtr);
-		const dv = new DataView(module.memory.buffer);
-		dv.setUint32(headerPtr + 0, bufferPtr, true);
-		dv.setUint32(headerPtr + 4, bufferPtr, true);
-		dv.setUint32(headerPtr + 8, byteLength, true);
-		const array = new Float64Array(module.memory.buffer, bufferPtr, length);
-		this.track(this.float64Pool, headerPtr, bufferPtr, byteLength);
-		return {
-			ptr: headerPtr,
-			dataPtr: bufferPtr,
-			array,
-			length
-		};
-	}
-	makeAsInt32(module, length) {
-		const byteLength = length * 4;
-		const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER)) >>> 0;
-		const headerPtr = module.__new(AS_HEADER_BYTES, AS_ID_INT32_ARRAY) >>> 0;
-		module.__pin(headerPtr);
-		const dv = new DataView(module.memory.buffer);
-		dv.setUint32(headerPtr + 0, bufferPtr, true);
-		dv.setUint32(headerPtr + 4, bufferPtr, true);
-		dv.setUint32(headerPtr + 8, byteLength, true);
-		const array = new Int32Array(module.memory.buffer, bufferPtr, length);
-		this.track(this.int32Pool, headerPtr, bufferPtr, byteLength);
-		return {
-			ptr: headerPtr,
-			dataPtr: bufferPtr,
-			array,
-			length
-		};
-	}
-	track(pool, ptr, dataPtr, size) {
-		if (size <= this.poolSizeThreshold) pool.push({
-			ptr,
-			dataPtr,
-			size,
-			inUse: true
-		});
-	}
-	acquireFromAsPool(module, pool, requestedSize) {
-		let bestFit = null;
-		let bestFitWaste = Infinity;
-		for (const entry of pool) if (!entry.inUse && entry.size >= requestedSize) {
-			const waste = entry.size - requestedSize;
-			if (waste < bestFitWaste && entry.size <= requestedSize * 2) {
-				bestFit = entry;
-				bestFitWaste = waste;
-			}
-		}
-		if (bestFit) {
-			bestFit.inUse = true;
-			new DataView(module.memory.buffer).setUint32(bestFit.ptr + 8, requestedSize, true);
-		}
-		return bestFit;
-	}
-	findEntry(ptr) {
-		return this.float64Pool.find((e) => e.ptr === ptr) ?? this.int32Pool.find((e) => e.ptr === ptr);
-	}
-	unpinAllocation(module, ptr, dataPtr) {
-		if (typeof module.__unpin !== "function") return;
-		module.__unpin(ptr);
-		if (dataPtr !== void 0) module.__unpin(dataPtr);
-	}
-	headerDataPtr(module, ptr) {
-		return new DataView(module.memory.buffer).getUint32(ptr + 4, true);
-	}
-	release(ptr, isFloat64 = true) {
-		const entry = this.findEntry(ptr);
-		if (entry) {
-			entry.inUse = false;
-			return;
-		}
-		const module = this.wasmModule;
-		if (!module) return;
-		this.unpinAllocation(module, ptr, this.headerDataPtr(module, ptr));
-	}
-	free(ptr) {
-		this.release(ptr);
-	}
-	clearPool() {
-		const module = this.wasmModule;
-		if (!module) return;
-		for (const entry of [...this.float64Pool, ...this.int32Pool]) if (!entry.inUse) this.unpinAllocation(module, entry.ptr, entry.dataPtr);
-		this.float64Pool = [];
-		this.int32Pool = [];
-	}
-	getPoolStats() {
-		const f64InUse = this.float64Pool.filter((e) => e.inUse).length;
-		const f64Bytes = this.float64Pool.reduce((sum, e) => sum + e.size, 0);
-		const i32InUse = this.int32Pool.filter((e) => e.inUse).length;
-		const i32Bytes = this.int32Pool.reduce((sum, e) => sum + e.size, 0);
-		return {
-			float64: {
-				total: this.float64Pool.length,
-				inUse: f64InUse,
-				totalBytes: f64Bytes
-			},
-			int32: {
-				total: this.int32Pool.length,
-				inUse: i32InUse,
-				totalBytes: i32Bytes
-			}
-		};
-	}
-	collect() {
-		const module = this.wasmModule;
-		if (!module) return;
-		if (typeof module.__collect === "function") module.__collect();
-	}
-	reset() {
-		this.clearPool();
-		this.wasmModule = null;
-		this.compiledModule = null;
-		this.loading = null;
-		this.lastMetrics = null;
-	}
-}).getInstance();
-//#endregion
 //#region src/backends/gpu/BatchExecutor.ts
 var BatchExecutor = class {
 	context;
@@ -3833,6 +3495,66 @@ function transpose$1(A) {
 	const n = A[0].length;
 	return Array.from({ length: n }, (_, j) => Array.from({ length: m }, (_, i) => A[i][j]));
 }
+function matInv(A) {
+	const n = A.length;
+	return gaussJordanSolve(A, Array.from({ length: n }, (_, i) => {
+		const row = new Array(n).fill(0);
+		row[i] = 1;
+		return row;
+	}));
+}
+function gaussJordanSolve(a, rhs) {
+	const n = a.length;
+	if (n === 0) return [];
+	const width = rhs[0]?.length ?? 0;
+	const M = a.map((row, i) => {
+		const r = new Array(n + width);
+		for (let j = 0; j < n; j++) r[j] = row[j];
+		const b = rhs[i] ?? [];
+		for (let j = 0; j < width; j++) r[n + j] = b[j] ?? 0;
+		return r;
+	});
+	for (let col = 0; col < n; col++) {
+		let maxRow = col;
+		let maxVal = Math.abs(M[col][col]);
+		for (let row = col + 1; row < n; row++) if (Math.abs(M[row][col]) > maxVal) {
+			maxVal = Math.abs(M[row][col]);
+			maxRow = row;
+		}
+		if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
+		const pivot = M[col][col];
+		if (Math.abs(pivot) < 1e-15) return null;
+		for (let j = col; j < n + width; j++) M[col][j] /= pivot;
+		for (let row = 0; row < n; row++) {
+			if (row === col) continue;
+			const f = M[row][col];
+			if (f === 0) continue;
+			for (let j = col; j < n + width; j++) M[row][j] -= f * M[col][j];
+		}
+	}
+	return M.map((row) => row.slice(n));
+}
+function gaussJordanContinue(aug, n, pivotTol) {
+	const width = aug[0].length;
+	for (let col = 0; col < n; col++) {
+		let maxRow = col;
+		let maxVal = Math.abs(aug[col][col]);
+		for (let row = col + 1; row < n; row++) if (Math.abs(aug[row][col]) > maxVal) {
+			maxVal = Math.abs(aug[row][col]);
+			maxRow = row;
+		}
+		if (maxRow !== col) [aug[col], aug[maxRow]] = [aug[maxRow], aug[col]];
+		const pivot = aug[col][col];
+		if (Math.abs(pivot) < pivotTol) continue;
+		for (let j = col; j < width; j++) aug[col][j] /= pivot;
+		for (let row = 0; row < n; row++) {
+			if (row === col) continue;
+			const factor = aug[row][col];
+			if (factor === 0) continue;
+			for (let j = col; j < width; j++) aug[row][j] -= factor * aug[col][j];
+		}
+	}
+}
 function isSymmetric(matrix, tolerance = 1e-10) {
 	const n = matrix.length;
 	if (n === 0) return true;
@@ -4385,6 +4107,38 @@ function powerIteration(matrix, options = {}) {
 	};
 }
 //#endregion
+//#region src/operations/givens.ts
+function givensRotation(a, b) {
+	if (b === 0) return {
+		c: 1,
+		s: 0
+	};
+	if (Math.abs(b) > Math.abs(a)) {
+		const t = -a / b;
+		const s = 1 / Math.sqrt(1 + t * t);
+		return {
+			c: s * t,
+			s
+		};
+	}
+	const t = -b / a;
+	const c = 1 / Math.sqrt(1 + t * t);
+	return {
+		c,
+		s: c * t
+	};
+}
+function applyGivensCols(A, c, s, i, k, rowStart, rowEnd) {
+	for (let j = rowStart; j < rowEnd; j++) {
+		const temp = c * A[j][i] - s * A[j][k];
+		A[j][k] = s * A[j][i] + c * A[j][k];
+		A[j][i] = temp;
+	}
+}
+function applyGivensRight(A, c, s, i, k, startRow) {
+	applyGivensCols(A, c, s, i, k, startRow, A.length);
+}
+//#endregion
 //#region src/operations/svd.ts
 const DEFAULT_MAX_ITERATIONS = 1e3;
 const DEFAULT_TOLERANCE = 1e-12;
@@ -4422,34 +4176,6 @@ function bidiagonalize(A) {
 		V
 	};
 }
-function givens(a, b) {
-	if (b === 0) return {
-		c: 1,
-		s: 0
-	};
-	else if (Math.abs(b) > Math.abs(a)) {
-		const t = -a / b;
-		const s = 1 / Math.sqrt(1 + t * t);
-		return {
-			c: s * t,
-			s
-		};
-	} else {
-		const t = -b / a;
-		const c = 1 / Math.sqrt(1 + t * t);
-		return {
-			c,
-			s: c * t
-		};
-	}
-}
-function applyGivensCols(A, c, s, i, k, rowStart, rowEnd) {
-	for (let j = rowStart; j < rowEnd; j++) {
-		const temp = c * A[j][i] - s * A[j][k];
-		A[j][k] = s * A[j][i] + c * A[j][k];
-		A[j][i] = temp;
-	}
-}
 function svdStep(d, e, U, V, start, end) {
 	if (end - start + 1 < 2) return;
 	const dm1 = d[end - 1];
@@ -4467,14 +4193,14 @@ function svdStep(d, e, U, V, start, end) {
 	let f = d[start] * d[start] - shift;
 	let g = d[start] * e[start];
 	for (let k = start; k < end; k++) {
-		const { c: cs, s: sn } = givens(f, g);
+		const { c: cs, s: sn } = givensRotation(f, g);
 		if (k > start) e[k - 1] = cs * f - sn * g;
 		f = cs * d[k] - sn * e[k];
 		e[k] = sn * d[k] + cs * e[k];
 		g = -sn * d[k + 1];
 		d[k + 1] = cs * d[k + 1];
 		applyGivensCols(V, cs, sn, k, k + 1, 0, V.length);
-		const { c: cs2, s: sn2 } = givens(f, g);
+		const { c: cs2, s: sn2 } = givensRotation(f, g);
 		d[k] = cs2 * f - sn2 * g;
 		f = cs2 * e[k] - sn2 * d[k + 1];
 		d[k + 1] = sn2 * e[k] + cs2 * d[k + 1];
@@ -4489,7 +4215,7 @@ function svdStep(d, e, U, V, start, end) {
 function handleZero(d, e, _U, V, zeroIdx, isDiagonal, _tolerance) {
 	const n = d.length;
 	if (isDiagonal) for (let k = zeroIdx; k < n - 1; k++) {
-		const { c, s } = givens(d[k + 1], e[k]);
+		const { c, s } = givensRotation(d[k + 1], e[k]);
 		d[k + 1] = c * d[k + 1] - s * e[k];
 		e[k] = 0;
 		if (k < n - 2) {
@@ -5009,26 +4735,8 @@ const B = [
 ];
 function matSolve(M, N) {
 	const n = M.length;
-	const cols = N[0].length;
 	const Aug = M.map((row, i) => [...row, ...N[i]]);
-	for (let col = 0; col < n; col++) {
-		let maxRow = col;
-		let maxVal = Math.abs(Aug[col][col]);
-		for (let row = col + 1; row < n; row++) if (Math.abs(Aug[row][col]) > maxVal) {
-			maxVal = Math.abs(Aug[row][col]);
-			maxRow = row;
-		}
-		if (maxRow !== col) [Aug[col], Aug[maxRow]] = [Aug[maxRow], Aug[col]];
-		const pivot = Aug[col][col];
-		if (Math.abs(pivot) < 1e-15) continue;
-		for (let j = col; j < n + cols; j++) Aug[col][j] /= pivot;
-		for (let row = 0; row < n; row++) {
-			if (row === col) continue;
-			const factor = Aug[row][col];
-			if (factor === 0) continue;
-			for (let j = col; j < n + cols; j++) Aug[row][j] -= factor * Aug[col][j];
-		}
-	}
+	gaussJordanContinue(Aug, n, 1e-15);
 	return Aug.map((row) => row.slice(n));
 }
 function pade13(A) {
@@ -5090,26 +4798,6 @@ function hessenbergReduce(A) {
 		Q
 	};
 }
-function givensParams(a, b) {
-	if (b === 0) return {
-		c: 1,
-		s: 0
-	};
-	if (Math.abs(b) > Math.abs(a)) {
-		const t = -a / b;
-		const s = 1 / Math.sqrt(1 + t * t);
-		return {
-			c: s * t,
-			s
-		};
-	}
-	const t = -b / a;
-	const c = 1 / Math.sqrt(1 + t * t);
-	return {
-		c,
-		s: c * t
-	};
-}
 function applyGivensLeft(A, c, s, i, k, startCol) {
 	const n = A[0].length;
 	for (let j = startCol; j < n; j++) {
@@ -5118,14 +4806,6 @@ function applyGivensLeft(A, c, s, i, k, startCol) {
 		A[i][j] = temp;
 	}
 }
-function applyGivensRight(A, c, s, i, k, startRow) {
-	const m = A.length;
-	for (let j = startRow; j < m; j++) {
-		const temp = c * A[j][i] - s * A[j][k];
-		A[j][k] = s * A[j][i] + c * A[j][k];
-		A[j][i] = temp;
-	}
-}
 function qrStepSingle(H, Q, start, end) {
 	const a = H[end - 1][end - 1];
 	const b = H[end - 1][end];
@@ -5141,18 +4821,7 @@ function qrStepSingle(H, Q, start, end) {
 		const e2 = (trace - sqrtDisc) / 2;
 		shift = Math.abs(e1 - d) < Math.abs(e2 - d) ? e1 : e2;
 	} else shift = d;
-	let x = H[start][start] - shift;
-	let y = H[start + 1][start];
-	for (let k = start; k < end; k++) {
-		const { c: gc, s: gs } = givensParams(x, y);
-		applyGivensLeft(H, gc, gs, k, k + 1, Math.max(0, k - 1));
-		applyGivensRight(H, gc, gs, k, k + 1, 0);
-		applyGivensRight(Q, gc, gs, k, k + 1, 0);
-		if (k < end - 1) {
-			x = H[k + 1][k];
-			y = H[k + 2][k];
-		}
-	}
+	qrStepSingleShift(H, Q, start, end, shift);
 }
 function qrStepDouble(H, Q, start, end) {
 	const n = H.length;
@@ -5198,7 +4867,7 @@ function qrStepDouble(H, Q, start, end) {
 		y = H[k + 2][k];
 		if (k < end - 2) z = H[k + 3][k];
 	}
-	const { c: gc, s: gs } = givensParams(x, y);
+	const { c: gc, s: gs } = givensRotation(x, y);
 	applyGivensLeft(H, gc, gs, end - 1, end, end - 2);
 	applyGivensRight(H, gc, gs, end - 1, end, 0);
 	applyGivensRight(Q, gc, gs, end - 1, end, 0);
@@ -5207,7 +4876,7 @@ function qrStepSingleShift(H, Q, start, end, shift) {
 	let x = H[start][start] - shift;
 	let y = H[start + 1][start];
 	for (let k = start; k < end; k++) {
-		const { c: gc, s: gs } = givensParams(x, y);
+		const { c: gc, s: gs } = givensRotation(x, y);
 		applyGivensLeft(H, gc, gs, k, k + 1, Math.max(0, k - 1));
 		applyGivensRight(H, gc, gs, k, k + 1, 0);
 		applyGivensRight(Q, gc, gs, k, k + 1, 0);
@@ -5317,51 +4986,210 @@ function schurInternal(A, maxIterations = 1e3, tolerance = 1e-12) {
 	return schurRaw(A, maxIterations, tolerance);
 }
 //#endregion
-//#region src/operations/logm.ts
+//#region src/operations/sqrtm.ts
 init_DenseMatrix();
-function matInv$1(A) {
+function symmetrize(A) {
 	const n = A.length;
-	const M = A.map((row, i) => {
-		const r = new Array(2 * n).fill(0);
-		for (let j = 0; j < n; j++) r[j] = row[j];
-		r[n + i] = 1;
-		return r;
-	});
-	for (let col = 0; col < n; col++) {
-		let maxRow = col;
-		let maxVal = Math.abs(M[col][col]);
-		for (let row = col + 1; row < n; row++) if (Math.abs(M[row][col]) > maxVal) {
-			maxVal = Math.abs(M[row][col]);
-			maxRow = row;
-		}
-		if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
-		const pivot = M[col][col];
-		if (Math.abs(pivot) < 1e-15) return null;
-		for (let j = 0; j < 2 * n; j++) M[col][j] /= pivot;
-		for (let row = 0; row < n; row++) {
-			if (row === col) continue;
-			const f = M[row][col];
-			if (f === 0) continue;
-			for (let j = 0; j < 2 * n; j++) M[row][j] -= f * M[col][j];
+	return Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (A[i][j] + A[j][i]) / 2));
+}
+function gramSchmidt(A) {
+	const m = A.length;
+	const n = A[0].length;
+	const Q = Array.from({ length: m }, () => new Array(n).fill(0));
+	for (let j = 0; j < n; j++) {
+		const v = A.map((row) => row[j]);
+		for (let k = 0; k < j; k++) {
+			let dot = 0;
+			for (let i = 0; i < m; i++) dot += Q[i][k] * v[i];
+			for (let i = 0; i < m; i++) v[i] -= dot * Q[i][k];
 		}
+		let norm = 0;
+		for (let i = 0; i < m; i++) norm += v[i] * v[i];
+		norm = Math.sqrt(norm);
+		if (norm < 1e-14) for (let i = 0; i < m; i++) Q[i][j] = i === j ? 1 : 0;
+		else for (let i = 0; i < m; i++) Q[i][j] = v[i] / norm;
 	}
-	return M.map((row) => row.slice(n));
+	return Q;
 }
-function matSqrt(A) {
+function sqrtmSymmetric(A) {
+	const n = A.length;
+	const Asym = symmetrize(A);
+	const { values, vectors } = eig(Asym, { computeVectors: true });
+	for (const v of values) if (v.re < -1e-8) throw new Error(`matrixSqrtm: negative eigenvalue (${v.re}) — matrix is not positive semi-definite`);
+	const Ynewton = sqrtmNewton(Asym);
+	if (Ynewton !== null) return Ynewton;
+	const Q = gramSchmidt(transpose$1(vectors));
+	const Qt = transpose$1(Q);
+	const Dsqrt = eye(n);
+	for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
+	return matMul(matMul(Q, Dsqrt), Qt);
+}
+function newtonSqrtUpdate(A, Y) {
+	const n = A.length;
+	const Yinv = matInv(Y);
+	if (Yinv === null) return null;
+	const AYinv = matMul(A, Yinv);
+	const next = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (Y[i][j] + AYinv[i][j]) / 2));
+	let diff = 0;
+	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) diff = Math.max(diff, Math.abs(next[i][j] - Y[i][j]));
+	return {
+		next,
+		diff
+	};
+}
+function sqrtmNewton(A) {
 	const n = A.length;
 	let Y = eye(n);
 	for (let iter = 0; iter < 150; iter++) {
-		const Yinv = matInv$1(Y);
-		if (Yinv === null) break;
-		const AYinv = matMul(A, Yinv);
-		const Ynew = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (Y[i][j] + AYinv[i][j]) / 2));
-		let diff = 0;
-		for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) diff = Math.max(diff, Math.abs(Ynew[i][j] - Y[i][j]));
-		Y = Ynew;
-		if (diff < 1e-14) break;
+		const step = newtonSqrtUpdate(A, Y);
+		if (step === null) return null;
+		Y = step.next;
+		if (step.diff < 1e-13) return Y;
+	}
+	const Y2 = matMul(Y, Y);
+	let err = 0;
+	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) err = Math.max(err, Math.abs(Y2[i][j] - A[i][j]));
+	return err < 1e-6 ? Y : null;
+}
+function sqrtmGeneral(A) {
+	const n = A.length;
+	const { values, vectors } = eig(A, { computeVectors: true });
+	for (const v of values) {
+		if (Math.abs(v.im) > 1e-7) throw new Error("matrixSqrtm: complex eigenvalues detected — real square root not supported");
+		if (v.re < -1e-7) throw new Error(`matrixSqrtm: negative eigenvalue (${v.re}) — principal square root not real`);
+	}
+	const Ynewton = sqrtmNewton(A);
+	if (Ynewton !== null) return Ynewton;
+	const Q = transpose$1(vectors);
+	const Qinv = matInv(Q);
+	if (Qinv === null) throw new Error("matrixSqrtm: eigenvector matrix is singular — matrix appears to be non-diagonalisable");
+	const Dsqrt = eye(n);
+	for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
+	return matMul(matMul(Q, Dsqrt), Qinv);
+}
+function sqrtmQuasiTriangular(T) {
+	const n = T.length;
+	const U = Array.from({ length: n }, () => new Array(n).fill(0));
+	const blockStart = [];
+	const blockSize = [];
+	let i = 0;
+	while (i < n) if (i === n - 1 || Math.abs(T[i + 1][i]) < 1e-12) {
+		blockStart.push(i);
+		blockSize.push(1);
+		i++;
+	} else {
+		blockStart.push(i);
+		blockSize.push(2);
+		i += 2;
+	}
+	const numBlocks = blockStart.length;
+	for (let b = 0; b < numBlocks; b++) {
+		const r = blockStart[b];
+		if (blockSize[b] === 1) {
+			if (T[r][r] < 0) return null;
+			U[r][r] = Math.sqrt(T[r][r]);
+		} else {
+			const a = T[r][r];
+			const b2 = T[r][r + 1];
+			const c = T[r + 1][r];
+			const d = T[r + 1][r + 1];
+			const detM = a * d - b2 * c;
+			const trM = a + d;
+			if (detM < 0) return null;
+			const sqrtDet = Math.sqrt(detM);
+			const tauSq = trM + 2 * sqrtDet;
+			if (tauSq < 0) return null;
+			const tau = Math.sqrt(tauSq);
+			if (Math.abs(tau) < 1e-14) return null;
+			U[r][r] = (a + sqrtDet) / tau;
+			U[r][r + 1] = b2 / tau;
+			U[r + 1][r] = c / tau;
+			U[r + 1][r + 1] = (d + sqrtDet) / tau;
+		}
+	}
+	for (let bj = 1; bj < numBlocks; bj++) for (let bi = bj - 1; bi >= 0; bi--) {
+		const ri = blockStart[bi];
+		const rj = blockStart[bj];
+		const si = blockSize[bi];
+		const sj = blockSize[bj];
+		const RHS = Array.from({ length: si }, (_, ii) => Array.from({ length: sj }, (_, jj) => T[ri + ii][rj + jj]));
+		for (let bk = bi + 1; bk < bj; bk++) {
+			const rk = blockStart[bk];
+			const sk = blockSize[bk];
+			for (let ii = 0; ii < si; ii++) for (let jj = 0; jj < sj; jj++) {
+				let sum = 0;
+				for (let kk = 0; kk < sk; kk++) sum += U[ri + ii][rk + kk] * U[rk + kk][rj + jj];
+				RHS[ii][jj] -= sum;
+			}
+		}
+		const total = si * sj;
+		const MAT = Array.from({ length: total }, () => new Array(total).fill(0));
+		const rhs = new Array(total).fill(0);
+		for (let ii = 0; ii < si; ii++) for (let jj = 0; jj < sj; jj++) {
+			const eq = ii * sj + jj;
+			for (let kk = 0; kk < si; kk++) MAT[eq][kk * sj + jj] += U[ri + ii][ri + kk];
+			for (let kk = 0; kk < sj; kk++) MAT[eq][ii * sj + kk] += U[rj + kk][rj + jj];
+			rhs[eq] = RHS[ii][jj];
+		}
+		const sol = solveLinearSystem(MAT, rhs);
+		if (sol === null) return null;
+		for (let ii = 0; ii < si; ii++) for (let jj = 0; jj < sj; jj++) U[ri + ii][rj + jj] = sol[ii * sj + jj];
+	}
+	return U;
+}
+function solveLinearSystem(A, b) {
+	const solved = gaussJordanSolve(A, b.map((value) => [value]));
+	if (solved === null) return null;
+	return solved.map((row) => row[0]);
+}
+function sqrtmSchur(A) {
+	const { H: T, Q } = schurInternal(A);
+	const U = sqrtmQuasiTriangular(T);
+	if (U === null) return null;
+	const Qt = transpose$1(Q);
+	return matMul(matMul(Q, U), Qt);
+}
+function matrixSqrtm(A, opts) {
+	const n = A.rows;
+	if (n !== A.cols) throw new Error(`matrixSqrtm: matrix must be square (got ${A.rows}×${A.cols})`);
+	if (n === 0) return DenseMatrix.zeros(0, 0);
+	if (n === 1) {
+		const val = A.get(0, 0);
+		if (val < 0) throw new Error(`matrixSqrtm: negative scalar (${val}) has no real square root`);
+		return DenseMatrix.fromArray([[Math.sqrt(val)]]);
+	}
+	const Aarr = A.toArray();
+	const isSymm = (opts?.assumeSymmetric ?? false) || isSymmetricMatrix(Aarr);
+	let result;
+	if (isSymm) result = sqrtmSymmetric(Aarr);
+	else {
+		const schurResult = sqrtmSchur(Aarr);
+		if (schurResult !== null) result = schurResult;
+		else result = sqrtmGeneral(Aarr);
+	}
+	const data = new Float64Array(n * n);
+	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) data[i * n + j] = result[i][j];
+	return new DenseMatrix(n, n, data);
+}
+function isSymmetricMatrix(A, tol = 1e-8) {
+	const n = A.length;
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) if (Math.abs(A[i][j] - A[j][i]) > tol) return false;
+	return true;
+}
+function matrixSqrtNewtonInternal(A) {
+	const n = A.length;
+	let Y = eye(n);
+	for (let iter = 0; iter < 150; iter++) {
+		const step = newtonSqrtUpdate(A, Y);
+		if (step === null) break;
+		Y = step.next;
+		if (step.diff < 1e-14) break;
 	}
 	return Y;
 }
+//#endregion
+//#region src/operations/logm.ts
+init_DenseMatrix();
 const GL16_NODES = [
 	.00529953674226076,
 	.02771248846338012,
@@ -5401,24 +5229,7 @@ const GL16_WEIGHTS = [
 function solveCol(M, b) {
 	const n = M.length;
 	const Aug = M.map((row, i) => [...row, b[i]]);
-	for (let col = 0; col < n; col++) {
-		let maxRow = col;
-		let maxVal = Math.abs(Aug[col][col]);
-		for (let row = col + 1; row < n; row++) if (Math.abs(Aug[row][col]) > maxVal) {
-			maxVal = Math.abs(Aug[row][col]);
-			maxRow = row;
-		}
-		if (maxRow !== col) [Aug[col], Aug[maxRow]] = [Aug[maxRow], Aug[col]];
-		const pivot = Aug[col][col];
-		if (Math.abs(pivot) < 1e-30) continue;
-		for (let j = col; j <= n; j++) Aug[col][j] /= pivot;
-		for (let row = 0; row < n; row++) {
-			if (row === col) continue;
-			const f = Aug[row][col];
-			if (f === 0) continue;
-			for (let j = col; j <= n; j++) Aug[row][j] -= f * Aug[col][j];
-		}
-	}
+	gaussJordanContinue(Aug, n, 1e-30);
 	return Aug.map((row) => row[n]);
 }
 function logPade(X) {
@@ -5496,7 +5307,7 @@ function logmEig(A) {
 		if (v.re <= 0) throw new Error("matrixLogm: non-positive eigenvalue detected — principal logarithm is undefined (eigenvalue = " + v.re + ")");
 	}
 	const Q = transpose$1(vectors);
-	const Qinv = matInv$1(Q);
+	const Qinv = matInv(Q);
 	if (Qinv === null) throw new Error("matrixLogm: eigenvector matrix is singular — matrix appears to be non-diagonalisable (Slice 5.9a limitation; full Schur-based implementation deferred to Slice 5.9b)");
 	const D = eye(n);
 	for (let i = 0; i < n; i++) D[i][i] = Math.log(values[i].re);
@@ -5520,7 +5331,7 @@ function matrixLogm(A, opts) {
 	const maxSqrt = 64;
 	while (numSqrt < maxSqrt) {
 		if (norm1(M.map((row, i) => row.map((v, j) => v - (i === j ? 1 : 0)))) < tol) break;
-		const sqrtM = matSqrt(M);
+		const sqrtM = matrixSqrtNewtonInternal(M);
 		if (!isFinite(normInf(sqrtM))) break;
 		M = sqrtM;
 		numSqrt++;
@@ -5538,234 +5349,6 @@ function matrixLogm(A, opts) {
 	return new DenseMatrix(n, n, data);
 }
 //#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));
-}
-function matInv(A) {
-	const n = A.length;
-	const M = A.map((row, i) => {
-		const r = new Array(2 * n).fill(0);
-		for (let j = 0; j < n; j++) r[j] = row[j];
-		r[n + i] = 1;
-		return r;
-	});
-	for (let col = 0; col < n; col++) {
-		let maxRow = col;
-		let maxVal = Math.abs(M[col][col]);
-		for (let row = col + 1; row < n; row++) if (Math.abs(M[row][col]) > maxVal) {
-			maxVal = Math.abs(M[row][col]);
-			maxRow = row;
-		}
-		if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
-		const pivot = M[col][col];
-		if (Math.abs(pivot) < 1e-15) return null;
-		for (let j = 0; j < 2 * n; j++) M[col][j] /= pivot;
-		for (let row = 0; row < n; row++) {
-			if (row === col) continue;
-			const f = M[row][col];
-			if (f === 0) continue;
-			for (let j = 0; j < 2 * n; j++) M[row][j] -= f * M[col][j];
-		}
-	}
-	return M.map((row) => row.slice(n));
-}
-function gramSchmidt(A) {
-	const m = A.length;
-	const n = A[0].length;
-	const Q = Array.from({ length: m }, () => new Array(n).fill(0));
-	for (let j = 0; j < n; j++) {
-		const v = A.map((row) => row[j]);
-		for (let k = 0; k < j; k++) {
-			let dot = 0;
-			for (let i = 0; i < m; i++) dot += Q[i][k] * v[i];
-			for (let i = 0; i < m; i++) v[i] -= dot * Q[i][k];
-		}
-		let norm = 0;
-		for (let i = 0; i < m; i++) norm += v[i] * v[i];
-		norm = Math.sqrt(norm);
-		if (norm < 1e-14) for (let i = 0; i < m; i++) Q[i][j] = i === j ? 1 : 0;
-		else for (let i = 0; i < m; i++) Q[i][j] = v[i] / norm;
-	}
-	return Q;
-}
-function sqrtmSymmetric(A) {
-	const n = A.length;
-	const Asym = symmetrize(A);
-	const { values, vectors } = eig(Asym, { computeVectors: true });
-	for (const v of values) if (v.re < -1e-8) throw new Error(`matrixSqrtm: negative eigenvalue (${v.re}) — matrix is not positive semi-definite`);
-	const Ynewton = sqrtmNewton(Asym);
-	if (Ynewton !== null) return Ynewton;
-	const Q = gramSchmidt(transpose$1(vectors));
-	const Qt = transpose$1(Q);
-	const Dsqrt = eye(n);
-	for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
-	return matMul(matMul(Q, Dsqrt), Qt);
-}
-function sqrtmNewton(A) {
-	const n = A.length;
-	let Y = eye(n);
-	for (let iter = 0; iter < 150; iter++) {
-		const Yinv = matInv(Y);
-		if (Yinv === null) return null;
-		const AYinv = matMul(A, Yinv);
-		const Ynew = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (Y[i][j] + AYinv[i][j]) / 2));
-		let diff = 0;
-		for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) diff = Math.max(diff, Math.abs(Ynew[i][j] - Y[i][j]));
-		Y = Ynew;
-		if (diff < 1e-13) return Y;
-	}
-	const Y2 = matMul(Y, Y);
-	let err = 0;
-	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) err = Math.max(err, Math.abs(Y2[i][j] - A[i][j]));
-	return err < 1e-6 ? Y : null;
-}
-function sqrtmGeneral(A) {
-	const n = A.length;
-	const { values, vectors } = eig(A, { computeVectors: true });
-	for (const v of values) {
-		if (Math.abs(v.im) > 1e-7) throw new Error("matrixSqrtm: complex eigenvalues detected — real square root not supported");
-		if (v.re < -1e-7) throw new Error(`matrixSqrtm: negative eigenvalue (${v.re}) — principal square root not real`);
-	}
-	const Ynewton = sqrtmNewton(A);
-	if (Ynewton !== null) return Ynewton;
-	const Q = transpose$1(vectors);
-	const Qinv = matInv(Q);
-	if (Qinv === null) throw new Error("matrixSqrtm: eigenvector matrix is singular — matrix appears to be non-diagonalisable");
-	const Dsqrt = eye(n);
-	for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
-	return matMul(matMul(Q, Dsqrt), Qinv);
-}
-function sqrtmQuasiTriangular(T) {
-	const n = T.length;
-	const U = Array.from({ length: n }, () => new Array(n).fill(0));
-	const blockStart = [];
-	const blockSize = [];
-	let i = 0;
-	while (i < n) if (i === n - 1 || Math.abs(T[i + 1][i]) < 1e-12) {
-		blockStart.push(i);
-		blockSize.push(1);
-		i++;
-	} else {
-		blockStart.push(i);
-		blockSize.push(2);
-		i += 2;
-	}
-	const numBlocks = blockStart.length;
-	for (let b = 0; b < numBlocks; b++) {
-		const r = blockStart[b];
-		if (blockSize[b] === 1) {
-			if (T[r][r] < 0) return null;
-			U[r][r] = Math.sqrt(T[r][r]);
-		} else {
-			const a = T[r][r];
-			const b2 = T[r][r + 1];
-			const c = T[r + 1][r];
-			const d = T[r + 1][r + 1];
-			const detM = a * d - b2 * c;
-			const trM = a + d;
-			if (detM < 0) return null;
-			const sqrtDet = Math.sqrt(detM);
-			const tauSq = trM + 2 * sqrtDet;
-			if (tauSq < 0) return null;
-			const tau = Math.sqrt(tauSq);
-			if (Math.abs(tau) < 1e-14) return null;
-			U[r][r] = (a + sqrtDet) / tau;
-			U[r][r + 1] = b2 / tau;
-			U[r + 1][r] = c / tau;
-			U[r + 1][r + 1] = (d + sqrtDet) / tau;
-		}
-	}
-	for (let bj = 1; bj < numBlocks; bj++) for (let bi = bj - 1; bi >= 0; bi--) {
-		const ri = blockStart[bi];
-		const rj = blockStart[bj];
-		const si = blockSize[bi];
-		const sj = blockSize[bj];
-		const RHS = Array.from({ length: si }, (_, ii) => Array.from({ length: sj }, (_, jj) => T[ri + ii][rj + jj]));
-		for (let bk = bi + 1; bk < bj; bk++) {
-			const rk = blockStart[bk];
-			const sk = blockSize[bk];
-			for (let ii = 0; ii < si; ii++) for (let jj = 0; jj < sj; jj++) {
-				let sum = 0;
-				for (let kk = 0; kk < sk; kk++) sum += U[ri + ii][rk + kk] * U[rk + kk][rj + jj];
-				RHS[ii][jj] -= sum;
-			}
-		}
-		const total = si * sj;
-		const MAT = Array.from({ length: total }, () => new Array(total).fill(0));
-		const rhs = new Array(total).fill(0);
-		for (let ii = 0; ii < si; ii++) for (let jj = 0; jj < sj; jj++) {
-			const eq = ii * sj + jj;
-			for (let kk = 0; kk < si; kk++) MAT[eq][kk * sj + jj] += U[ri + ii][ri + kk];
-			for (let kk = 0; kk < sj; kk++) MAT[eq][ii * sj + kk] += U[rj + kk][rj + jj];
-			rhs[eq] = RHS[ii][jj];
-		}
-		const sol = solveLinearSystem(MAT, rhs);
-		if (sol === null) return null;
-		for (let ii = 0; ii < si; ii++) for (let jj = 0; jj < sj; jj++) U[ri + ii][rj + jj] = sol[ii * sj + jj];
-	}
-	return U;
-}
-function solveLinearSystem(A, b) {
-	const n = A.length;
-	const Aug = A.map((row, i) => [...row, b[i]]);
-	for (let col = 0; col < n; col++) {
-		let maxRow = col;
-		let maxVal = Math.abs(Aug[col][col]);
-		for (let row = col + 1; row < n; row++) if (Math.abs(Aug[row][col]) > maxVal) {
-			maxVal = Math.abs(Aug[row][col]);
-			maxRow = row;
-		}
-		if (maxRow !== col) [Aug[col], Aug[maxRow]] = [Aug[maxRow], Aug[col]];
-		const pivot = Aug[col][col];
-		if (Math.abs(pivot) < 1e-15) return null;
-		for (let j = col; j <= n; j++) Aug[col][j] /= pivot;
-		for (let row = 0; row < n; row++) {
-			if (row === col) continue;
-			const f = Aug[row][col];
-			if (f === 0) continue;
-			for (let j = col; j <= n; j++) Aug[row][j] -= f * Aug[col][j];
-		}
-	}
-	return Aug.map((row) => row[n]);
-}
-function sqrtmSchur(A) {
-	const { H: T, Q } = schurInternal(A);
-	const U = sqrtmQuasiTriangular(T);
-	if (U === null) return null;
-	const Qt = transpose$1(Q);
-	return matMul(matMul(Q, U), Qt);
-}
-function matrixSqrtm(A, opts) {
-	const n = A.rows;
-	if (n !== A.cols) throw new Error(`matrixSqrtm: matrix must be square (got ${A.rows}×${A.cols})`);
-	if (n === 0) return DenseMatrix.zeros(0, 0);
-	if (n === 1) {
-		const val = A.get(0, 0);
-		if (val < 0) throw new Error(`matrixSqrtm: negative scalar (${val}) has no real square root`);
-		return DenseMatrix.fromArray([[Math.sqrt(val)]]);
-	}
-	const Aarr = A.toArray();
-	const isSymm = (opts?.assumeSymmetric ?? false) || isSymmetricMatrix(Aarr);
-	let result;
-	if (isSymm) result = sqrtmSymmetric(Aarr);
-	else {
-		const schurResult = sqrtmSchur(Aarr);
-		if (schurResult !== null) result = schurResult;
-		else result = sqrtmGeneral(Aarr);
-	}
-	const data = new Float64Array(n * n);
-	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) data[i * n + j] = result[i][j];
-	return new DenseMatrix(n, n, data);
-}
-function isSymmetricMatrix(A, tol = 1e-8) {
-	const n = A.length;
-	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) if (Math.abs(A[i][j] - A[j][i]) > tol) return false;
-	return true;
-}
-//#endregion
 //#region src/operations/qr-pivoted.ts
 init_DenseMatrix();
 function qrPivoted(A, opts) {
@@ -5841,21 +5424,20 @@ function qrPivoted(A, opts) {
 //#endregion
 //#region src/operations/qr-family.ts
 init_DenseMatrix();
-function flipRows(M) {
+function flipDense(M, axis) {
 	const m = M.rows;
 	const n = M.cols;
 	const src = M.toFloat64Array();
 	const data = new Float64Array(m * n);
-	for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) data[i * n + j] = src[(m - 1 - i) * n + j];
+	if (axis === 0) for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) data[i * n + j] = src[(m - 1 - i) * n + j];
+	else for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) data[i * n + j] = src[i * n + (n - 1 - j)];
 	return new DenseMatrix(m, n, data);
 }
+function flipRows(M) {
+	return flipDense(M, 0);
+}
 function flipCols(M) {
-	const m = M.rows;
-	const n = M.cols;
-	const src = M.toFloat64Array();
-	const data = new Float64Array(m * n);
-	for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) data[i * n + j] = src[i * n + (n - 1 - j)];
-	return new DenseMatrix(m, n, data);
+	return flipDense(M, 1);
 }
 function lq(A) {
 	const { Q: Q1, R: R1 } = qr(A.transpose(), { mode: "reduced" });
@@ -6199,6 +5781,10 @@ function matrixToFloat64(m) {
 function float64ToMatrix(data, rows, cols) {
 	return new DenseMatrix(rows, cols, data);
 }
+async function densePair(a, b, op, mismatch) {
+	if (a.rows !== b.rows || a.cols !== b.cols) throw new Error(mismatch(a, b));
+	return float64ToMatrix((await op(matrixToFloat64(a), matrixToFloat64(b))).result, a.rows, a.cols);
+}
 const parallelMatrix = mathTyped("parallelMatrix", {
 	Array: (arr) => DenseMatrix.fromArray(arr),
 	"number, number": (rows, cols) => DenseMatrix.zeros(rows, cols),
@@ -6215,10 +5801,7 @@ const parallelDiag = mathTyped("parallelDiag", {
 });
 const parallelRandom = mathTyped("parallelRandom", { "number, number": (rows, cols) => DenseMatrix.random(rows, cols) });
 const parallelMatrixAdd = mathTyped("parallelMatrixAdd", {
-	"DenseMatrix, DenseMatrix": async (a, b) => {
-		if (a.rows !== b.rows || a.cols !== b.cols) throw new Error(`Matrix dimensions must match: ${a.rows}×${a.cols} vs ${b.rows}×${b.cols}`);
-		return float64ToMatrix((await pAdd(matrixToFloat64(a), matrixToFloat64(b))).result, a.rows, a.cols);
-	},
+	"DenseMatrix, DenseMatrix": (a, b) => densePair(a, b, pAdd, (left, right) => `Matrix dimensions must match: ${left.rows}×${left.cols} vs ${right.rows}×${right.cols}`),
 	"DenseMatrix, number": async (a, scalar) => {
 		const dataA = matrixToFloat64(a);
 		return float64ToMatrix((await pAdd(dataA, new Float64Array(dataA.length).fill(scalar))).result, a.rows, a.cols);
@@ -6232,10 +5815,7 @@ const parallelMatrixAdd = mathTyped("parallelMatrixAdd", {
 	"number, number": (a, b) => a + b
 });
 const parallelMatrixSubtract = mathTyped("parallelMatrixSubtract", {
-	"DenseMatrix, DenseMatrix": async (a, b) => {
-		if (a.rows !== b.rows || a.cols !== b.cols) throw new Error(`Matrix dimensions must match: ${a.rows}×${a.cols} vs ${b.rows}×${b.cols}`);
-		return float64ToMatrix((await pSubtract(matrixToFloat64(a), matrixToFloat64(b))).result, a.rows, a.cols);
-	},
+	"DenseMatrix, DenseMatrix": (a, b) => densePair(a, b, pSubtract, (left, right) => `Matrix dimensions must match: ${left.rows}×${left.cols} vs ${right.rows}×${right.cols}`),
 	"DenseMatrix, number": async (a, scalar) => {
 		const dataA = matrixToFloat64(a);
 		return float64ToMatrix((await pSubtract(dataA, new Float64Array(dataA.length).fill(scalar))).result, a.rows, a.cols);
@@ -6265,10 +5845,7 @@ const parallelMatrixMultiply = mathTyped("parallelMatrixMultiply", {
 	"number, number": (a, b) => a * b
 });
 const parallelDotMultiply = mathTyped("parallelDotMultiply", {
-	"DenseMatrix, DenseMatrix": async (a, b) => {
-		if (a.rows !== b.rows || a.cols !== b.cols) throw new Error(`Matrix dimensions must match for element-wise multiply`);
-		return float64ToMatrix((await pMultiply(matrixToFloat64(a), matrixToFloat64(b))).result, a.rows, a.cols);
-	},
+	"DenseMatrix, DenseMatrix": (a, b) => densePair(a, b, pMultiply, () => `Matrix dimensions must match for element-wise multiply`),
 	"Float64Array, Float64Array": async (a, b) => {
 		return (await pMultiply(a, b)).result;
 	},
@@ -6282,10 +5859,7 @@ const parallelMatrixDivide = mathTyped("parallelMatrixDivide", {
 		const dataA = matrixToFloat64(a);
 		return float64ToMatrix((await pDivide(new Float64Array(dataA.length).fill(scalar), dataA)).result, a.rows, a.cols);
 	},
-	"DenseMatrix, DenseMatrix": async (a, b) => {
-		if (a.rows !== b.rows || a.cols !== b.cols) throw new Error(`Matrix dimensions must match for element-wise divide`);
-		return float64ToMatrix((await pDivide(matrixToFloat64(a), matrixToFloat64(b))).result, a.rows, a.cols);
-	},
+	"DenseMatrix, DenseMatrix": (a, b) => densePair(a, b, pDivide, () => `Matrix dimensions must match for element-wise divide`),
 	"Float64Array, Float64Array": async (a, b) => {
 		return (await pDivide(a, b)).result;
 	},
@@ -6584,4 +6158,4 @@ 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, 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, typedMatrixOperations, unaryMinus, wasmBackend, zeros };
+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 };