There are several means to create sparse matrix.
There are many functions that directly return sparse matrices. These include speye, sprand, diag, etc.
The function sparse allows a sparse matrix to be constructed from three vectors representing the row, column and data. Alternatively, the function spconvert uses a three column matrix format to allow easy importation of data from elsewhere.
The function sparse or spalloc can be used to create an empty matrix that is then filled by the user
The user can directly create the sparse matrix within an oct-file.
There are several basic functions to return specific sparse
matrices. For example the sparse identity matrix, is a matrix that is
often needed. It therefore has its own function to create it as
speye (n) or speye (r, c), which
creates an n-by-n or r-by-c sparse identity
matrix.
Another typical sparse matrix that is often needed is a random distribution
of random elements. The functions sprand and sprandn perform
this for uniform and normal random distributions of elements. They have
exactly the same calling convention, where sprand (r, c,
d), creates an r-by-c sparse matrix with a density of
filled elements of d.
Other functions of interest that directly create sparse matrices, are diag or its generalization spdiags, that can take the definition of the diagonals of the matrix and create the sparse matrix that corresponds to this. For example,
s = diag (sparse (randn (1,n)), -1);
creates a sparse (n+1)-by-(n+1) sparse matrix with a single diagonal defined.
B = spdiags (A) ¶[B, d] = spdiags (A) ¶B = spdiags (A, d) ¶A = spdiags (v, d, A) ¶A = spdiags (v, d, m, n) ¶A generalization of the function diag.
Called with a single input argument, the nonzero diagonals d of A are extracted.
With two arguments the diagonals to extract are given by the vector d.
The other two forms of spdiags modify the input matrix by replacing
the diagonals. They use the columns of v to replace the diagonals
represented by the vector d. If the sparse matrix A is
defined then the diagonals of this matrix are replaced. Otherwise a
matrix of m by n is created with the diagonals given by the
columns of v.
Negative values of d represent diagonals below the main diagonal, and positive values of d diagonals above the main diagonal.
For example:
spdiags (reshape (1:12, 4, 3), [-1 0 1], 5, 4)
⇒ 5 10 0 0
1 6 11 0
0 2 7 12
0 0 3 8
0 0 0 4
See also: diag.
s = speye (m, n) ¶s = speye (m) ¶s = speye ([m, n]) ¶Return a sparse identity matrix of size mxn.
The implementation is significantly more efficient than
sparse (eye (m)) as the full matrix is not constructed.
When called with a single argument, a square matrix of size m-by-m is created. If called with a single vector argument, this argument is taken to be the size of the matrix to create.
r = spones (S) ¶Replace the nonzero entries of S with ones.
This creates a sparse matrix with the same structure as S.
s = sprand (m, n, d) ¶s = sprand (m, n, d, rc) ¶s = sprand (s) ¶Generate a sparse matrix with uniformly distributed random values.
The size of the matrix is mxn with a density of values d. d must be between 0 and 1. Values will be uniformly distributed on the interval (0, 1).
If called with a single matrix argument, a sparse matrix is generated with random values wherever the matrix s is nonzero.
If called with a scalar fourth argument rc, a random sparse matrix
with reciprocal condition number rc is generated. If rc is
a vector, then it specifies the first singular values of the generated
matrix (length (rc) <= min (m, n)).
s = sprandn (m, n, d) ¶s = sprandn (m, n, d, rc) ¶s = sprandn (s) ¶Generate a sparse matrix with normally distributed random values.
The size of the matrix is mxn with a density of values d. d must be between 0 and 1. Values will be normally distributed with a mean of 0 and a variance of 1.
If called with a single matrix argument, a sparse matrix is generated with random values wherever the matrix s is nonzero.
If called with a scalar fourth argument rc, a random sparse matrix
with reciprocal condition number rc is generated. If rc is
a vector, then it specifies the first singular values of the generated
matrix (length (rc) <= min (m, n)).
S = sprandsym (n, d) ¶S = sprandsym (s) ¶Generate a symmetric random sparse matrix.
The size of the matrix will be nxn, with a density of values given by d. d must be between 0 and 1 inclusive. Values will be normally distributed with a mean of zero and a variance of 1.
If called with a single matrix argument, a random sparse matrix is generated wherever the matrix s is nonzero in its lower triangular part.
The recommended way for the user to create a sparse matrix, is to create two vectors containing the row and column index of the data and a third vector of the same size containing the data to be stored. For example,
ri = ci = d = [];
for j = 1:c
ri = [ri; randperm(r,n)'];
ci = [ci; j*ones(n,1)];
d = [d; rand(n,1)];
endfor
s = sparse (ri, ci, d, r, c);
creates an r-by-c sparse matrix with a random distribution of n (<r) elements per column. The elements of the vectors do not need to be sorted in any particular order as Octave will sort them prior to storing the data. However, pre-sorting the data will make the creation of the sparse matrix faster.
The function spconvert takes a three or four column real matrix. The first two columns represent the row and column index respectively and the third and four columns, the real and imaginary parts of the sparse matrix. The matrix can contain zero elements and the elements can be sorted in any order. Adding zero elements is a convenient way to define the size of the sparse matrix. For example:
s = spconvert ([1 2 3 4; 1 3 4 4; 1 2 3 0]')
⇒ Compressed Column Sparse (rows=4, cols=4, nnz=3)
(1 , 1) -> 1
(2 , 3) -> 2
(3 , 4) -> 3
An example of creating and filling a matrix might be
k = 5;
nz = r * k;
s = spalloc (r, c, nz)
for j = 1:c
idx = randperm (r);
s (:, j) = [zeros(r - k, 1); ...
rand(k, 1)] (idx);
endfor
It should be noted, that due to the way that the Octave assignment functions are written that the assignment will reallocate the memory used by the sparse matrix at each iteration of the above loop. Therefore the spalloc function ignores the nz argument and does not pre-assign the memory for the matrix. Therefore, it is vitally important that code using to above structure should be vectorized as much as possible to minimize the number of assignments and reduce the number of memory allocations.
FM = full (SM) ¶Return a full storage matrix from a sparse, diagonal, or permutation matrix, or from a range.
s = spalloc (m, n, nz) ¶Create an m-by-n sparse matrix with pre-allocated space for at most nz nonzero elements.
This is useful for building a matrix incrementally by a sequence of indexed
assignments. Subsequent indexed assignments after spalloc will reuse
the pre-allocated memory, provided they are of one of the simple forms
s(I:J) = x
s(:,I:J) = x
s(K:L,I:J) = x
and that the following conditions are met:
nnz (S).
nnz (S) does not exceed nz.
Partial movement of data may still occur, but in general the assignment will be more memory and time efficient under these circumstances. In particular, it is possible to efficiently build a pre-allocated sparse matrix from a contiguous block of columns.
The amount of pre-allocated memory for a given matrix may be queried using
the function nzmax.
Programming Note: Octave always reserves memory for at least one value, even if nz is 0.
S = sparse (A) ¶S = sparse (m, n) ¶S = sparse (i, j, sv) ¶S = sparse (i, j, sv, m, n) ¶S = sparse (i, j, sv, m, n, "unique") ¶S = sparse (i, j, sv, m, n, nzmax) ¶Create a sparse matrix from a full matrix A or row, column, value triplets.
If A is a full matrix, convert it to a sparse matrix representation, removing all zero values in the process. The matrix A should be of type logical or double.
If two inputs m (rows) and n (columns) are specified then create an empty sparse matrix with the specified dimensions.
Given the integer index vectors i and j, and a 1-by-nnz
vector of real or complex values sv, construct the sparse matrix
S(i(k),j(k)) = sv(k) with overall
dimensions m and n. If any of i, j, or sv are
scalars, they are expanded to have a common size.
If m or n are not specified then their values are derived from the
maximum index in the vectors i and j as given by
m = max (i), n = max (j).
Note: If multiple values are specified with the same i,
j indices, the corresponding value in S will be the sum of the
values at the repeated location. See accumarray, for
an example of how to produce different behavior such as taking the minimum
instead.
If the option "unique" is given, and more than one value is specified
at the same i, j indices, then only the last specified value will
be used. For completeness, the option "sum" can be given and will
be ignored as the default behavior is to sum values at repeated locations.
sparse (m, n) will create an empty mxn sparse
matrix and is equivalent to sparse ([], [], [], m, n)
The optional final argument reserves space for nzmax values in the sparse
array and is useful if the eventual number of nonzero values will be greater
than the number of values in sv used during the initial construction of
the array. See spalloc, for more information and usage
instructions.
Example 1 (convert full matrix to sparse to save memory):
x = full (diag (1:1000)); sizeof (x) ⇒ 8000000 s = sparse (x); sizeof (xs) ⇒ 24008
Example 2 (sum at repeated indices):
i = [1 1 2]; j = [1 1 2]; sv = [3 4 5];
sparse (i, j, sv, 3, 4)
⇒
Compressed Column Sparse (rows = 3, cols = 4, nnz = 2 [17%])
(1, 1) -> 7
(2, 2) -> 5
Example 3 ("unique" option):
i = [1 1 2]; j = [1 1 2]; sv = [3 4 5];
sparse (i, j, sv, 3, 4, "unique")
⇒
Compressed Column Sparse (rows = 3, cols = 4, nnz = 2 [17%])
(1, 1) -> 4
(2, 2) -> 5
See also: full, accumarray, spalloc, spdiags, speye, spones, sprand, sprandn, sprandsym, spconvert, spfun.
x = spconvert (m) ¶Convert a simple sparse matrix format easily generated by other programs into Octave’s internal sparse format.
The input m is either a 3 or 4 column real matrix, containing the row, column, real, and imaginary parts of the elements of the sparse matrix. An element with a zero real and imaginary part can be used to force a particular matrix size.
See also: sparse.
The above problem of memory reallocation can be avoided in oct-files. However, the construction of a sparse matrix from an oct-file is more complex than can be discussed here. See External Code Interface, for a full description of the techniques involved.