R矩阵包：稀疏矩阵dgCMatrix类中属性的含义_R_Pointers_Matrix_Sparse Matrix

R矩阵包：稀疏矩阵dgCMatrix类中属性的含义

r pointers matrix

R矩阵包：稀疏矩阵dgCMatrix类中属性的含义,r,pointers,matrix,sparse-matrix,R,Pointers,Matrix,Sparse Matrix,我已经看了包裹和它们的包装。我试图理解dgCMatrix类中的直觉和参数背后的含义。我明白 @i给出矩阵中非零项的基于零的行索引 @j给出矩阵中非零项的基于零的列索引 @x给出（i，j）位置处的非零元素但是我不明白指针@p的意思。警察说指针的数字（整数值）向量，每列（或行）一个指针，指向列（或行）中元素的初始（基于零的）索引这不是很有用。在“细节”部分，他们在同一页上解释了更多如果缺少i或j，则p必须是第一个元素为零的非递减整数向量。它提供行或列索引的压缩或“指针”表示，以缺少的为准

我已经看了包裹和它们的包装。我试图理解

dgCMatrix

类中的直觉和参数背后的含义。我明白

```
@i
```
给出矩阵中非零项的基于零的行索引
```
@j
```
给出矩阵中非零项的基于零的列索引
```
@x
```
给出
```
（i，j）
```
位置处的非零元素

但是我不明白指针

@p

的意思。警察说

指针的数字（整数值）向量，每列（或行）一个指针，指向列（或行）中元素的初始（基于零的）索引

这不是很有用。在“细节”部分，他们在同一页上解释了更多

如果缺少

或

，则

必须是第一个元素为零的非递减整数向量。它提供行或列索引的压缩或“指针”表示，以缺少的为准。

，

rep（seq_-along（dp），dp）

的扩展形式，其中

dp我终于明白了！我把答案贴出来，以备将来参考。
查看矩阵A

 [1,] . 60  . . .  . . .  .  . . . . . . . . . . .
 [2,] .  .  . . .  . . .  .  . . . . . . . . . . .
 [3,] .  .  . . .  . . . 20  . . . . . . . . . . .
 [4,] .  .  . . . 10 . .  .  . . . . . . . . . . .
 [5,] .  .  . . .  . . .  .  . . . . . . . . . . .
 [6,] .  . 40 . .  . . .  .  . . . . . . . . . . .
 [7,] .  .  . . .  . . .  .  . . . . . . . . . . .
 [8,] .  .  . . .  . . . 30  . . . . . . . . . . .
 [9,] .  .  . . .  . . .  . 50 . . . . . . . . . .
[10,] .  .  . . .  . . .  .  . . . . . . . . . . .

属性p

> A@p
 [1] 0 0 1 2 2 2 3 3 3 5 6 6 6 6 6 6 6 6 6 6 6

基本上统计每行中非零元素的数量。它是这样构造的

按照惯例，第一个元素总是0
（不确定原因），因此p=[0]
接下来，从矩阵的左上角开始（即[1，1]
），我们从最左边的列到最右边的列查看每一列，并将该列中非零元素的数量添加到“计数器”（现在设置为0
）中

列1
没有非零元素，因此我们将0
添加到计数器中<代码>p=[0,0]

列

有一个非零元素（

），因此我们将

添加到计数器

p=[0,0,0+1]=[0,0,1]

列

有一个非零元素（

），因此

p=[0,0,1,1+1]=[0,0,1,2]

列

没有非零元素，因此

p=[0,0,1,2,2+0]=[0,0,1,2,2]

列

没有非零元素，因此

p=[0,0,1,2,2,2]

列

有一个非零元素（

），因此

p=[0,0,1,2,2,3]

列

没有非零元素，因此

p=[0,0,1,2,2,2,3]

列

没有非零元素，因此

p=[0,0,1,2,2,2,3,3]

列

有两个非零元素（

和

），因此

p=[0,0,1,2,2,2,3,3,5]

列

有一个非零元素（

），因此

p=[0,0,1,2,2,2,3,3,5,6]

列

到

都有零元素，因此我们附加

[6,6,6,6,6,6]

因此，我们获得了所需的

。背后的直觉是，它是一个计数器，指示从左到右有多少个非零元素。

我终于明白了！我把答案贴出来，以备将来参考。查看矩阵

 [1,] . 60  . . .  . . .  .  . . . . . . . . . . .
 [2,] .  .  . . .  . . .  .  . . . . . . . . . . .
 [3,] .  .  . . .  . . . 20  . . . . . . . . . . .
 [4,] .  .  . . . 10 . .  .  . . . . . . . . . . .
 [5,] .  .  . . .  . . .  .  . . . . . . . . . . .
 [6,] .  . 40 . .  . . .  .  . . . . . . . . . . .
 [7,] .  .  . . .  . . .  .  . . . . . . . . . . .
 [8,] .  .  . . .  . . . 30  . . . . . . . . . . .
 [9,] .  .  . . .  . . .  . 50 . . . . . . . . . .
[10,] .  .  . . .  . . .  .  . . . . . . . . . . .

属性

> A@p
 [1] 0 0 1 2 2 2 3 3 3 5 6 6 6 6 6 6 6 6 6 6 6

基本上统计每行中非零元素的数量。它是这样构造的

按照惯例，第一个元素总是
```
0
```
（不确定原因），因此
```
p=[0]
```
接下来，从矩阵的左上角开始（即
```
[1，1]
```
），我们从最左边的列到最右边的列查看每一列，并将该列中非零元素的数量添加到“计数器”（现在设置为
```
0
```
）中
- 列
```
1
```
  没有非零元素，因此我们将
```
0
```
  添加到计数器中<代码>p=[0,0]
- 列
```
2
```
  有一个非零元素（
```
60
```
  ），因此我们将
```
1
```
  添加到计数器
```
p=[0,0,0+1]=[0,0,1]
```
- 列
```
3
```
  有一个非零元素（
```
40
```
  ），因此
```
p=[0,0,1,1+1]=[0,0,1,2]
```
- 列
```
4
```
  没有非零元素，因此
```
p=[0,0,1,2,2+0]=[0,0,1,2,2]
```
- 列
```
5
```
  没有非零元素，因此
```
p=[0,0,1,2,2,2]
```
- 列
```
6
```
  有一个非零元素（
```
10
```
  ），因此
```
p=[0,0,1,2,2,3]
```
- 列
```
7
```
  没有非零元素，因此
```
p=[0,0,1,2,2,2,3]
```
- 列
```
8
```
  没有非零元素，因此
```
p=[0,0,1,2,2,2,3,3]
```
- 列
```
9
```
  有两个非零元素（
```
20
```
  和
```
30
```
  ），因此
```
p=[0,0,1,2,2,2,3,3,5]
```
- 列
```
10
```
  有一个非零元素（
```
50
```
  ），因此
```
p=[0,0,1,2,2,2,3,3,5,6]
```
- 列
```
11
```
  到
```
20
```
  都有零元素，因此我们附加
```
[6,6,6,6,6,6]
```

因此，我们获得了所需的

。其背后的直觉是，它是一个计数器，指示从左到右有多少非零元素

> A@p
 [1] 0 0 1 2 2 2 3 3 3 5 6 6 6 6 6 6 6 6 6 6 6