Package evaluation to load StandardPacked on Julia 1.14.0-DEV.2226 (797a5ef2b0*) started at 2026-05-23T19:23:55.131 ################################################################################ # Set-up # Set-up completed after 0.13s ################################################################################ # Installation # Installing StandardPacked... Resolving package versions... Installed StandardPacked ─ v1.1.0 Updating `~/.julia/environments/v1.14/Project.toml` [65f29c17] + StandardPacked v1.1.0 Updating `~/.julia/environments/v1.14/Manifest.toml` [65f29c17] + StandardPacked v1.1.0 [56f22d72] + Artifacts v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.13.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.13.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.1+0 [4536629a] + OpenBLAS_jll v0.3.33+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Installation completed after 5.83s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Project No packages added to or removed from `~/.julia/environments/pkgeval/Project.toml` Manifest No packages added to or removed from `~/.julia/environments/pkgeval/Manifest.toml` Precompiling package dependencies... Precompiling project... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 =# Core.@doc " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" struct SPMatrix{R, V <: AbstractVector{R}, Fmt} <: AbstractMatrix{R} │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:22 =# │ dim::Int │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:23 =# │ data::V │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =# @doc " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" function SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol = :U) where R │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:30 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:31 =# │ chkpacked(dim, data) │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:32 =# │ type ∈ (:U, :L, :US, :LS) || error("Type must be one of :U, :L, :US, or :LS") │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:33 =# │ return new{R, typeof(data), type}(dim, data) │ end │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =# @doc " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" function SPMatrix{R}(::UndefInitializer, dim::Integer, type::Symbol = :U) where R │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:41 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:42 =# │ type ∈ (:U, :L, :US, :LS) || error("Type must be one of :U, :L, :US, or :LS") │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:43 =# │ return new{R, Vector{R}, type}(dim, Vector{R}(undef, packedsize(dim))) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 =#) :: Value │ │ " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" :: Value │ │ [struct] │ │ false :: Value │ │ [<:] │ │ [curly] │ │ SPMatrix :: Identifier │ │ R :: Identifier │ │ [<:] │ │ V :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ R :: Identifier │ │ Fmt :: Identifier │ │ [curly] │ │ AbstractMatrix :: Identifier │ │ R :: Identifier │ │ [block] │ │ [::] │ │ dim :: Identifier │ │ Int :: Identifier │ │ [::] │ │ data :: Identifier │ │ V :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =#) :: Value │ │ " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ SPMatrix :: Identifier │ │ [::] │ │ dim :: Identifier │ │ Integer :: Identifier │ │ [::] │ │ data :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ R :: Identifier │ │ [kw] │ │ [::] │ │ type :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ │ [block] │ │ [call] │ │ chkpacked :: Identifier │ │ dim :: Identifier │ │ data :: Identifier │ │ [||] │ │ [call] │ │ ∈ :: Identifier │ │ type :: Identifier │ │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ │ "Type must be one of :U, :L, :US, or :LS" :: Value │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ R :: Identifier │ │ [call] │ │ typeof :: Identifier │ │ data :: Identifier │ │ type :: Identifier │ │ dim :: Identifier │ │ data :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =#) :: Value │ │ " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ [curly] │ │ SPMatrix :: Identifier │ │ R :: Identifier │ │ [::] │ │ UndefInitializer :: Identifier │ │ [::] │ │ dim :: Identifier │ │ Integer :: Identifier │ │ [kw] │ │ [::] │ │ type :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ │ [block] │ │ [||] │ │ [call] │ │ ∈ :: Identifier │ │ type :: Identifier │ │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ │ "Type must be one of :U, :L, :US, or :LS" :: Value │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ R :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ R :: Identifier │ │ type :: Identifier │ │ dim :: Identifier │ │ [call] │ │ [curly] │ │ Vector :: Identifier │ │ R :: Identifier │ │ undef :: Identifier │ │ [call] │ │ packedsize :: Identifier │ │ dim :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [struct] │ │ false :: Value │ macro_source=138 │ [<:] │ scope_layer=1 │ [curly] │ │ SPMatrix :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ V :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Fmt :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractMatrix :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ dim :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [::] │ │ data :: Identifier │ scope_layer=1 │ V :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #1#val :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ SPMatrix :: Identifier │ scope_layer=1 │ [::] │ │ dim :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [::] │ │ data :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ type :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ chkpacked :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ data :: Identifier │ scope_layer=1 │ [||] │ │ [call] │ │ ∈ :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ scope_layer=1 │ "Type must be one of :U, :L, :US, or :LS" :: Value │ macro_source=138 │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [call] │ │ typeof :: Identifier │ scope_layer=1 │ data :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ data :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [inert] │ │ SPMatrix :: Identifier │ │ [call] │ macro_source=138 │ Base.Docs.docstr :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Core.svec :: Value │ macro_source=138 │ " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Dict{Symbol, Any} :: Value │ macro_source=138 │ :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :: Value │ macro_source=138 │ :linenumber => 25 :: Value │ macro_source=138 │ :module => StandardPacked :: Value │ macro_source=138 │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ #1#val :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #2#val :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ [curly] │ │ SPMatrix :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [::] │ │ UndefInitializer :: Identifier │ scope_layer=1 │ [::] │ │ dim :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ type :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ scope_layer=1 │ [block] │ │ [||] │ │ [call] │ │ ∈ :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ scope_layer=1 │ "Type must be one of :U, :L, :US, or :LS" :: Value │ macro_source=138 │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ undef :: Identifier │ scope_layer=1 │ [call] │ │ packedsize :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [inert] │ │ SPMatrix :: Identifier │ │ [call] │ macro_source=138 │ Base.Docs.docstr :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Core.svec :: Value │ macro_source=138 │ " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Dict{Symbol, Any} :: Value │ macro_source=138 │ :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :: Value │ macro_source=138 │ :linenumber => 36 :: Value │ macro_source=138 │ :module => StandardPacked :: Value │ macro_source=138 │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ UndefInitializer :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ UndefInitializer :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ #2#val :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=138 │ StandardPacked :: Value │ │ [inert] │ jl_source=L65 │ SPMatrix :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Core.svec :: Value │ macro_source=138 │ " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" :: Value │ macro_source=138 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=138 │ :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :: Value │ macro_source=138 │ :linenumber => 4 :: Value │ macro_source=138 │ :module => StandardPacked :: Value │ macro_source=138 │ [call] │ │ Pair :: Value │ macro_source=138 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=138 │ Dict{Symbol, Any} :: Value │ macro_source=138 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" │ line = 4 └ mod = StandardPacked ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =# - assignment syntax in structure fields is reserved Expression:  (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) :U)) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data))))) Containing expressions:  (struct false (<: (curly SPMatrix R (<: V (curly AbstractVector R)) Fmt) (curly AbstractMatrix R)) (block (:: dim Int) (:: data V) (block (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) :U)) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data))))) (call Base.Docs.doc! StandardPacked (call Base.Docs.Binding StandardPacked :SPMatrix) (call Base.Docs.docstr (call Core.svec " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :linenumber => 25 :module => StandardPacked)) (where (curly Union (curly Tuple Integer (curly AbstractVector R)) (curly Tuple Integer (curly AbstractVector R) Symbol) (curly Tuple R)) (<: R Any))) #1#val) (block (= #2#val (function (where (call (curly SPMatrix R) (:: UndefInitializer) (:: dim Integer) (kw (:: type Symbol) :U)) R) (block (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (curly Vector R) type) dim (call (curly Vector R) undef (call packedsize dim))))))) (call Base.Docs.doc! StandardPacked (call Base.Docs.Binding StandardPacked :SPMatrix) (call Base.Docs.docstr (call Core.svec " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :linenumber => 36 :module => StandardPacked)) (where (curly Union (curly Tuple UndefInitializer Integer) (curly Tuple UndefInitializer Integer Symbol) (curly Tuple R)) (<: R Any))) #2#val)))  Detailed provenance:  (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) :U)) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data)))))  └─ (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) (inert U))) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data)))))  └─ (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) (inert U))) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data)))))  ├─ @ /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 =#) " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" (struct false (<: (curly SPMatrix R (<: V (curly AbstractVector R)) Fmt) (curly AbstractMatrix R)) (block (:: dim Int) (:: data V) (macrocall @doc :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =#) " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) (inert U))) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =#) " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" (function (where (call (curly SPMatrix R) (:: UndefInitializer) (:: dim Integer) (kw (:: type Symbol) (inert U))) R) (block (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (curly Vector R) type) dim (call (curly Vector R) undef (call packedsize dim))))))))))  └─ @ /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4  Stacktrace:  [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3184  [2] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3181  [3] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3754  [4] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4336  [5] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152  [6] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, is_const::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1318  [7] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1268  [8] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4196  [9] expand_forms_2  @ /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]  [10] #expand_forms_2##2  @ /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4440 [inlined]  [11] mapchildren(f::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}}, ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:707  [12] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4440  [13] Dict{Int64, Int64}()  @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]  [14] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469  [15] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [16] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [17] top-level scope  @ ~/.julia/packages/StandardPacked/1iEvn/src/StandardPacked.jl:16  [18] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [19] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base ./loading.jl:3271  [20] top-level scope  @ stdin:5  [21] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [23] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [24] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [25] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 in expression starting at /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/StandardPacked.jl:2 in expression starting at stdin:5 ✗ StandardPacked Precompilation completed after 61.97s ################################################################################ # Loading # Loading StandardPacked... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 =# Core.@doc " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" struct SPMatrix{R, V <: AbstractVector{R}, Fmt} <: AbstractMatrix{R} │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:22 =# │ dim::Int │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:23 =# │ data::V │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =# @doc " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" function SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol = :U) where R │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:30 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:31 =# │ chkpacked(dim, data) │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:32 =# │ type ∈ (:U, :L, :US, :LS) || error("Type must be one of :U, :L, :US, or :LS") │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:33 =# │ return new{R, typeof(data), type}(dim, data) │ end │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =# @doc " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" function SPMatrix{R}(::UndefInitializer, dim::Integer, type::Symbol = :U) where R │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:41 =# │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:42 =# │ type ∈ (:U, :L, :US, :LS) || error("Type must be one of :U, :L, :US, or :LS") │ #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:43 =# │ return new{R, Vector{R}, type}(dim, Vector{R}(undef, packedsize(dim))) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 =#) :: Value │ │ " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" :: Value │ │ [struct] │ │ false :: Value │ │ [<:] │ │ [curly] │ │ SPMatrix :: Identifier │ │ R :: Identifier │ │ [<:] │ │ V :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ R :: Identifier │ │ Fmt :: Identifier │ │ [curly] │ │ AbstractMatrix :: Identifier │ │ R :: Identifier │ │ [block] │ │ [::] │ │ dim :: Identifier │ │ Int :: Identifier │ │ [::] │ │ data :: Identifier │ │ V :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =#) :: Value │ │ " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ SPMatrix :: Identifier │ │ [::] │ │ dim :: Identifier │ │ Integer :: Identifier │ │ [::] │ │ data :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ R :: Identifier │ │ [kw] │ │ [::] │ │ type :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ │ [block] │ │ [call] │ │ chkpacked :: Identifier │ │ dim :: Identifier │ │ data :: Identifier │ │ [||] │ │ [call] │ │ ∈ :: Identifier │ │ type :: Identifier │ │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ │ "Type must be one of :U, :L, :US, or :LS" :: Value │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ R :: Identifier │ │ [call] │ │ typeof :: Identifier │ │ data :: Identifier │ │ type :: Identifier │ │ dim :: Identifier │ │ data :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =#) :: Value │ │ " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ [curly] │ │ SPMatrix :: Identifier │ │ R :: Identifier │ │ [::] │ │ UndefInitializer :: Identifier │ │ [::] │ │ dim :: Identifier │ │ Integer :: Identifier │ │ [kw] │ │ [::] │ │ type :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ │ [block] │ │ [||] │ │ [call] │ │ ∈ :: Identifier │ │ type :: Identifier │ │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ │ "Type must be one of :U, :L, :US, or :LS" :: Value │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ R :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ R :: Identifier │ │ type :: Identifier │ │ dim :: Identifier │ │ [call] │ │ [curly] │ │ Vector :: Identifier │ │ R :: Identifier │ │ undef :: Identifier │ │ [call] │ │ packedsize :: Identifier │ │ dim :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [struct] │ │ false :: Value │ macro_source=138 │ [<:] │ scope_layer=1 │ [curly] │ │ SPMatrix :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ V :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Fmt :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractMatrix :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ dim :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [::] │ │ data :: Identifier │ scope_layer=1 │ V :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #1#val :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ SPMatrix :: Identifier │ scope_layer=1 │ [::] │ │ dim :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [::] │ │ data :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ type :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ chkpacked :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ data :: Identifier │ scope_layer=1 │ [||] │ │ [call] │ │ ∈ :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ scope_layer=1 │ "Type must be one of :U, :L, :US, or :LS" :: Value │ macro_source=138 │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [call] │ │ typeof :: Identifier │ scope_layer=1 │ data :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ data :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [inert] │ │ SPMatrix :: Identifier │ │ [call] │ macro_source=138 │ Base.Docs.docstr :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Core.svec :: Value │ macro_source=138 │ " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Dict{Symbol, Any} :: Value │ macro_source=138 │ :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :: Value │ macro_source=138 │ :linenumber => 25 :: Value │ macro_source=138 │ :module => StandardPacked :: Value │ macro_source=138 │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ #1#val :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #2#val :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ [curly] │ │ SPMatrix :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [::] │ │ UndefInitializer :: Identifier │ scope_layer=1 │ [::] │ │ dim :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ type :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ U :: Identifier │ │ R :: Identifier │ scope_layer=1 │ [block] │ │ [||] │ │ [call] │ │ ∈ :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ [tuple] │ │ [inert] │ │ U :: Identifier │ │ [inert] │ │ L :: Identifier │ │ [inert] │ │ US :: Identifier │ │ [inert] │ │ LS :: Identifier │ │ [call] │ │ error :: Identifier │ scope_layer=1 │ "Type must be one of :U, :L, :US, or :LS" :: Value │ macro_source=138 │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ type :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ undef :: Identifier │ scope_layer=1 │ [call] │ │ packedsize :: Identifier │ scope_layer=1 │ dim :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [inert] │ │ SPMatrix :: Identifier │ │ [call] │ macro_source=138 │ Base.Docs.docstr :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Core.svec :: Value │ macro_source=138 │ " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Dict{Symbol, Any} :: Value │ macro_source=138 │ :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :: Value │ macro_source=138 │ :linenumber => 36 :: Value │ macro_source=138 │ :module => StandardPacked :: Value │ macro_source=138 │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ UndefInitializer :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ UndefInitializer :: Identifier │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ R :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ #2#val :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=138 │ StandardPacked :: Value │ macro_source=138 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=138 │ StandardPacked :: Value │ │ [inert] │ jl_source=L65 │ SPMatrix :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=138 │ [call] │ macro_source=138 │ Core.svec :: Value │ macro_source=138 │ " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" :: Value │ macro_source=138 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=138 │ :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :: Value │ macro_source=138 │ :linenumber => 4 :: Value │ macro_source=138 │ :module => StandardPacked :: Value │ macro_source=138 │ [call] │ │ Pair :: Value │ macro_source=138 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=138 │ Dict{Symbol, Any} :: Value │ macro_source=138 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" │ line = 4 └ mod = StandardPacked ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =# - assignment syntax in structure fields is reserved Expression:  (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) :U)) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data))))) Containing expressions:  (struct false (<: (curly SPMatrix R (<: V (curly AbstractVector R)) Fmt) (curly AbstractMatrix R)) (block (:: dim Int) (:: data V) (block (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) :U)) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data))))) (call Base.Docs.doc! StandardPacked (call Base.Docs.Binding StandardPacked :SPMatrix) (call Base.Docs.docstr (call Core.svec " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :linenumber => 25 :module => StandardPacked)) (where (curly Union (curly Tuple Integer (curly AbstractVector R)) (curly Tuple Integer (curly AbstractVector R) Symbol) (curly Tuple R)) (<: R Any))) #1#val) (block (= #2#val (function (where (call (curly SPMatrix R) (:: UndefInitializer) (:: dim Integer) (kw (:: type Symbol) :U)) R) (block (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (curly Vector R) type) dim (call (curly Vector R) undef (call packedsize dim))))))) (call Base.Docs.doc! StandardPacked (call Base.Docs.Binding StandardPacked :SPMatrix) (call Base.Docs.docstr (call Core.svec " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl" :linenumber => 36 :module => StandardPacked)) (where (curly Union (curly Tuple UndefInitializer Integer) (curly Tuple UndefInitializer Integer Symbol) (curly Tuple R)) (<: R Any))) #2#val)))  Detailed provenance:  (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) :U)) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple :U :L :US :LS)) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data)))))  └─ (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) (inert U))) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data)))))  └─ (= #1#val (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) (inert U))) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data)))))  ├─ @ /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 =#) " SPMatrix{R,V,Fmt}\n\nTwo-dimensional dense Hermitian square matrix in packed storage. Depending on Fmt, we only store the upper or lower triangle\nin col-major vectorized or scaled vectorized form:\n- `:U`: `PM[i, j] = PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:L`: `PM[i, j] = PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\n- `:US`: `PM[i, j] = s(i, j) PM[i + (j -1) * j ÷ 2]` for `1 ≤ i ≤ j ≤ n`\n- `:LS`: `PM[i, j] = s(i, j) PM[i + (j -1) * (2n - j) ÷ 2]` for `1 ≤ j ≤ i ≤ n`\nwhere `n` is the side dimension of the packed matrix `PM`, `s(i, i) = 1`, and `s(i, j) = inv(sqrt(2))` for `i ≠ j`.\n\n!!! warning\n The SPMatrix can be effciently broadcast to other matrices, which works on the vector representation. It can also\n receive values from generic matrices by `copyto!` or broadcasting. Using it in a mixed chain of broadcastings of different\n type is not implemented and will potentially lead to logical errors (in the sense that the types will not match) or even\n segfaults (as the correct index mapping is not implemented).\n" (struct false (<: (curly SPMatrix R (<: V (curly AbstractVector R)) Fmt) (curly AbstractMatrix R)) (block (:: dim Int) (:: data V) (macrocall @doc :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:25 =#) " SPMatrix(dim::Integer, data::AbstractVector{R}, type::Symbol=:U)\n\nCreates a packed matrix from already existing vectorized data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" (function (where (call SPMatrix (:: dim Integer) (:: data (curly AbstractVector R)) (kw (:: type Symbol) (inert U))) R) (block (call chkpacked dim data) (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (call typeof data) type) dim data))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:36 =#) " SPMatrix{R}(undef, dim, type::Symbol=:U)\n\nCreates a packed matrix with undefined data. `type` must be one of `:U`, `:L`, `:US`, or `:LS`.\n" (function (where (call (curly SPMatrix R) (:: UndefInitializer) (:: dim Integer) (kw (:: type Symbol) (inert U))) R) (block (|| (call ∈ type (tuple (inert U) (inert L) (inert US) (inert LS))) (call error "Type must be one of :U, :L, :US, or :LS")) (return (call (curly new R (curly Vector R) type) dim (call (curly Vector R) undef (call packedsize dim))))))))))  └─ @ /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4  Stacktrace:  [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3184  [2] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3181  [3] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3754  [4] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4336  [5] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152  [6] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, is_const::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1318  [7] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1268  [8] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4196  [9] expand_forms_2  @ /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]  [10] #expand_forms_2##2  @ /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4440 [inlined]  [11] mapchildren(f::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}}, ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:707  [12] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4440  [13] Dict{Int64, Int64}()  @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]  [14] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469  [15] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [16] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [17] top-level scope  @ ~/.julia/packages/StandardPacked/1iEvn/src/StandardPacked.jl:16  [18] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [19] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base ./loading.jl:3271  [20] top-level scope  @ stdin:5  [21] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [23] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [24] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [25] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/spmatrix.jl:4 in expression starting at /home/pkgeval/.julia/packages/StandardPacked/1iEvn/src/StandardPacked.jl:2 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ StandardPacked │ [Output was shown above] └ ERROR: The following 1 package failed to precompile: StandardPacked Failed to precompile StandardPacked [65f29c17-9e56-4606-972f-81e04007695c] to "/home/pkgeval/.julia/compiled/v1.14/StandardPacked/jl_2c63hC" (ProcessExited(1)). Loading failed after 49.94s ERROR: LoadError: failed process: Process(`/opt/julia/bin/julia -C native -J/opt/julia/lib/julia/sys.so -g1 --check-bounds=yes --inline=yes --check-bounds=yes --pkgimages=existing -e 'using StandardPacked'`, ProcessExited(1)) [1] Stacktrace: [1] spawn_opts_inherit() @ Base ./process.jl:612 [inlined] [2] run(::Cmd; wait::Bool) @ Base ./process.jl:525 [3] run(::Cmd) @ Base ./process.jl:522 [4] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:197 [5] include(mod::Module, _path::String) @ Base ./Base.jl:326 [6] exec_options(opts::Base.JLOptions) @ Base ./client.jl:355 [7] _start() @ Base ./client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:188 PkgEval failed after 137.39s: package fails to precompile