sparse.md

Sparse Module

Sparse matrix types and direct solvers.

SparseMatrix(T)

CSR (Compressed Sparse Row) format sparse matrix.

Construction

var sp = Zigen.SparseMatrix(f64).init(allocator, rows, cols);
defer sp.deinit();

try sp.insert(row, col, value);   // Add entry (before finalize)
try sp.finalize();                // Build CSR structure

Operations

sp.at(i, j)                      // Element access (O(log nnz))
sp.nonZeros()                    // Number of non-zeros
sp.mulVec(x)                    // y = A*x (allocating, returns []T)
sp.mulVecInto(x, y)             // y = A*x (zero-allocation)
sp.mulMat(other)                // Sparse × Sparse
sp.add(other)                   // Sparse + Sparse
sp.scale(scalar)                // scalar * A
sp.transpose()                  // Aᵀ
sp.toDense(allocator)           // Convert to MatrixDynamic

SparseMatrixCOO(T)

COO (Coordinate) format. Use Triplet(T) for entries.

var coo = Zigen.SparseMatrixCOO(f64).init(allocator, rows, cols);
try coo.addTriplet(.{ .row = 0, .col = 0, .value = 1.0 });
var csr = try coo.toCSR();       // Convert to CSR

---

Direct Solvers

SparseLU(T)

LU factorization for general square sparse systems.

One-Shot (Allocating)

var lu = try Zigen.SparseLU(f64).compute(allocator, sp);
defer lu.deinit();
var x = try lu.solve(b);
defer x.deinit();
lu.determinant()                 // Determinant

Workspace Reuse (Zero-Allocation)

var lu = try Zigen.SparseLU(f64).init(allocator, n);
defer lu.deinit();
const work_dense = try allocator.alloc(f64, n * n);
defer allocator.free(work_dense);
const x_buf = try allocator.alloc(f64, n);
const y_buf = try allocator.alloc(f64, n);

lu.computeFrom(sp, work_dense);
lu.solveInto(b_data, x_buf, y_buf);

SparseCholesky(T)

Cholesky for SPD sparse systems. Same API pattern as SparseLU.

// One-shot
var chol = try Zigen.SparseCholesky(f64).compute(allocator, sp);

// Workspace reuse
var chol = try Zigen.SparseCholesky(f64).init(allocator, n);
chol.computeFrom(sp, work_dense);
chol.solveInto(b_data, x_buf, y_buf);

SparseQR(T)

QR decomposition for sparse systems (overdetermined systems, least-squares).

SimplicialLDLT(T) / SimplicialLLT(T)

Simplicial sparse Cholesky solvers for large SPD systems.

---

MatrixMarket I/O

// Load from string
var sp = try Zigen.loadMatrixMarket(f64, allocator, mm_string);

// Save to string
const mm_str = try Zigen.saveMatrixMarket(f64, allocator, sp);