如何在julia中使用数组元素作为迭代器

Question

我正在努力让我的Julia代码更容易理解(物理学家(，并认为如果我能使用某种向量类型的迭代器会很好。我尝试将每个元素用作迭代器。到目前为止，我的解决方案是：

kcut=2
𝐌 = Array{Float64}(undef,3)
Ø = [0, 0, 0]
for 𝐌[1] in -kcut:kcut, 𝐌[2] in -kcut:kcut, 𝐌[3] in -kcut:kcut
if norm(𝐌)^2 <= kcut^2 && 𝐌 != Ø
println(𝐌)
end
end
println(𝐌)

它几乎做到了它应该做的。唯一的问题是，一旦我完成for循环，我的M就被重新定义为它在循环中的最后一个配置，[2,2,2]在这种情况下。当我在下面的正常变量上迭代时，情况似乎并非如此

x=1
for x in 1:10
println(x)
end
println(x)

这告诉我在循环之后x仍然等于1。如果可能的话，我也希望有同样的行为。此外，在我使用M进行迭代之前，是否有任何方法可以在不定义它的情况下做到这一点？

编辑：我需要M作为数组输出，这样我就可以对它做一些线性代数。

Answer 1

您可以直接在M上迭代，例如：

julia> using LinearAlgebra: norm
julia> kcut=2;
julia> Ø = [0, 0, 0];
julia> for 𝐌 in Iterators.product(-kcut:kcut, -kcut:kcut, -kcut:kcut)
if norm(𝐌)^2 <= kcut^2 && 𝐌 != Ø
# 𝐌 is a Tuple now, which should be best in most cases.
#
# If you want arrays instead:
𝐍 = collect(𝐌)
println(𝐌, "t", 𝐍)
end
end
(0, 0, -2)      [0, 0, -2]
(-1, -1, -1)    [-1, -1, -1]
(0, -1, -1)     [0, -1, -1]
(1, -1, -1)     [1, -1, -1]
(-1, 0, -1)     [-1, 0, -1]
(0, 0, -1)      [0, 0, -1]
(1, 0, -1)      [1, 0, -1]
(-1, 1, -1)     [-1, 1, -1]
...
julia> println(𝐌)
ERROR: UndefVarError: 𝐌 not defined
Stacktrace:
[1] top-level scope at REPL[5]:1

这样，M仅在for循环的范围内定义。

要理解原始代码的行为，您必须对Julia内部执行的代码转换("代码降低"(有一个基本的了解。特别是，for循环按照迭代接口的规则进行替换

总而言之，一个片段如下：

M = [42]
for M[1] in -k:k
println(M[1])
end

行为方式与相同

M = [42]
next = iterate(-k:k)
while next !== nothing
M[1] = i
println(M[1])
next = iterate(iter, state)
end

在这里，你看到M必须预先存在，这样M[1]=i就不会失败，而且循环体内部发生的事情没有理由在它之后不持续。

Answer 2

您可以使用StaticArrays执行以下操作以获得"可以进行线性代数的元组"：

julia> using StaticArrays
julia> ⊗(u, v) = (i ⊗ j for i in u for j in v)
⊗ (generic function with 1 method)
julia> ⊗(x::Number, y::Number) = SVector(x, y)
⊗ (generic function with 2 methods)
julia> ⊗(x::SVector{N}, y::Number) where {N} = SVector(x..., y)
⊗ (generic function with 3 methods)
julia> collect((1:3) ⊗ (10:12) ⊗ (100:101))
18-element Array{SArray{Tuple{3},Int64,1,3},1}:
[1, 10, 100]
[1, 10, 101]
[1, 11, 100]
[1, 11, 101]
[1, 12, 100]
[1, 12, 101]
[2, 10, 100]
[2, 10, 101]
[2, 11, 100]
[2, 11, 101]
[2, 12, 100]
[2, 12, 101]
[3, 10, 100]
[3, 10, 101]
[3, 11, 100]
[3, 11, 101]
[3, 12, 100]
[3, 12, 101]
julia> using LinearAlgebra: norm
julia> for M in (1:3) ⊗ (10:12) ⊗ (100:101)
println(norm(M))
end
100.50373127401788
101.49876846543509
100.60815076324582
101.6021653312566
100.72239075796404
101.7152889196113
100.5186549850325
101.51354589413178
100.62305898749054
101.61692772368194
100.73728207570423
101.73003489628813
100.54352291420865
101.5381701627521
100.64790112068906
101.64152694642087
100.7620960480676
101.75460677532

但我不确定这是否值得。理想情况下，SVectors和Numbers的otimes将构建一个惰性数据结构，该结构在迭代时只创建适当大小的SVectors(而不是像这里那样飞溅(。我只是现在懒得写。

一个更好的变体(但数学语法稍微差一点(是重载⨂(spaces...)以同时完成所有任务：

julia> ⨂(spaces::NTuple{N}) where {N} = (SVector{N}(t) for t in Iterators.product(spaces...))
⨂ (generic function with 1 method)
julia> ⨂(spaces...) = ⨂(spaces)
⨂ (generic function with 2 methods)
julia> collect(⨂(1:3, 10:11))
3×2 Array{SArray{Tuple{2},Int64,1,2},2}:
[1, 10]  [1, 11]
[2, 10]  [2, 11]
[3, 10]  [3, 11]
julia> collect(⨂(1:3, 10:11, 100:101))
3×2×2 Array{SArray{Tuple{3},Int64,1,3},3}:
[:, :, 1] =
[1, 10, 100]  [1, 11, 100]
[2, 10, 100]  [2, 11, 100]
[3, 10, 100]  [3, 11, 100]
[:, :, 2] =
[1, 10, 101]  [1, 11, 101]
[2, 10, 101]  [2, 11, 101]
[3, 10, 101]  [3, 11, 101]

这收集到一个不同的形状，尽管我认为这更合适。