稀疏数组

Julia支持稀疏向量和https://en.wikipedia.org/wiki/Sparse_matrix[稀疏矩阵]在 [医]麻雀 stdlib模块。稀疏数组是包含足够的零的数组，与密集数组相比，将它们存储在特殊的数据结构中可以节省空间和执行时间。

实现不同稀疏存储类型、多维稀疏数组等的外部包可以在值得注意的外部稀疏包

压缩稀疏列(CSC)稀疏矩阵存储

在Julia中，稀疏矩阵存储在https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_.28CSC_or_CCS.29[压缩稀疏列（CSC）格式]。 Julia稀疏矩阵具有类型 [医麻雀{Tv,Ti}]，在哪里 电视 是存储值的类型，以及 蒂 是用于存储列指针和行索引的整数类型。的内部表示 [医]麻雀 如下所示:

struct SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrixCSC{Tv,Ti}
    m::Int                  # Number of rows
    n::Int                  # Number of columns
    colptr::Vector{Ti}      # Column j is in colptr[j]:(colptr[j+1]-1)
    rowval::Vector{Ti}      # Row indices of stored values
    nzval::Vector{Tv}       # Stored values, typically nonzeros
end

压缩的稀疏列存储使得访问稀疏矩阵列中的元素变得容易和快速，而按行访问稀疏矩阵的速度要慢得多。诸如在CSC结构中一次插入一个以前未存储的条目之类的操作往往很慢。这是因为稀疏矩阵中超出插入点的所有元素都必须移动一个位置。

对稀疏矩阵的所有操作都经过仔细实施，以利用CSC数据结构来提高性能，并避免昂贵的操作。

如果您有来自不同应用程序或库的CSC格式的数据，并希望在Julia中导入它，请确保使用基于1的索引。每列中的行索引都需要排序，如果不是，矩阵将显示不正确。如果您的 [医]麻雀 对象包含未排序的行索引，对它们进行排序的一种快速方法是执行双重转置。由于转置操作是懒惰的，所以制作一个副本来实现每个转置。

在某些应用程序中，将显式零值存储在 [医]麻雀. 这些_are_被函数接受 基地 （但不能保证它们将在变异操作中保留）。这样显式存储的零被许多例程视为结构非零。该 nnz函数返回显式存储在稀疏数据结构中的元素数，包括非结构零。为了计算数值nonzeros的确切数量，使用 算（！iszero，x），它检查稀疏矩阵的每个存储元素。 滴管,滴管，而就地 dropzeros！，可用于从稀疏矩阵中移除存储的零。

julia> A = sparse([1, 1, 2, 3], [1, 3, 2, 3], [0, 1, 2, 0])
3×3 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
 0  ⋅  1
 ⋅  2  ⋅
 ⋅  ⋅  0

julia> dropzeros(A)
3×3 SparseMatrixCSC{Int64, Int64} with 2 stored entries:
 ⋅  ⋅  1
 ⋅  2  ⋅
 ⋅  ⋅  ⋅

稀疏向量存储

稀疏向量以类似于稀疏矩阵的压缩稀疏列格式存储。在Julia中，稀疏向量具有类型 [医麻雀{Tv,Ti}]哪里 电视 是存储值的类型和 蒂 索引的整数类型。内部表示如下:

struct SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}
    n::Int              # Length of the sparse vector
    nzind::Vector{Ti}   # Indices of stored values
    nzval::Vector{Tv}   # Stored values, typically nonzeros
end

至于 [医麻雀]，该 [医]麻雀 类型还可以包含显式存储的零。（见稀疏矩阵存储。).

稀疏向量和矩阵构造函数

创建稀疏数组的最简单方法是使用与 零Julia提供的用于处理密集数组的函数。要生成稀疏数组，您可以使用与 sp 前缀:

julia> spzeros(3)
3-element SparseVector{Float64, Int64} with 0 stored entries

该 稀疏函数通常是构造稀疏数组的方便方法。例如，要构造稀疏矩阵，我们可以输入一个向量 我 行索引，向量 J 列索引和向量 V 存储值（也称为https://en.wikipedia.org/wiki/Sparse_matrix#Coordinate_list_.28COO.29[COO（坐标）格式]）。 稀疏（I，J，V） 然后构造一个稀疏矩阵，使得 S[I[k],J[k]]=V[k]. 等效的稀疏向量构造函数为 斯帕塞维克，其中取（行）索引向量 我 和向量 V 用存储的值并构造稀疏向量 R 这样， R[I[k]]=V[k].

julia> I = [1, 4, 3, 5]; J = [4, 7, 18, 9]; V = [1, 2, -5, 3];

julia> S = sparse(I,J,V)
5×18 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
⎡⠀⠈⠀⠀⠀⠀⠀⠀⢀⎤
⎣⠀⠀⠀⠂⡀⠀⠀⠀⠀⎦

julia> R = sparsevec(I,V)
5-element SparseVector{Int64, Int64} with 4 stored entries:
  [1]  =  1
  [3]  =  -5
  [4]  =  2
  [5]  =  3

的逆 稀疏和 斯帕塞维克功能是 查找nz，它检索用于创建稀疏数组的输入（包括等于零的存储条目）。 findall（！iszero，x）返回非零条目的笛卡尔索引 x （不包括等于零的存储条目）。

julia> findnz(S)
([1, 4, 5, 3], [4, 7, 9, 18], [1, 2, 3, -5])

julia> findall(!iszero, S)
4-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 4)
 CartesianIndex(4, 7)
 CartesianIndex(5, 9)
 CartesianIndex(3, 18)

julia> findnz(R)
([1, 3, 4, 5], [1, -5, 2, 3])

julia> findall(!iszero, R)
4-element Vector{Int64}:
 1
 3
 4
 5

创建稀疏数组的另一种方法是使用 稀疏功能:

julia> sparse(Matrix(1.0I, 5, 5))
5×5 SparseMatrixCSC{Float64, Int64} with 5 stored entries:
 1.0   ⋅    ⋅    ⋅    ⋅
  ⋅   1.0   ⋅    ⋅    ⋅
  ⋅    ⋅   1.0   ⋅    ⋅
  ⋅    ⋅    ⋅   1.0   ⋅
  ⋅    ⋅    ⋅    ⋅   1.0

julia> sparse([1.0, 0.0, 1.0])
3-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0

你可以去另一个方向使用 阵列构造函数。该 伊斯帕尔斯函数可用于查询矩阵是否稀疏。

julia> issparse(spzeros(5))
true

稀疏矩阵运算

稀疏矩阵上的算术运算也像它们在密集矩阵上一样工作。稀疏矩阵的索引、赋值和连接的工作方式与密集矩阵相同。当一次执行一个元素时，索引操作，特别是分配，是昂贵的。在许多情况下，将稀疏矩阵转换为 （I，J，V） 使用格式 查找nz，操作密集向量中的值或结构 （I，J，V），然后重建稀疏矩阵。

密集和稀疏方法的对应关系

下表给出了稀疏矩阵上的内置方法与密集矩阵类型上的相应方法之间的对应关系。通常，生成稀疏矩阵的方法与密集矩阵的不同之处在于，生成的矩阵遵循与给定稀疏矩阵相同的稀疏模式 S，或者说所得到的稀疏矩阵具有密度 d，即每个矩阵元素都有一个概率 d 不为零。

详情可参阅稀疏向量和矩阵标准库参考部分。

稀疏密集资料描述

稀疏	密集	资料描述
`spzeros（m，n）`	`零(m,n)`	创建一个由零组成的_m_by-_n_矩阵。 (`spzeros（m，n）`是空的。)
`稀疏(I,n,n)`	`矩阵(I,n,n)`	创建一个_n_by-_n_单位矩阵。
`稀疏(A)`	`阵列(S)`	密集和稀疏格式之间的转换。
`斯普朗(m,n,d)`	`兰德(m,n)`	创建具有均匀分布在半开区间上的iid非零元素的_m_by-n_随机矩阵（密度_d） .
`斯普朗德(m,n,d)`	`兰德(m,n)`	创建一个_m_by-n_随机矩阵（密度_d），其中包含根据标准正态（高斯）分布分布的iid非零元素。
`sprandn（rng，m，n，d）`	`randn（rng，m，n）`	创建一个_m_by-n_随机矩阵（密度_d），其中包含与 `[医]rng` 随机数发生器

spzeros（m，n）

零(m,n)

创建一个由零组成的_m_by-_n_矩阵。 (spzeros（m，n）是空的。)

创建一个_n_by-_n_单位矩阵。

密集和稀疏格式之间的转换。

创建具有均匀分布在半开区间上的iid非零元素的_m_by-n_随机矩阵（密度_d） .

斯普朗德(m,n,d)

兰德(m,n)

创建一个_m_by-n_随机矩阵（密度_d），其中包含根据标准正态（高斯）分布分布的iid非零元素。

sprandn（rng，m，n，d）

randn（rng，m，n）

创建一个_m_by-n_随机矩阵（密度_d），其中包含与 [医]rng 随机数发生器

SparseArrays空气污染指数

# *`麻雀。[医]抽象粒子`*-类型

AbstractSparseArray{Tv,Ti,N}

超类型为 N-具有类型元素的维稀疏数组（或类数组类型） 电视 和索引类型 蒂. [医麻雀], [医麻雀]和 诉讼。霍莫德。稀疏 是这个的亚型。

# *`麻雀。AbstractSparseVector`*-类型

AbstractSparseVector{Tv,Ti}

具有类型元素的一维稀疏数组（或类数组类型）的超类型 电视 和索引类型 蒂. 别名为 [医]抽象粒子{Tv,Ti,1}.

# *`麻雀。N.抽象,抽象`*-类型

AbstractSparseMatrix{Tv,Ti}

具有类型元素的二维稀疏数组（或类数组类型）的超类型 电视 和索引类型 蒂. 别名为 [医]抽象粒子{Tv,Ti,2}.

# *`麻雀。[医]麻雀`*-类型

SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}

用于存储稀疏向量的向量类型。可以通过传递向量的长度，非零索引的_sorted_向量和非零值的向量来创建。

例如，向量 [5, 6, 0, 7] 可以表示为

SparseVector(4, [1, 2, 4], [5, 6, 7])

这表明索引1处的元素为5，索引2处为6，索引3处为 零(Int)，并且在索引4处为7。

使用以下方法直接从密集向量创建稀疏向量可能更方便 稀疏 作为

sparse([5, 6, 0, 7])

产生相同的稀疏向量。

# *`麻雀。[医]麻雀`*-类型

SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrixCSC{Tv,Ti}

用于存储稀疏矩阵的矩阵类型压缩稀疏列格式。构造SparseMatrixCSC的标准方式是通过 稀疏功能。请参阅 斯普泽罗斯, spdiagm和 斯普兰德.

# *`麻雀。稀疏`*-函数

sparse(A::Union{AbstractVector, AbstractMatrix})

转换向量或矩阵 A 成稀疏数组。数字零在 A 化为结构零。

*例子*

julia> A = Matrix(1.0I, 3, 3)
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> sparse(A)
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 1.0   ⋅    ⋅
  ⋅   1.0   ⋅
  ⋅    ⋅   1.0

julia> [1.0, 0.0, 1.0]
3-element Vector{Float64}:
 1.0
 0.0
 1.0

julia> sparse([1.0, 0.0, 1.0])
3-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0

sparse(I, J, V,[ m, n, combine])

创建稀疏矩阵 S 尺寸 m x n 这样， S[I[k],J[k]]=V[k]. 该 联合收割机 函数用于组合重复项。如果 m 和 n 未指定，它们被设置为 最大值(I) 和 最大(J) 分别。如果 联合收割机 功能不提供, 联合收割机 默认值为 + 除非 V 在这种情况下是布尔值 联合收割机 默认值为 |. 所有元素 我 必须满足 1<=I[k]<=m，以及 J 必须满足 1<=J[k]<=n. 数值零在(我, J, V)保留为结构非零；若要删除数值零，请使用 dropzeros！.

有关其他文档和专家驱动程序，请参阅 麻雀。稀疏！.

*例子*

julia> Is = [1; 2; 3];

julia> Js = [1; 2; 3];

julia> Vs = [1; 2; 3];

julia> sparse(Is, Js, Vs)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 1  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  3

# *`麻雀。稀疏！`*-函数

sparse!(I::AbstractVector{Ti}, J::AbstractVector{Ti}, V::AbstractVector{Tv},
        m::Integer, n::Integer, combine, klasttouch::Vector{Ti},
        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv},
        [csccolptr::Vector{Ti}], [cscrowval::Vector{Ti}, cscnzval::Vector{Tv}] ) where {Tv,Ti<:Integer}

家长及专家司机 稀疏；见 稀疏基本用法。此方法允许用户提供预分配的存储 稀疏中间对象和结果如下所述。这种能力可以更有效地连续构建 [医麻雀]从坐标表示中提取，并且还可以提取结果转置的未排序列表示，无需额外费用。

该方法包括三个主要步骤：（1）计数-将提供的坐标表示排序为包括重复条目的未排序的行CSR形式。 (2)扫描CSR表单，同时计算所需的CSC表单的列指针数组，检测重复条目，并将重复条目组合起来重新打包CSR表单；此阶段生成一个没有重复条目的未排序行CSR表单。（3）计数-将前面的CSR表单排序为完全排序的CSC表单，没有重复条目。

输入数组 [医]csrrowptr, [医]血管造影，而 [医]csrnzval 构成中间CSR表格的存储，并要求 长度(csrrowptr)>=m+1, 长度(csrcolval)>=长度(I)，而 长度(csrnzval>=长度(I)). 输入数组 [医]克拉斯图，第二阶段的工作空间，需要 长度(klasttouch)>=n. 可选输入数组 [医]cscolptr, cscrowval的，而 cscnzval 为退回的CSC表格构成存储 S. 如有必要，这些会自动调整大小以满足 长度(cscolptr)=n+1, 长度(cscrowval)=nnz(S) 和 长度(cscnzval)=nnz(S);因此，如果 nnz(南) 一开始是未知的，传入适当类型的空向量（向量{Ti}() 和 向量{Tv}() 分别）就足够了，或调用 稀疏！ 方法忽略 [医]cscrowval 和 [医]cscnzval.

返回时, [医]csrrowptr, [医]血管造影，而 [医]csrnzval 包含结果转置的未排序列表示形式。

您可以重用输入数组的存储（我, J, V)对于输出数组([医]cscolptr, [医]cscrowval, cscnzval). 例如，您可以调用 稀疏！(I,J,V,csrrowptr,csrcolval,csrnzval,I,J,V). 请注意，它们将调整大小以满足上述条件。

为了提高效率，此方法不执行参数检查。 1<=I[k]<=m 和 1<=J[k]<=n. 小心使用。测试与 --检查边界=是 是明智的。

此方法运行在 O(m,n,长度(I)) 时间。 F.Gustavson,"two fast algorithms for sparse matrices:multiplication and permuted transposition,"ACM TOMS4(3),250-269(1978)中描述的HALFPERM算法启发了该方法对一对计数排序的使用。

SparseArrays.sparse!(I, J, V, [m, n, combine]) -> SparseMatrixCSC

的变体 稀疏！ 它重新使用输入向量（我, J, V)进行最终的矩阵存储。构造后，输入向量将别名矩阵缓冲区; S.colptr===我, S.rowval===J，而 S.nzval===V 持有，他们将是 调整大小！d根据需要。

请注意，仍会分配一些工作缓冲区。具体来说，这个方法是一个方便的包装 稀疏！(I,J,V,m,n,combine,klasttouch,csrrowptr,csrcolval,csrnzval,csccolptr,cscrowval,cscnzval) 此方法分配的位置 [医]克拉斯图, [医]csrrowptr, [医]血管造影，而 [医]csrnzval 大小合适，但可重复使用 我, J，而 V 为 [医]cscolptr, [医]cscrowval，而 cscnzval.

争论 m, n，而 联合收割机 默认值为 最大值(I), 最大值(J)，而 +，分别。

兼容性

Julia1.10此方法需要Julia1.10或更高版本。

# *`麻雀。斯帕塞维克`*-函数

sparsevec(I, V, [m, combine])

创建稀疏向量 S 长度 m 这样， S[I[k]]=V[k]. 重复项使用 联合收割机 函数，默认为 + 如果没有 联合收割机 提供参数，除非 V 在这种情况下是布尔值 联合收割机 默认值为 |.

*例子*

julia> II = [1, 3, 3, 5]; V = [0.1, 0.2, 0.3, 0.2];

julia> sparsevec(II, V)
5-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  0.5
  [5]  =  0.2

julia> sparsevec(II, V, 8, -)
8-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  -0.1
  [5]  =  0.2

julia> sparsevec([1, 3, 1, 2, 2], [true, true, false, false, false])
3-element SparseVector{Bool, Int64} with 3 stored entries:
  [1]  =  1
  [2]  =  0
  [3]  =  1

sparsevec(d::Dict, [m])

创建长度的稀疏向量 m 其中非零索引是字典中的键，非零值是字典中的值。

*例子*

julia> sparsevec(Dict(1 => 3, 2 => 2))
2-element SparseVector{Int64, Int64} with 2 stored entries:
  [1]  =  3
  [2]  =  2

sparsevec(A)

转换向量 A 成长度的稀疏向量 m. 数字零在 A 化为结构零。

*例子*

julia> sparsevec([1.0, 2.0, 0.0, 0.0, 3.0, 0.0])
6-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  2.0
  [5]  =  3.0

# *`基地。类似的`*-Method

similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

根据给定的源，使用给定的元素类型、索引类型和大小创建未初始化的可变数组 [医]麻雀. 新的稀疏矩阵保持原始稀疏矩阵的结构，除了在输出矩阵的维度与输出不同的情况下。

输出矩阵在与输入相同的位置上有零，但非零位置的值未初始化。

# *`麻雀。伊斯帕尔斯`*-函数

issparse(S)

申报表 真的 如果 S 是稀疏的，并且 错误 否则。

*例子*

julia> sv = sparsevec([1, 4], [2.3, 2.2], 10)
10-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  2.3
  [4]  =  2.2

julia> issparse(sv)
true

julia> issparse(Array(sv))
false

# *`麻雀。nnz`*-函数

nnz(A)

返回稀疏数组中存储（填充）元素的数量。

*例子*

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 2  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  2

julia> nnz(A)
3

# *`麻雀。查找nz`*-函数

findnz(A::SparseMatrixCSC)

返回一个元组 （I，J，V） 哪里 我 和 J 是稀疏矩阵中存储（"结构非零"）值的行和列索引 A，而 V 是值的向量。

*例子*

julia> A = sparse([1 2 0; 0 0 3; 0 4 0])
3×3 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
 1  2  ⋅
 ⋅  ⋅  3
 ⋅  4  ⋅

julia> findnz(A)
([1, 1, 3, 2], [1, 2, 2, 3], [1, 2, 4, 3])

# *`麻雀。斯普泽罗斯`*-函数

spzeros([type,]m[,n])

创建长度的稀疏向量 m 或大小的稀疏矩阵 m x n. 此稀疏数组将不包含任何非零值。在构造期间不会为非零值分配任何存储。类型默认为 漂浮64如果没有指定。

*例子*

julia> spzeros(3, 3)
3×3 SparseMatrixCSC{Float64, Int64} with 0 stored entries:
  ⋅    ⋅    ⋅
  ⋅    ⋅    ⋅
  ⋅    ⋅    ⋅

julia> spzeros(Float32, 4)
4-element SparseVector{Float32, Int64} with 0 stored entries

spzeros([type], I::AbstractVector, J::AbstractVector, [m, n])

创建稀疏矩阵 S 尺寸 m x n 结构零在 S[I[k],J[k]].

该方法可用于构造矩阵的稀疏模式，并且比使用例如 稀疏（I，J，零（长度（I）））.

有关其他文档和专家驱动程序，请参阅 麻雀。斯普泽罗斯！.

兼容性

Julia1.10此方法需要Julia1.10或更高版本。

# *`麻雀。斯普泽罗斯！`*-函数

spzeros!(::Type{Tv}, I::AbstractVector{Ti}, J::AbstractVector{Ti}, m::Integer, n::Integer,
         klasttouch::Vector{Ti}, csrrowptr::Vector{Ti}, csrcolval::Vector{Ti},
         [csccolptr::Vector{Ti}], [cscrowval::Vector{Ti}, cscnzval::Vector{Tv}]) where {Tv,Ti<:Integer}

家长及专家司机 spzeros（I，J） 允许用户为中间对象提供预分配存储。这种方法是 斯普泽罗斯 什么 麻雀。稀疏！ 是要 稀疏. 请参阅以下文档 麻雀。稀疏！ 有关详细信息和所需的缓冲长度。

兼容性

Julia1.10此方法需要Julia1.10或更高版本。

SparseArrays.spzeros!(::Type{Tv}, I, J, [m, n]) -> SparseMatrixCSC{Tv}

的变体 斯普泽罗斯！ 重新使用输入向量 我 和 J 于最终的矩阵存储。构造后，输入向量将别名矩阵缓冲区; S.colptr===我 和 S.rowval===J 持有，他们将是 调整大小！d根据需要。

请注意，仍会分配一些工作缓冲区。具体来说，这个方法是一个方便的包装 斯普泽罗斯！(Tv,I,J,m,n,klasttouch,csrrowptr,csrcolval,csccolptr,cscrowval) 此方法分配的位置 [医]克拉斯图, [医]csrrowptr，而 [医]血管造影 大小合适，但可重复使用 我 和 J 为 [医]cscolptr 和 cscrowval的.

争论 m 和 n 默认值为 最大值(I) 和 最大值(J).

兼容性

Julia1.10此方法需要Julia1.10或更高版本。

# *`麻雀。spdiagm`*-函数

spdiagm(kv::Pair{<:Integer,<:AbstractVector}...)
spdiagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

从构造稀疏对角矩阵 对向量和对角线的s。每个向量 千伏。第二 将被放置在 千伏。第一个 对角线。默认情况下，矩阵是正方形，其大小是从 千伏,千伏，但非正方形大小 m×n （根据需要用零填充）可以通过传递指定 m，n 作为第一个论点。

*例子*

julia> spdiagm(-1 => [1,2,3,4], 1 => [4,3,2,1])
5×5 SparseMatrixCSC{Int64, Int64} with 8 stored entries:
 ⋅  4  ⋅  ⋅  ⋅
 1  ⋅  3  ⋅  ⋅
 ⋅  2  ⋅  2  ⋅
 ⋅  ⋅  3  ⋅  1
 ⋅  ⋅  ⋅  4  ⋅

spdiagm(v::AbstractVector)
spdiagm(m::Integer, n::Integer, v::AbstractVector)

以向量的元素为对角元素构造稀疏矩阵。默认情况下（没有给出 m 和 n），矩阵是正方形，其大小由下式给出 长度(v)，但非正方形大小 m×n 可以通过传递指定 m 和 n 作为第一个论点。

兼容性

Julia1.6这些函数至少需要Julia1.6。

*例子*

julia> spdiagm([1,2,3])
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 1  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  3

julia> spdiagm(sparse([1,0,3]))
3×3 SparseMatrixCSC{Int64, Int64} with 2 stored entries:
 1  ⋅  ⋅
 ⋅  ⋅  ⋅
 ⋅  ⋅  3

# *`麻雀。sparse_hcat`*-函数

sparse_hcat(A...)

沿着尺寸2连接。返回SparseMatrixCSC对象。

兼容性

Julia1.8这种方法是在Julia1.8中加入的。它模仿以前的连接行为，其中与LinearAlgebra的专门"稀疏"矩阵类型的连接。即使在没有任何SparseArray参数的情况下，jl也会自动产生稀疏输出。

# *`麻雀。sparse_vcat`*-函数

sparse_vcat(A...)

沿着尺寸1连接。返回SparseMatrixCSC对象。

兼容性

# *`麻雀。sparse_hvcat`*-函数

sparse_hvcat(rows::Tuple{Vararg{Int}}, values...)

稀疏水平和垂直连接在一个调用. 块矩阵语法调用此函数。第一个参数指定要在每个块行中连接的参数的数量。

兼容性

Julia1.8这种方法是在Julia1.8中加入的。它模仿以前的连接行为，其中连接与线性代数的专门的"稀疏"矩阵类型。即使在没有任何SparseArray参数的情况下，jl也会自动产生稀疏输出。

# *`麻雀。n.块体,块体`*-函数

blockdiag(A...)

串联矩阵块-对角线。目前仅针对稀疏矩阵实现。

*例子*

julia> blockdiag(sparse(2I, 3, 3), sparse(4I, 2, 2))
5×5 SparseMatrixCSC{Int64, Int64} with 5 stored entries:
 2  ⋅  ⋅  ⋅  ⋅
 ⋅  2  ⋅  ⋅  ⋅
 ⋅  ⋅  2  ⋅  ⋅
 ⋅  ⋅  ⋅  4  ⋅
 ⋅  ⋅  ⋅  ⋅  4

# *`麻雀。斯普兰德`*-函数

sprand([rng],[T::Type],m,[n],p::AbstractFloat)
sprand([rng],m,[n],p::AbstractFloat,[rfn=rand])

创建随机长度 m 稀疏向量或 m 由 n 稀疏矩阵，其中任何元素非零的概率独立地由 p （因此nonzeros的平均密度也正是 p). 可选项 [医]rng 参数指定随机数生成器，请参阅随机数。可选项 T 参数指定元素类型，默认为 漂浮64.

默认情况下，使用 兰德功能，即通过 兰德(T)，或 兰德(rng,T) 如果 [医]rng 被提供；对于默认 T=浮64，这对应于均匀采样的非零值 [0,1).

您可以通过传递自定义来对不同分布中的非零值进行采样 射频 功能而不是 兰德. 这应该是一个功能 射频(k) 它返回一个 k 从所需分布中采样的随机数；或者，如果 [医]rng 被提供，它应该是一个函数 rfn（rng，k）.

*例子*

julia> sprand(Bool, 2, 2, 0.5)
2×2 SparseMatrixCSC{Bool, Int64} with 2 stored entries:
 1  1
 ⋅  ⋅

julia> sprand(Float64, 3, 0.75)
3-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  0.795547
  [2]  =  0.49425

# *`麻雀。斯普朗德`*-函数

sprandn([rng][,Type],m[,n],p::AbstractFloat)

创建长度的随机稀疏向量 m 或大小的稀疏矩阵 m 由 n 具有指定的（独立的）概率 p 任何非零项，其中非零值是从正态分布中采样的。可选项 [医]rng 参数指定随机数生成器，请参阅随机数。

兼容性

Julia1.1指定输出元素类型 类型 至少需要Julia1.1。

*例子*

julia> sprandn(2, 2, 0.75)
2×2 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 -1.20577     ⋅
  0.311817  -0.234641

# *`麻雀。非泽洛斯`*-函数

nonzeros(A)

返回稀疏数组中结构非零值的向量 A. 这包括显式存储在稀疏数组中的零。返回的向量直接指向内部非零存储 A，并且对返回的向量的任何修改都会发生变异 A ""好吧。见 行距和 nzrange.

*例子*

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 2  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  2

julia> nonzeros(A)
3-element Vector{Int64}:
 2
 2
 2

# *`麻雀。行距`*-函数

rowvals(A)

返回稀疏数组的行索引的向量 A. 对返回向量的任何修改都将发生变异 A ""好吧。提供对行索引在内部存储方式的访问对于迭代结构非零值非常有用。请参阅 非泽洛斯和 nzrange.

*例子*

julia> A = sparse(2I, 3, 3)
3×3 SparseMatrixCSC{Int64, Int64} with 3 stored entries:
 2  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  2

julia> rowvals(A)
3-element Vector{Int64}:
 1
 2
 3

# *`麻雀。nzrange`*-函数

nzrange(A, col::Integer)

将索引的范围返回到列的结构非零值 上校 稀疏数组 A. 与 非泽洛斯和 行距，这允许方便地迭代稀疏矩阵 :

A = sparse(I,J,V)
rows = rowvals(A)
vals = nonzeros(A)
m, n = size(A)
for j = 1:n
   for i in nzrange(A, j)
      row = rows[i]
      val = vals[i]
      # perform sparse wizardry...
   end
end

警告向矩阵添加或删除非零元素可能会使 nzrange，人们不应该在迭代时改变矩阵。

nzrange(x::SparseVectorUnion, col)

给出稀疏向量的结构非零值的索引范围。列索引 上校 被忽略（假定为 1).

# *`麻雀。滴滴！`*-函数

droptol!(A::AbstractSparseMatrixCSC, tol)

从 A 其绝对值小于或等于 托尔.

droptol!(x::AbstractCompressedVector, tol)

从 x 其绝对值小于或等于 托尔.

# *`麻雀。dropzeros！`*-函数

dropzeros!(x::AbstractCompressedVector)

删除存储的数字零 x.

有关不合适的版本，请参阅 滴管,滴管. 有关算法信息，请参阅 fkeep！.

# *`麻雀。滴管,滴管`*-函数

dropzeros(A::AbstractSparseMatrixCSC;)

生成的副本 A 并从该副本中删除存储的数字零。

有关就地版本和算法信息，请参阅 dropzeros！.

*例子*

julia> A = sparse([1, 2, 3], [1, 2, 3], [1.0, 0.0, 1.0])
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 1.0   ⋅    ⋅
  ⋅   0.0   ⋅
  ⋅    ⋅   1.0

julia> dropzeros(A)
3×3 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 1.0   ⋅    ⋅
  ⋅    ⋅    ⋅
  ⋅    ⋅   1.0

dropzeros(x::AbstractCompressedVector)

生成的副本 x 并从该副本中删除数字零。

有关就地版本和算法信息，请参阅 dropzeros！.

*例子*

julia> A = sparsevec([1, 2, 3], [1.0, 0.0, 1.0])
3-element SparseVector{Float64, Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  0.0
  [3]  =  1.0

julia> dropzeros(A)
3-element SparseVector{Float64, Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0

# *`麻雀。排列,排列`*-函数

permute(A::AbstractSparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
        q::AbstractVector{<:Integer}) where {Tv,Ti}

双边许可 A，返回 帕克 (A[p,q]). 列-排列 q长度必须匹配 A的列计数(长度(q)==尺寸(A,2)). 行排列 p长度必须匹配 A行数(长度(p)==尺寸(A,1)).

有关专家驱动程序和其他信息，请参阅 胡说八道！.

*例子*

julia> A = spdiagm(0 => [1, 2, 3, 4], 1 => [5, 6, 7])
4×4 SparseMatrixCSC{Int64, Int64} with 7 stored entries:
 1  5  ⋅  ⋅
 ⋅  2  6  ⋅
 ⋅  ⋅  3  7
 ⋅  ⋅  ⋅  4

julia> permute(A, [4, 3, 2, 1], [1, 2, 3, 4])
4×4 SparseMatrixCSC{Int64, Int64} with 7 stored entries:
 ⋅  ⋅  ⋅  4
 ⋅  ⋅  3  7
 ⋅  2  6  ⋅
 1  5  ⋅  ⋅

julia> permute(A, [1, 2, 3, 4], [4, 3, 2, 1])
4×4 SparseMatrixCSC{Int64, Int64} with 7 stored entries:
 ⋅  ⋅  5  1
 ⋅  6  2  ⋅
 7  3  ⋅  ⋅
 4  ⋅  ⋅  ⋅

# *`基地。胡说八道！`*-Method

permute!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
         [C::AbstractSparseMatrixCSC{Tv,Ti}]) where {Tv,Ti}

双边许可 A，存储结果 帕克 (A[p,q])在 X. 存储中间结果 (AQ)^T (转置(A[:,q]))在可选参数中 C 如果存在的话。要求没有 X, A，并且，如果存在, C 互相别名；存储结果 帕克 回到 A，使用以下方法： X:

permute!(A::AbstractSparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
         q::AbstractVector{<:Integer}[, C::AbstractSparseMatrixCSC{Tv,Ti},
         [workcolptr::Vector{Ti}]]) where {Tv,Ti}

X尺寸必须与 A (尺寸(X,1)==尺寸(A,1) 和 尺寸(X,2)==尺寸(A,2)），以及 X 必须有足够的存储空间来容纳所有分配的条目 A (长度(行数(X))>=nnz(A) 和 长度(nonzeros(X))>=nnz(A)). 列排列 q长度必须匹配 A的列计数(长度(q)==尺寸(A,2)). 行排列 p长度必须匹配 A行数(长度(p)==尺寸(A,1)).

C尺寸必须与 转置(A) (尺寸(C,1)==尺寸(A,2) 和 大小(C,2)==大小(A,1)），以及 C 必须有足够的存储空间来容纳所有分配的条目 A (长度(行数(C))>=nnz(A) 和 长度(nonzeros(C))>=nnz(A)).

有关其他（算法）信息以及放弃参数检查的这些方法的版本，请参阅（未报告的）父方法 unchecked_noalias_permute！ 和 unchecked_aliasing_permute！.

请参阅 排列,排列.

# *`麻雀。半精子！`*-函数

halfperm!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{TvA,Ti},
          q::AbstractVector{<:Integer}, f::Function = identity) where {Tv,TvA,Ti}

列-排列和转置 A，同时申请 f 到每个条目 A，存储结果 (f(A)Q)^T (map(f,转置(A[:,q])))在 X.

元素类型 电视 的 X 必须匹配 f(::TvA)，在哪里 TvA 元素类型是 A. X尺寸必须与 转置(A) (尺寸(X,1)==尺寸(A,2) 和 尺寸(X,2)==尺寸(A,1)），以及 X 必须有足够的存储空间来容纳所有分配的条目 A (长度(行数(X))>=nnz(A) 和 长度(nonzeros(X))>=nnz(A)). 列排列 q长度必须匹配 A的列计数(长度(q)==尺寸(A,2)).

此方法是执行转置和置换操作的几种方法的父方法 [医麻雀`由于此方法不执行参数检查，因此更喜欢更安全的子方法（[c]转置[！], `permute[！]）直接使用。

此方法实现了 半精子 算法描述于F.Gustavson,"two fast algorithms for sparse matrices:multiplication and permuted transposition,"ACM TOMS4(3), 250-269 (1978). 该算法运行在 O(尺寸(a,1),尺寸(A,2),nnz(A)) 时间，不需要任何空间。

# *`麻雀。翻译！`*-函数

ftranspose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}, f::Function) where {Tv,Ti}

转置,转置 A 并将其存储在 X 在应用函数时 f 到非零元素。不删除由 f. 尺寸(X) 必须等于 尺寸(转置(A)). 除了调整rowval和nzval的大小之外，不会分配其他内存 X，如果需要的话。

见 半精子！

值得注意的外部稀疏包

其他几个Julia包提供了应该提到的稀疏矩阵实现:

SuiteSparseGraphBLAS.jl是快速，多线程SuiteSparse：GraphBLAS c库的包装器。在CPU上，这通常是最快的选择，通常显着优于MKLSparse。
CUDA.jl暴露https://docs.nvidia.com/cuda/cusparse/index.html[CUSPARSE]gpu稀疏矩阵运算库。
SparseMatricesCSR.jl提供压缩稀疏行(CSR)格式的Julia本机实现。
MKLSparse.jl使用英特尔的MKL库加速SparseArrays稀疏密集矩阵操作。
SparseArrayKit.jl可用于多维稀疏数组。
LuxurySparse.jl提供静态稀疏数组格式，以及坐标格式。
ExtendableSparse.jl使用对新存储索引的惰性方法，可以快速插入稀疏矩阵。
Finch.jl通过一个迷你张量语言和编译器支持广泛的多维稀疏数组格式和操作，所有这些都在本地Julia中。支持COO、CSF、CSR、CSC等,以及广播、减少等操作. 和自定义操作。

提供稀疏直接求解器的外部包:

为本征系统和奇异值分解的迭代求解提供求解器的外部包:

用于处理图形的外部包:

图表.jl