Julia 逻辑索引的稀疏矩阵分配中的错误结果

在Matlab/Octave中，我可以使用逻辑索引为矩阵a中满足特定要求的每个位置的矩阵B赋值

octave:1> A = [.1;.2;.3;.4;.11;.13;.14;.01;.04;.09];
octave:2> C = A < .12
C =

   1
   0
   0
   0
   1
   0
   0
   1
   1
   1

octave:3> B = spalloc(10,1);
octave:4> B(C) = 1
B =

Compressed Column Sparse (rows = 10, cols = 1, nnz = 5 [50%])

  (1, 1) ->  1
  (5, 1) ->  1
  (8, 1) ->  1
  (9, 1) ->  1
  (10, 1) ->  1

octave:1>A=[.1；.2；.3；.4；.11；.13；.14；.01；.04；.09]；
倍频程：2>C=A<.12
C=
1.
0
0
0
1.
0
0
1.
1.
1.
倍频程：3>B=spalloc（10,1）；
倍频程：4>B（C）=1
B=
压缩列稀疏（行=10，列=1，nnz=5[50%]）
(1, 1) ->  1
(5, 1) ->  1
(8, 1) ->  1
(9, 1) ->  1
(10, 1) ->  1

但是，如果我尝试在Julia中使用基本相同的代码，则结果不正确：

julia> A = [.1;.2;.3;.4;.11;.13;.14;.01;.04;.09];

julia> B = spzeros(10,1)
10x1 sparse matrix with 0 Float64 entries:

julia> C = A .< .12
10-element BitArray{1}:
  true
 false
 false
 false
  true
 false
 false
  true
  true
  true

julia> B[C] = 1
1

julia> B
10x1 sparse matrix with 5 Float64 entries:
    [0 ,  1]  =  1.0
    [0 ,  1]  =  1.0
    [1 ,  1]  =  1.0
    [1 ,  1]  =  1.0
    [1 ,  1]  =  1.0

julia>A=[.1；.2；.3；.4；.11；.13；.14；.01；.04；.09]；
julia>B=spzeros（10,1）
10x1稀疏矩阵，具有0个浮点64个条目：
julia>C=A.<.12
10元素位数组{1}：
真的
假的
假的
假的
真的
假的
假的
真的
真的
真的
julia>B[C]=1
1.
朱莉娅>B
10x1稀疏矩阵，包含5个浮点64项：
[0 ,  1]  =  1.0
[0 ,  1]  =  1.0
[1 ,  1]  =  1.0
[1 ,  1]  =  1.0
[1 ,  1]  =  1.0

---

我是否在语法上犯了错误，是我误解了什么，还是这是一个错误？注意，如果我在Julia中使用完整矩阵，我会得到正确的结果，但是由于我的应用程序中的矩阵非常稀疏（有限元模拟中的基本边界条件），我更喜欢使用稀疏矩阵

看起来

稀疏

与

位数组

有一些问题

julia> VERSION
v"0.3.5"
julia> A = [.1;.2;.3;.4;.11;.13;.14;.01;.04;.09]
julia> B = spzeros(10,1)
julia> C = A .< .12
julia> B[C] = 1
julia> B
10x1 sparse matrix with 5 Float64 entries:
        [0 ,  1]  =  1.0
        [0 ,  1]  =  1.0
        [1 ,  1]  =  1.0
        [1 ,  1]  =  1.0
        [1 ,  1]  =  1.0

因此，如果您将

位数组

转换为

浮点

，则此操作有效。我想这一解决方法会让您继续，但似乎

sparse

应该与

BitArray

一起使用

一些其他想法（编辑）

当我进一步思考这个问题时，我突然想到，

sparse（）

没有

BitArray

方法的一个原因是，对于已经高度紧凑的类型，实现稀疏存储并不是非常有用。从上面考虑

B

和

C

：

julia> sizeof(C)
8

julia> sizeof(B)
40

因此，对于这些数据，

sparse

版本比原始版本大得多。乍一看，它实际上比这个简单（也许过于简单）的检查显示更糟糕

sizeof（：：BitArray{1}）

似乎是整个数组的大小，但

sizeof（：：sparsematricxcsc{}）

显示存储的每个元素的大小。因此，实际大小的差异大约是8字节与200字节

当然，如果数据足够稀疏（略小于1%

true

），稀疏存储就开始胜出，尽管它的开销很高

julia> C = rand(10^6) .< 0.01

julia> B = sparse(float(C))

julia> sizeof(C)
125000

julia> sum(C)*sizeof(B)
394520

julia> C = rand(10^6) .< 0.001

julia> B = sparse(float(C))

julia> sizeof(C)
125000

julia> sum(C)*sizeof(B)
40280

julia>C=rand（10^6）。<0.01
julia>B=sparse（float（C））
julia>sizeof（C）
125000
茱莉亚>总和（C）*sizeof（B）
394520
julia>C=rand（10^6）。<0.001
julia>B=sparse（float（C））
julia>sizeof（C）
125000
茱莉亚>总和（C）*sizeof（B）
40280

---

因此，

sparse（）

没有

BitArray

方法可能不是疏忽。在这种情况下，它可能会代表一个显着的空间节省可能不太常见，比人们可能认为乍一看

有趣的想法。在这里，我盲目地将Matlab代码转换成Julia代码。。。

julia> C = rand(10^6) .< 0.01

julia> B = sparse(float(C))

julia> sizeof(C)
125000

julia> sum(C)*sizeof(B)
394520

julia> C = rand(10^6) .< 0.001

julia> B = sparse(float(C))

julia> sizeof(C)
125000

julia> sum(C)*sizeof(B)
40280