CSC矩阵-按列排序-个人理解(有实例解释)

CSC（Compressed Sparse Column）矩阵是一种用于存储稀疏矩阵的压缩格式。稀疏矩阵是指大多数元素为零的矩阵，而CSC格式则通过压缩这种矩阵来节省内存和加快运算速度。具体来说，CSC矩阵存储方法包含以下三个主要数组：

values-数据数组：存储矩阵中的非零元素的数组，在CSC矩阵中是以列的顺序存储的；

row_indices-行索引数组：存储矩阵中的非零元素的行索引，它的长度等于矩阵中非零元素的数量；

col_pointers-列指针数组：存储每列的开始位置的数组。长度为列数加1，其中第i个元素表示第i列开始的位置，第i+1个元素表示第i+1列开始的位置。

接下来我通过矩阵来解释以上的数组：

[0, 1, 0, 0]
[0, 0, 0, 0]
[2, 0, 3, 0]
[0, 0, 0, 4]

这个矩阵的三个主要数组为：

values = [2, 1, 3, 4]

row_indices = [2, 0, 2, 3]

col_pointers = [0, 1, 2, 3, 4]

values数组很好理解，这个矩阵中一共有4个非零元素，所以它的长度是4。

更具列的顺序进行排列就是从元素2->1->3->4，所以values = [2, 1, 3, 4]

row_indices数组是每个非零元素的行索引，根据列顺序进行排列，也就是根据values数组进行排列，它与values数组是一一对应的：

values中的第0个元素2是在矩阵的第2行 所以row_indices[0] = 2

values中的第1个元素1是在矩阵的第0行 所以row_indices[1] = 0

values中的第2个元素3是在矩阵的第2行 所以row_indices[2] = 2

values中的第3个元素4是在矩阵的第3行 所以row_indices[3] = 3

所以row_indices = [2, 0, 2, 3]

col_pointers数组比较麻烦，它的第一个元素一定是0，最后一个元素是这个矩阵中的所以非零元素的数量。

我的理解是：当你想要知道第i列有多少元素时，你可以通过col_pointers[i+1]-col_pointers[i]所获取的值来确定，

如果值<0，说明这一列没有非零元素；

如果值>0，说明这一列有与这个值大小相同的非零元素。

以上述的矩阵为例子：

以下把col_pointers简写为col_p

clo_p[1] - col_p[0] == 1 - 0 == 1，说明第0列中有1个非零元素；

clo_p[2] - col_p[1] == 2 - 1 == 1，说明第1列中有1个非零元素；

col_p[3] - col_p[2] == 3 - 2 == 1，说明第2列中有1个非零元素；

col_p[4] - col_p[3] == 4 - 3 == 1，说明第3列中有1个非零元素；

一般的创建一个CSC矩阵就可以通过给定以上三个数列来指定想要的CSC矩阵

import numpy as np
from scipy.sparse import csc_matrix

data = np.array([2, 1, 3, 4]) # 数据数组
indices = np.array([2, 0, 2, 3]) # 行索引数组
indptr = np.array([0, 1, 2, 3, 4]) # 列指针数组
# 通过indptr[i+1]-indptr[i]确认i列的元素数量
mtx = scipy.sparse.csc_matrix((data, indices, indptr), shape=(4, 4))
mtx.todense()

这个代码运行结果如下：

[0, 1, 0, 0]
[0, 0, 0, 0]
[2, 0, 3, 0]
[0, 0, 0, 4]

 我们可以通过修改这些数组来得出不同的结果，接下来我修改列指针数组col_pointers

如果我想把元素2从第0列变到第1列，我可以修改indptr变成[0, 0, 2, 3, 4]

import numpy as np
from scipy.sparse import csc_matrix

data = np.array([2, 1, 3, 4]) # 数据数组
indices = np.array([2, 0, 2, 3]) # 行索引数组
indptr = np.array([0, 0, 2, 3, 4]) # 列指针数组
# 通过indptr[i+1]-indptr[i]确认i列的元素数量
mtx = scipy.sparse.csc_matrix((data, indices, indptr), shape=(4, 4))
mtx.todense()

这样的话indptr[2] - indptr[1] == 2 - 0 == 2，理论上第1列就会有两个元素，运行一下看下结果。

[0, 1, 0, 0]
[0, 0, 0, 0]
[0, 2, 3, 0]
[0, 0, 0, 4]

 结果是正确的，前面提到过如果col_pointers[i+1]-col_pointers[i]的值是0，那么这列将会没有非零元素。如果值小于0呢？那么，我把indptr[3]修改为1会是怎样的结果呢?

import numpy as np
from scipy.sparse import csc_matrix

data = np.array([2, 1, 3, 4]) # 数据数组
indices = np.array([2, 0, 2, 3]) # 行索引数组
indptr = np.array([0, 0, 2, 1, 4]) # 列指针数组
# 通过indptr[i+1]-indptr[i]确认i列的元素数量
mtx = scipy.sparse.csc_matrix((data, indices, indptr), shape=(4, 4))
mtx.todense()

 理论上说indptr[3] - indptr[2] == 1 - 2 == -1，第2列将会没有非零元素，而

indptr[4] - indptr[3] == 4 - 1 == 3，第3列将会有3个非零元素，但是第0和1列已经有了2个元素，data数组里只剩下了2个元素。不足以支付这个第3列的3个非零元素，让我们看下结果：

[0, 1, 0, 1]
[0, 0, 0, 0]
[0, 2, 0, 3]
[0, 0, 0, 4]

可以看到第2列没有了非零元素，而第3列有3个非零元素，多出了一个1。

不合理之间存在着一点合理性，首先data数组里有1，而这个第3列的1又正好是在第0行，可以与行索引数组相对应。

我认为这虽然是个错误，但是很有趣。

它首先符合了数据数组和行索引数组，可是没有符合列指针数组的最后一项。