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

sparse creates a host-resident compressed sparse column matrix. MATLAB-compatible forms construct double, single, or logical sparse values as documented; runmat compatibility mode additionally supports exact sparse storage for all eight integer classes.

Syntax

S = sparse(A)
S = sparse(m, n)
S = sparse(m, n, typename)
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) stores only nonzero values and preserves documented double, single, or logical input class. Integer A is an exact RunMat-only extension.
• 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. All eight integer classes are accepted for i and j; when both are integer arrays they must use the same datatype and are parsed without a double round trip.
• Integer triplet values retain their exact class in runmat compatibility mode. Duplicate integer values use class-saturating addition; MATLAB-compatible modes reject the integer-value extension before construction.
• 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