S = sparse(i,j,v) generates a sparse matrix S from the triplets i, j, and v such that S(i(k),j(k)) = v(k). The max(i)-by-max(j) output matrix has space allotted for length(v) nonzero elements.

If the inputs i, j, and v are vectors or matrices, they must have the same number of elements. Alternatively, the argument v and/or one of the arguments i or j can be scalars.

Create a 10,000-by-10,000 full storage identity matrix.

  Name          Size                   Bytes  Class     Attributes

  A         10000x10000            800000000  double              

This matrix uses 800-megabytes of memory.

Convert the matrix to sparse storage.

  Name          Size                Bytes  Class     Attributes

  S         10000x10000            240008  double    sparse    

In sparse form, the same matrix uses roughly 0.25-megabytes of memory. In this case, you can avoid full storage completely by using the speye function, which creates sparse identity matrices directly.

S = 10000×5000 sparse double matrix
   All zero

Create a 1500-by-1500 sparse matrix from the triplets i, j, and v.

i = [900 1000];
j = [900 1000];
v = [10 100];
S = sparse(i,j,v,1500,1500)

S = 1500×1500 sparse double matrix (2 nonzeros)
 (900,900)     10
(1000,1000)   100

When you specify a size larger than max(i) -by- max(j), the sparse function pads the output with extra rows and columns of zeros.

Create a sparse matrix with 10 nonzero values, but which has space allocated for 100 nonzero values.

S = sparse(1:10,1:10,5,20,20,100);
N = nnz(S)

The spalloc function is a shorthand way to create a sparse matrix with no nonzero elements but which has space allotted for some number of nonzeros.

Use repeated subscripts to accumulate values into a single sparse matrix that would otherwise require one or more loops.

Create a column vector of data and two column vectors of subscripts.

i = [6 6 6 5 10 10 9 9]';
j = [1 1 1 2 3 3 10 10]';
v = [100 202 173 305 410 550 323 121]';

Visualize the subscripts and values side-by-side.

ans = 8×3

     6     1   100
     6     1   202
     6     1   173
     5     2   305
    10     3   410
    10     3   550
     9    10   323
     9    10   121

Use the sparse function to accumulate the values that have identical subscripts.

S = 10×10 sparse double matrix (4 nonzeros)
   (6,1)      475
   (5,2)      305
  (10,3)      960
   (9,10)     444

Input matrix, specified as a full or sparse matrix. If A is already sparse, then sparse(A) returns A.

Data Types: single | double | logical
Complex Number Support: Yes

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Data Types: single | double | logical
Complex Number Support: Yes

Size of each dimension, specified as separate arguments of integer values. If you specify m (the row size), you also must specify n (the column size).

If you do not specify m and n, then sparse uses the default values m = max(i) and n = max(j). These maxima are computed before any zeros in v are removed.

Since R2025a

Output data type, specified as "double", "single", or "logical".

Storage allocation for nonzero elements, specified as a nonnegative integer. nz generally must be greater than or equal to max([numel(i), numel(j), numel(v), 1]). However, if the sizes of i, j, and v allow you to specify a value of 0 for nz, then sparse instead sets the value to 1.

For a sparse matrix, S, the nnz function returns the number of nonzero elements in the matrix, and the nzmax function returns the amount of storage allocated for nonzero matrix elements. If nnz(S) and nzmax(S) return different results, then more storage might be allocated than is actually required. For this reason, set nz only in anticipation of later fill-in.

If you do not specify nz, then sparse uses a default value of max([numel(i), numel(j), numel(v), 1]).

Usage notes and limitations:

The sparse function supports GPU array input with these usage notes and limitations:

For more information about creating and using sparse GPU arrays, see Work with Sparse Arrays on a GPU (Parallel Computing Toolbox).

A = [0 0 0 5; 0 2 0 0; 1 3 0 0; 0 0 4 0];
sparse(A)

  4×4 sparse double matrix (5 nonzeros)

   (3,1)        1
   (2,2)        2
   (3,2)        3
   (4,3)        4
   (1,4)        5