问题[julia](coding)

Julia 有两种构造命名元组的语法。

第一个语法使用括号内的键值对，没有分号。

named_tuple = (a=1, b=2, c=3)

语法的第二种形式使用初始分号。

named_tuple = (; a=1, b=2, c=3)

据我从文档中了解，两种形式都会产生相同的结果。（一个NamedTuple对象。）

以下两种形式看上去并没有什么区别。

julia> tuple1 = (a=1, b=2, c=3)
(a = 1, b = 2, c = 3)

julia> typeof(tuple1)
@NamedTuple{a::Int64, b::Int64, c::Int64}

julia> tuple2 = (; a=1, b=2, c=3)
(a = 1, b = 2, c = 3)

julia> typeof(tuple2)
@NamedTuple{a::Int64, b::Int64, c::Int64}

似乎可以NamedTuple通过一系列对来创建，但只有包含分号时才可以。

换句话说，此语法有效并产生预期结果

julia> tuple3 = (; :a=>1, :b=>2, :c=>3)
(a = 1, b = 2, c = 3)

julia> typeof(tuple3)
@NamedTuple{a::Int64, b::Int64, c::Int64}

另一方面，以下情况并不

julia> tuple4 = (:a=>1, :b=>2, :c=>3)
(:a => 1, :b => 2, :c => 3)

julia> typeof(tuple4)
Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}}

这会产生一个Tuple，Pair而不是NamedTuple。

每种形式的预期用途是什么，或者有两种不同形式的原因是什么？

我有一个像这样的嵌套字典

function_dict_1 = Dict(
    :f => Dict(
        :func1 => x -> x^2
    )
)

我想调用一个强类型函数，它接收这个字典作为参数。

我的第一个想法是像这样输入：

dict_arg::Dict{Symbol, Dict{Symbol, <:Function}}

但是，我收到不匹配的函数调用错误。

我很困惑，因为它似乎可以与其他数据类型一起使用：

string_dict = Dict(
    :s => Dict(
        :string1 => "a"
    )
)
typeof(string_dict) <: Dict{Symbol, Dict{Symbol, String}}
>> true

以及非嵌套的字典：

function_dict_2 = Dict(
    :func1 => x -> x^2
)
typeof(function_dict_2) <: Dict{Symbol, <:Function}
>> true 

我尝试过以下类型：

• Dict{Symbol, Dict{Symbol, <:Function}}
• Dict{Symbol, Dict{Symbol, Function}}
• AbstractDict{Symbol, AbstractDict{Symbol, <:Function}}
• AbstractDict{Symbol, AbstractDict{Symbol, Function}}

但这一切都没有起作用。

该变量的正确输入方式是什么？

我有一个大型二进制文件，其中交错的 Int16 值表示每个样本的实部和虚部。设 S_i 表示样本编号 i，则数据排列如下

[Re(S_1)，Im(S_1)，Re(S_2)，Im(S_2)，...]

我的想法是定义一个自定义的 ComplexInt16 类型并对其进行操作。我编写了以下代码：

struct ComplexInt16
    re::Int16
    im::Int16
end

filehandle = open("y_baseband.dat")
dh = mmap(filehandle, Vector{ComplexInt16})

上面的代码按预期运行，但我无法使用为复数定义的函数（例如real(dh[1])返回错误。）有没有办法让我的ComplexInt16类型与 Julia 中现有的复杂函数一起工作？

我不完全理解Julia 中的quote ... end和:( ... )表达式之间有什么区别。

看起来唯一的区别好像是前者（quote）引入了额外的注释行。

• 差异就这么简单吗，或者还有更多其他的差异？
• 这些注释行的目的是什么？它们有什么作用？或者换句话说，为什么你会使用其中一个而不是另一个？

以下是一些例子

julia> :(2+2)
:(2 + 2)

julia> e1=:(2+2)
:(2 + 2)

julia> e1
:(2 + 2)

julia> eval(e1)
4

julia> quote
           2+2
       end
quote
    #= REPL[2]:2 =#
    2 + 2
end

julia> e2=quote
           2+2
       end
quote
    #= REPL[5]:2 =#
    2 + 2
end

julia> e2
quote
    #= REPL[5]:2 =#
    2 + 2
end

julia> eval(e2)
4

我找到了这本维基百科，但它只说

引用表达式的每一行都添加了有用的行号

（指与……quote相比:）。

关键字表达式的文档页面也没有说太多。

与其他引用方式 :( ... ) 不同，此形式将 QuoteNode 元素引入表达式树，直接操作树时必须考虑到这一点。

这意味着什么？

Julia 中是否有任何函数可以实现这一点？

f(x, n) = vcat(repeat(x, div(n, length(x))), x[1:rem(n, length(x))])

 f([1,3,2], 10)
10-element Vector{Int64}:
 1
 3
 2
 1
 3
 2
 1
 3
 2
 1

我想知道是否存在一个已知的函数可以做同样的事情。

a >= b && c <= b vs !( a < b || c > b)

julia 中哪个性能更高？

我正在尝试移动 Makie 图中的一些数据（我使用的是网格散射，但有一个更简单的示例）。

如果

fig = Figure()

Axis(fig[1,1],
xticks = 0:10:60,
xtickformat = x -> string.(x .+70),
yticks = 0:10:60,
ytickformat = x -> string.(x .+70),
limits = (0,60,0,60)
)
fig

我得到每个标签末尾带有“.0”的格式，但不想要它们。

从文档看来，它通过命令运行来自动添加“.0”。

我正在尝试对 Julia 中的矩阵执行高斯消除，然后以分数形式而不是小数形式提取解决方案。例如，我想要 3/4 而不是 0.75 作为解决方案。

我当前用于减少矩阵行并将解决方案表示为小数的代码如下：

using RowEchelon

A = [1 2 3;
     4 5 6;
     7 8 10]

A_reduced rref(A)

print(A_reduced)

有没有办法修改此代码以获得分数而不是浮点解？

我正在尝试构建并求解一个如下所示的矩阵系统：

\begin{equation}
    \begin{bmatrix}
        B & D & 0 & \cdots &        & 0       \\
        A & B & D & \ddots &        & \vdots  \\
        0 & A & B & D      & \ddots &         \\
        \vdots & \ddots &   & \ddots & \\
        \vdots & \cdots & \cdots & A & B & D \\
        0      & \cdots & \cdots & 0 & A & B
    \end{bmatrix}
    \
    \begin{bmatrix}
       \Delta c
    \end{bmatrix}
    \
    =
    \
    \begin{bmatrix}
       G
    \end{bmatrix}
\end{equation}

该系统来自用于求解方程组 (PDE) 的一维有限体积方法。

大矩阵 ( BBM) 由数组构造而成A, B, D。以下代码可以正常运行，但我有兴趣使该代码的计算效率更高。

我很好奇堆栈溢出社区是否有任何建议。特别是有没有一种方法可以消除for函数内的循环？

using BlockBandedMatrices

function calculate_BBM(; A, B, D)
    # initialize the Block Banded Matrix (BBM)
    int_array = map(Int, N*ones(NJ));
    BBM = BlockBandedMatrix(Zeros{Float64}(N*NJ, N*NJ), int_array, int_array, (1,1))

    # Precompute indices to avoid calculating them in each iteration
    ind_begin = [(1 + N * (j - 1)) for j in 1:NJ]
    ind_end = [N * j for j in 1:NJ]

    for j in 2:NJ - 1
        # Use precomputed indices
        ib = ind_begin[j]
        ie = ind_end[j]

        BBM[ib:ie, (ib - N):(ie - N)] .= A[:, :, j - 1]
        BBM[ib:ie, ib:ie] .= B[:, :, j]
        BBM[ib:ie, (ib + N):(ie + N)] .= D[:, :, j]
    end

    j = 1
    ib = ind_begin[j]
    ie = ind_end[j]

    BBM[ib:ie, ib:ie] .= B[:, :, j]
    BBM[ib:ie, (ib + N):(ie + N)] .= D[:, :, j]


    j = NJ
    ib = ind_begin[j]
    ie = ind_end[j]

    BBM[ib:ie, (ib - N):(ie - N)] .= A[:, :, j - 1]
    BBM[ib:ie, ib:ie] .= B[:, :, j]

    return BBM

end

N = 3
NJ = 102

A = randn(N, N, NJ-1)
B = randn(N, N, NJ)
D = randn(N, N, NJ-1)

# A = -ones(N, N, NJ-1)
# B = ones(N, N, NJ) * 2
# D = ones(N, N, NJ-1)

BBM = calculate_BBM(A=A, B=B, D=D);

在 Python 中，可以使用以下命令设置标志的选择argparse：

parser.add_argument('-q', 
                    dest='quality_scale', 
                    type=str, 
                    choices=["sanger", "illumina"],
                    help='Base quality scale',
                    required=True)

有没有办法在 Julia 中使用 来做到这一点ArgParse？我检查了这里的文档（常规设置），但我找不到任何东西。