C++ 阵列火稀疏矩阵问题

对简单的事情感到困惑。花了一点时间试着调试这个，我没有走得太远。如果有人能帮我，我将不胜感激

我试图在arrayfire中定义一个稀疏矩阵，方法是按照本文中指定的值/列/行三元组。我想将以下矩阵存储为稀疏矩阵：

3 3 4 
3 10 0 
4 0 3

我将其编码如下：

int row[] = {0,0,0,1,1,2,2};
int col[] = {0,1,2,0,1,0,2};
double values[] = { 3,3, 4,3,10,4,3};
array rr = sparse(3,3,array(7,values),array(7,row),array(7,col));
af_print(rr);
af_print(dense(rr));

我得到以下输出：

rr                                                                      
Storage Format : AF_STORAGE_CSR   
[3 3 1 1]
rr: Values
[7 1 1 1]
1.0000                                                              
2.0000                                                              
4.0000                                                              
3.0000
10.0000                                                              
4.0000                                                              
3.0000

rr: RowIdx                                                              
[7 1 1 1]                                                               
         0                                                              
         0                                                              
         0                                                              
         1                                                              
         1                                                              
         2                                                              
         2  

rr: ColIdx                                                              
[7 1 1 1]                                                               
         0                                                              
         1                                                              
         2                                                              
         0                                                              
         1                                                              
         0                                                              
         2  

dense(rr)                                                               
[3 3 1 1]                                                               
    0.0000     0.0000     0.0000                                        
    0.0000     0.0000     3.0000                                        
    3.0000     0.0000     0.0000 

当以密集格式打印存储的矩阵时，我得到了与预期完全不同的结果

如何使打印rr的密集版本的输出给出：

3 3 4 
3 10 0 
4 0 3

Arrayfire使用（修改的），因此

行

数组的长度必须为

行数+1

。通常，它将用每行的非零条目数填充，即

{0,3,2,2}

。但是对于Arrayfire，您需要获取累积和，即

{0,3,5,7}

。这对我来说很有用：

int row[] = {0,3,5,7};
int col[] = {0,1,2,0,1,0,2};
float values[] = {3,3,4,3,10,4,3};
array rr = sparse(3,3,array(7,values),array(4,row),array(7,col));
af_print(rr);
af_print(dense(rr)); 

然而，这并不是很方便，因为它与您的输入格式完全不同。或者，您可以指定：

产生：

rr
Storage Format : AF_STORAGE_COO
[3 3 1 1]
rr: Values
[7 1 1 1]
    3.0000 
    3.0000 
    4.0000 
    3.0000 
   10.0000 
    4.0000 
    3.0000 

rr: RowIdx
[7 1 1 1]
         0 
         0 
         0 
         1 
         1 
         2 
         2 

rr: ColIdx
[7 1 1 1]
         0 
         1 
         2 
         0 
         1 
         0 
         2 

dense(rr)
[3 3 1 1]
    3.0000     3.0000     4.0000 
    3.0000    10.0000     0.0000 
    4.0000     0.0000     3.0000 

---

另请参见。

谢谢。我应该留意一下格式。有没有一种简单的方法可以在不同类型之间进行转换？@stantheman您可以使用

af:：sparseConvertTo（）

直接在CSR和COO之间进行转换。

rr
Storage Format : AF_STORAGE_COO
[3 3 1 1]
rr: Values
[7 1 1 1]
    3.0000 
    3.0000 
    4.0000 
    3.0000 
   10.0000 
    4.0000 
    3.0000 

rr: RowIdx
[7 1 1 1]
         0 
         0 
         0 
         1 
         1 
         2 
         2 

rr: ColIdx
[7 1 1 1]
         0 
         1 
         2 
         0 
         1 
         0 
         2 

dense(rr)
[3 3 1 1]
    3.0000     3.0000     4.0000 
    3.0000    10.0000     0.0000 
    4.0000     0.0000     3.0000