sparse — Create sparse double matrices from full arrays, sizes, or row/column/value triplets.

sparse creates a sparse double matrix. RunMat stores sparse matrices in compressed sparse column form and supports MATLAB construction forms for conversion from full arrays, empty sparse allocation by size, and triplet assembly from row indices, column indices, and values.

Syntax

S = sparse(A)
S = sparse(m, n)
S = sparse(i, j, v)
S = sparse(i, j, v, m, n)
S = sparse(i, j, v, m, n, nzmax)

Inputs

Returns

Errors

How sparse works

• sparse(A) converts a full numeric or logical array to a sparse double matrix, storing only nonzero values.
• sparse(m, n) returns an m x n sparse double matrix with zero stored entries.
• sparse(i, j, v) creates a sparse matrix whose size is inferred from the largest row and column subscripts.
• sparse(i, j, v, m, n) creates an m x n sparse matrix and errors if any subscript falls outside those dimensions.
• sparse(i, j, v, m, n, nzmax) accepts the MATLAB allocation hint for compatibility; RunMat's storage is still sized from the produced nonzero entries.
• Duplicate (i, j) entries are summed. Entries whose final value is zero are not stored.
• Row and column subscripts are one-based positive integers, matching MATLAB.
• Sparse matrices support scalar row/column indexing and linear indexing; scalar selections return sparse 1 x 1 values, unstored entries read as zero, and linear indices are resolved in column-major order.
• Sparse slice indexing preserves sparse storage for non-scalar selections.
• Sparse indexed assignment currently raises RunMat:SparseAssignmentUnsupported instead of silently densifying or partially mutating storage.
• Sparse real matrices interoperate with +, -, and .* for sparse-sparse, sparse-dense, dense-sparse, sparse-scalar, character, logical, and complex operands. Addition and subtraction with dense, complex, or nonzero scalar operands return full storage when unstored sparse zeros become nonzero; sparse-preserving real products and sparse-sparse sums/differences return sparse storage.

Does RunMat run sparse on the GPU?

The GPU metadata for sparse is intentionally marked as gather-immediate. This makes the representation transition explicit to the planner and prevents pretending that dense GPU buffers are native sparse matrices.

GPU memory and residency

Sparse values are currently host-resident. Passing a GPU tensor to sparse triggers a gather, after which RunMat builds a compressed sparse column matrix on the host.

Examples

Creating a sparse matrix from triplets

S = sparse([1; 3; 2], [1; 2; 3], [10; 20; 30], 3, 3);
nnz(S)

Expected output:

ans = 3

Summing duplicate row and column pairs

S = sparse([1; 1; 2], [2; 2; 3], [4; 5; 6], 2, 3);
[r, c, v] = find(S);
v

Expected output:

v = [9; 6]

Converting a full matrix

A = [0 5; 7 0];
S = sparse(A);
size(S)

Expected output:

ans = [2 2]

Creating an empty sparse matrix

S = sparse(4, 5);
nnz(S)

Expected output:

ans = 0

Reading stored and unstored entries

S = sparse([1; 2], [1; 3], [10; 23], 3, 3);
a = full(S(1,1));
b = full(S(2,1));
c = full(S(8));
[a, b, c]

Expected output:

ans = [10 0 23]

Slicing keeps sparse storage

S = sparse([1; 3; 2], [1; 1; 3], [10; 30; 23], 3, 3);
T = S([1 2], [1 3]);
issparse(T)

Expected output:

ans = 1

Sparse arithmetic with dense and scalar operands

S = sparse([1; 3; 2], [1; 1; 2], [10; 30; 20], 3, 2);
A = full(3 .* S);
B = S + 2;

Expected output:

`A` is sparse-scaled then densified by `full`; `B` is a full matrix because sparse zeros become twos.

Using sparse with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how sparse changes the result.

FAQ

Related Array functions

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how sparse is executed, line by line, in Rust.

• View the source for sparse in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing