Visitar URL original
SparseArray—Wolfram Documentation

WOLFRAM

Wolfram Language & System Documentation Center

"SparseArray" (Compiled Type)

"SparseArray"::[type,rank]

represents a sparse array type with elements of specified type and rank.

Details

  • "SparseArray" can be used in Typed and related constructs to specify a type.
  • "SparseArray" objects are automatically memory managed.

Properties

  • With "SparseArray"::[type, rank], unspecified values are always taken to be zero and rank can only be 1 or 2.

Expression Conversions

    From Expressions

  • SparseArray expressions can be converted into compiled code elements with types created with "SparseArray".

    • To Expressions

  • Compiled code elements with types created with "SparseArray" can be converted into SparseArray expressions.

Examples

open all close all

Basic Examples  (1)

"SparseArray" can be used as an input and output from a CompiledCodeFunction:

Wolfram Language code: cf = FunctionCompile[Function[Typed[arg, "SparseArray"::["Integer64", 2]], arg]]
Wolfram Language code: cf[SparseArray[{{1, 0, 2}, {0, 3, 0}}]]
Wolfram Language code: MatrixForm[%]

Scope  (1)

SparseArray properties may be used within CompiledCodeFunction:

Wolfram Language code: cf = FunctionCompile[Function[Typed[arg, "SparseArray"::["MachineReal", 2]], Module[{nz, dims, nelems }, nz = arg["ExplicitLength"]; dims = Dimensions[arg]; nelems = Typed[1., "MachineReal"]; Do[nelems *= dims[[i]], {i, Length[dims]}]; Cast[nz, "MachineReal"] / nelems ]]]
Wolfram Language code: cf[SparseArray[{{1., 0, 2.}, {0, 3., 0}}]]

This is equivalent to the "Density" property:

Wolfram Language code: SparseArray[{{1., 0, 2.}, {0, 3., 0}}]["Density"]

The function uses real arithmetic so that it works even when the total number of elements is too large for a machine-sized integer:

Wolfram Language code: cf[SparseArray[{{1, 1} -> 1.}, {10 ^ 6, 10 ^ 16}]]

Neat Examples  (1)

Compute a power series of a sparse matrix:

Wolfram Language code: cf = FunctionCompile[Function[{ Typed[coeffs, "PackedArray"::["MachineReal", 1]], Typed[a, "SparseArray"::["MachineReal", 2]]}, Module[{res, len, n}, n = Length[a]; len = Length[coeffs]; res = DiagonalMatrix[coeffs[[len]], 0, n, SparseArray]; Do[ res = res.a + DiagonalMatrix[coeffs[[i]], 0, n, SparseArray], {i, len - 1, 1, -1} ]; res ] ]]

This is equivalent to computing the square of a matrix:

Wolfram Language code: sp = SparseArray[{{1, 1} -> 1., {2, 2} -> 2., {3, 3} -> 3., {1, 3} -> 4.}]; cf[{0, 0, 1}, sp]//Normal

Generate coefficients of the exponential function and use them to compute a matrix exponential:

Wolfram Language code: coeffs = CoefficientList[ Normal[ Series[Exp[x], {x, 0, 16}]], x]; cf[N[coeffs], sp]//Normal

The MatrixExp function is a better way to compute the exponential, but the power series result was close:

Wolfram Language code: MatrixExp[sp]//Normal