Create sparse distributed or codistributed matrix

`SD = sparse(FD)`

SC = sparse(m,n,codist)

SC = sparse(m,n,codist,'noCommunication')

SC = sparse(i,j,v,m,n,nzmax)

SC = sparse(i,j,v,m,n)

SC = sparse(i,j,v)

`SD = sparse(FD)`

converts a full distributed or codistributed
array `FD`

to a sparse distributed or codistributed (respectively)
array `SD`

.

`SC = sparse(m,n,codist)`

creates an
`m`

-by-`n`

sparse codistributed array of
underlying class double, distributed according to the scheme defined by the
codistributor `codist`

. For information on constructing
codistributor objects, see the reference pages for `codistributor1d`

and `codistributor2dbc`

. This form of
the syntax is most useful inside `spmd`

or a communicating
job.

`SC = sparse(m,n,codist,'noCommunication')`

creates an
`m`

-by-`n`

sparse codistributed array in the
manner specified above, but does not perform any global communication for error
checking when constructing the array. This form of the syntax is most useful inside
`spmd`

or a communicating job.

`SC = sparse(i,j,v,m,n,nzmax)`

uses vectors
`i`

and `j`

to specify indices, and
`v`

to specify element values, for generating an
`m`

-by-`n`

sparse matrix such that
`SC(i(k),j(k)) = v(k)`

, with space allocated for
`nzmax`

nonzeros. If any of the input vectors
`i`

, `j`

, or `v`

is
codistributed, the output sparse matrix `SC`

is codistributed.
Vectors `i`

, `j`

, and `v`

must be
the same length. Any elements of `v`

that are zero are ignored,
along with the corresponding values of `i`

and
`j`

. Any elements of `v`

that have duplicate
values of `i`

and `j`

are added together.

To simplify this six-argument call, you can pass scalars for the argument
`v`

and one of the arguments `i`

or
`j`

, in which case they are expanded so that
`i`

, `j`

, and `v`

all have
the same length.

`SC = sparse(i,j,v,m,n)`

uses ```
nzmax
= max([length(i) length(j)])
```

.

`SC = sparse(i,j,v)`

uses ```
m =
max(i)
```

and `n = max(j)`

. The maxima are computed
before any zeros in `v`

are removed, so one of the rows of
`[i j v]`

might be `[m n 0]`

, assuring the
matrix size satisfies the requirements of `m`

and
`n`

.

**Note**

To create a sparse codistributed array of underlying class logical, first
create an array of underlying class double and then cast it using the `logical`

function:

spmd SC = logical(sparse(m,n,codistributor1d())); end

With four workers,

spmd(4) C = sparse(1000,1000,codistributor1d()) end

creates a 1000-by-1000 codistributed sparse double array `C`

.
`C`

is distributed by its second dimension (columns), and each
worker contains a 1000-by-250 local piece of `C`

.

spmd(4) codist = codistributor1d(2,1:numlabs) C = sparse(10,10,codist); end

creates a 10-by-10 codistributed sparse double array `C`

,
distributed by its columns. Each worker contains a
10-by-`labindex`

local piece of `C`

.

Convert a distributed array into a sparse distributed array:

R = rand(1000,'distributed'); D = floor(2*R); % D also is distributed SD = sparse(D); % SD is sparse distributed

Create a sparse codistributed array from vectors of indices and a distributed array of element values:

r = [ 1 1 4 4 8]; c = [ 1 4 1 4 8]; v = [10 20 30 40 0]; V = distributed(v); spmd SC = sparse(r,c,V); end

In this example, even though the fifth element of the value array
`v`

is 0, the size of the result is an 8–by-8 matrix because of
the corresponding maximum indices in `r`

and `c`

.
Matrix `SC`

is considered codistributed when viewed inside an
`spmd`

block, and distributed when viewed from the client
workspace. To view a full version of the matrix, the `full`

function converts this distributed sparse array to a full distributed array:

S = full(SC)

10 0 0 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 30 0 0 40 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0