Package evaluation to load Manopt on Julia 1.14.0-DEV.2226 (797a5ef2b0*) started at 2026-05-23T22:33:22.173 ################################################################################ # Set-up # Set-up completed after 0.13s ################################################################################ # Installation # Installing Manopt... Resolving package versions... Installed Reexport ───────────────── v1.2.2 Installed TensorCore ─────────────── v0.1.1 Installed ColorVectorSpace ───────── v0.11.0 Installed DataStructures ─────────── v0.19.4 Installed FixedPointNumbers ──────── v0.8.5 Installed Requires ───────────────── v1.3.1 Installed Glossaries ─────────────── v0.1.1 Installed Statistics ─────────────── v1.11.1 Installed Preferences ────────────── v1.5.2 Installed Colors ─────────────────── v0.13.1 Installed ManifoldsBase ──────────── v2.3.5 Installed ADTypes ────────────────── v1.22.0 Installed PrecompileTools ────────── v1.3.4 Installed Manopt ─────────────────── v0.5.38 Installed OrderedCollections ─────── v1.8.1 Installed ManifoldDiff ───────────── v0.4.5 Installed ColorTypes ─────────────── v0.12.1 Installed DifferentiationInterface ─ v0.7.18 Installed ColorSchemes ───────────── v3.31.0 Updating `~/.julia/environments/v1.14/Project.toml` [0fc0a36d] + Manopt v0.5.38 Updating `~/.julia/environments/v1.14/Manifest.toml` [47edcb42] + ADTypes v1.22.0 [35d6a980] + ColorSchemes v3.31.0 [3da002f7] + ColorTypes v0.12.1 [c3611d14] + ColorVectorSpace v0.11.0 [5ae59095] + Colors v0.13.1 [864edb3b] + DataStructures v0.19.4 [a0c0ee7d] + DifferentiationInterface v0.7.18 [53c48c17] + FixedPointNumbers v0.8.5 [8f48dd54] + Glossaries v0.1.1 [af67fdf4] + ManifoldDiff v0.4.5 [3362f125] + ManifoldsBase v2.3.5 [0fc0a36d] + Manopt v0.5.38 [bac558e1] + OrderedCollections v1.8.1 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [189a3867] + Reexport v1.2.2 [ae029012] + Requires v1.3.1 [10745b16] + Statistics v1.11.1 [62fd8b95] + TensorCore v0.1.1 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.13.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.13.0 [f489334b] + StyledStrings v1.13.0 [fa267f1f] + TOML v1.0.3 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.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 9.61s ################################################################################ # 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... 1.0 s ✓ Glossaries 1.4 s ✓ ADTypes 0.5 s ✓ Reexport 1.0 s ✓ Statistics 0.8 s ✓ TensorCore 148.3 s ✓ OrderedCollections 1.0 s ✓ Requires 190.3 s ✓ ManifoldsBase 2.3 s ✓ Preferences 1.9 s ✓ DifferentiationInterface 42.2 s ✓ FixedPointNumbers 39.3 s ✓ Statistics → SparseArraysExt 179.1 s ✓ DataStructures 39.0 s ✓ ManifoldsBase → ManifoldsBaseStatisticsExt 2.4 s ✓ PrecompileTools 37.7 s ✓ DifferentiationInterface → DifferentiationInterfaceSparseArraysExt 39.6 s ✓ ManifoldDiff 41.8 s ✓ ColorTypes 36.6 s ✓ ColorTypes → StyledStringsExt 85.3 s ✓ Colors 77.3 s ✓ ColorVectorSpace 111.1 s ✓ ColorSchemes ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 =# @doc " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``$(_tex(:abs, "g"))`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``$(_tex(:abs, "d"))`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = $(_tex(:abs, "g"))^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ $(_tex(:abs, "d"))^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``$(_tex(:abs, "g"))`` (``$(_tex(:abs, "d"))``), respectively.\n" mutable struct StopWhenLagrangeMultiplierLess{T <: Real, A <: AbstractVector{<:T}, B <: Union{Nothing, <:AbstractVector{<:String}}} <: StoppingCriterion │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:107 =# │ tolerances::A │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:108 =# │ values::A │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:109 =# │ names::B │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:110 =# │ mode::Symbol │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:111 =# │ at_iteration::Int │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:112 =# │ function StopWhenLagrangeMultiplierLess(tol::T; mode::Symbol = :estimate, names::B = nothing) where {T <: Real, B <: Union{Nothing, <:AbstractVector{<:String}}} │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:112 =# │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:115 =# │ return new{T, Vector{T}, B}([tol], zero([tol]), names, mode, -1) │ end │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117 =# │ function StopWhenLagrangeMultiplierLess(tols::A; mode::Symbol = :estimate, names::B = nothing) where {T <: Real, A <: AbstractVector{<:T}, B <: Union{Nothing, <:AbstractVector{<:String}}} │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117 =# │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:120 =# │ return new{T, A, B}(tols, zero(tols), names, mode, -1) │ 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 │ │ :(#= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 =#) :: Value │ │ [string] │ │ " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ │ "`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ │ "`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = " :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ │ "^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ " :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ │ "^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ │ "`` (``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ │ "``), respectively.\n" :: Value │ │ [struct] │ │ true :: Value │ │ [<:] │ │ [curly] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ A :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ T :: Identifier │ │ [<:] │ │ B :: Identifier │ │ [curly] │ │ Union :: Identifier │ │ Nothing :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ String :: Identifier │ │ StoppingCriterion :: Identifier │ │ [block] │ │ [::] │ │ tolerances :: Identifier │ │ A :: Identifier │ │ [::] │ │ values :: Identifier │ │ A :: Identifier │ │ [::] │ │ names :: Identifier │ │ B :: Identifier │ │ [::] │ │ mode :: Identifier │ │ Symbol :: Identifier │ │ [::] │ │ at_iteration :: Identifier │ │ Int :: Identifier │ │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ │ B :: Identifier │ │ nothing :: Identifier │ │ [::] │ │ tol :: Identifier │ │ T :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ B :: Identifier │ │ [curly] │ │ Union :: Identifier │ │ Nothing :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ String :: Identifier │ │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ T :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ T :: Identifier │ │ B :: Identifier │ │ [vect] │ │ tol :: Identifier │ │ [call] │ │ zero :: Identifier │ │ [vect] │ │ tol :: Identifier │ │ names :: Identifier │ │ mode :: Identifier │ │ -1 :: Value │ │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ │ B :: Identifier │ │ nothing :: Identifier │ │ [::] │ │ tols :: Identifier │ │ A :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ A :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ T :: Identifier │ │ [<:] │ │ B :: Identifier │ │ [curly] │ │ Union :: Identifier │ │ Nothing :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ String :: Identifier │ │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ T :: Identifier │ │ A :: Identifier │ │ B :: Identifier │ │ tols :: Identifier │ │ [call] │ │ zero :: Identifier │ │ tols :: Identifier │ │ names :: Identifier │ │ mode :: Identifier │ │ -1 :: Value │ │ │ 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] │ │ true :: Value │ macro_source=186 │ [<:] │ scope_layer=1 │ [curly] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ StoppingCriterion :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ tolerances :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [::] │ │ values :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [::] │ │ names :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [::] │ │ mode :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [::] │ │ at_iteration :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ scope_layer=1 │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [::] │ │ tol :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [vect] │ │ tol :: Identifier │ scope_layer=1 │ [call] │ │ zero :: Identifier │ scope_layer=1 │ [vect] │ │ tol :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ mode :: Identifier │ scope_layer=1 │ -1 :: Value │ macro_source=186 │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ scope_layer=1 │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [::] │ │ tols :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ tols :: Identifier │ scope_layer=1 │ [call] │ │ zero :: Identifier │ scope_layer=1 │ tols :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ mode :: Identifier │ scope_layer=1 │ -1 :: Value │ macro_source=186 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=186 │ Manopt :: Value │ macro_source=186 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=186 │ Manopt :: Value │ │ [inert] │ jl_source=L65 │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=186 │ [call] │ │ Core.svec :: Value │ macro_source=186 │ " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ macro_source=186 │ "`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ macro_source=186 │ "`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = " :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ macro_source=186 │ "^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ " :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ macro_source=186 │ "^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ macro_source=186 │ "`` (``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ macro_source=186 │ "``), respectively.\n" :: Value │ macro_source=186 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=186 │ :path => "/home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl" :: Value │ macro_source=186 │ :linenumber => 76 :: Value │ macro_source=186 │ :module => Manopt :: Value │ macro_source=186 │ [call] │ │ Pair :: Value │ macro_source=186 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=186 │ Dict{Symbol, Any} :: Value │ macro_source=186 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl" │ line = 76 └ mod = Manopt ERROR: LoadError: internal lowering bug: #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117 =# - `jl_assert(!(haskey(ssa_rewrites, lhs_id)), _)`: multiple assignments to ssavalue Expression:  (= #₅₉ (call core.TypeVar :#T1 #₃₀₈/T)) Containing expressions:  (= #₅₉ (call core.TypeVar :#T1 #₃₀₈/T))  Detailed provenance:  (= #₅₉ (call core.TypeVar :#T1 #₃₀₈/T)) @#= /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:366 =#  └─ (= #₅₉ (call core.TypeVar :#T1 #₁₁₉/T)) @#= /source/usr/share/julia/JuliaLowering/src/closure_conversion.jl:197 =#  └─ (= #₅₉ (call core.TypeVar :#T1 #₁₁₉/T)) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₅₉ (call core.TypeVar :#T1 T)) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₅₉ (call core.TypeVar :#T1 T))  └─ (call core.TypeVar :#T1 T) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3025 =#  └─ (<: T)  └─ (<: T)  └─ (<: T)  └─ (<: T)  ├─ @ /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 =#) (string " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``" (call _tex (inert abs) "g") "`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``" (call _tex (inert abs) "d") "`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = " (call _tex (inert abs) "g") "^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ " (call _tex (inert abs) "d") "^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``" (call _tex (inert abs) "g") "`` (``" (call _tex (inert abs) "d") "``), respectively.\n") (struct true (<: (curly StopWhenLagrangeMultiplierLess (<: T Real) (<: A (curly AbstractVector (<: T))) (<: B (curly Union Nothing (<: (curly AbstractVector (<: String)))))) StoppingCriterion) (block (:: tolerances A) (:: values A) (:: names B) (:: mode Symbol) (:: at_iteration Int) (function (where (call StopWhenLagrangeMultiplierLess (parameters (kw (:: mode Symbol) (inert estimate)) (kw (:: names B) nothing)) (:: tol T)) (<: T Real) (<: B (curly Union Nothing (<: (curly AbstractVector (<: String)))))) (block (return (call (curly new T (curly Vector T) B) (vect tol) (call zero (vect tol)) names mode -1)))) (function (where (call StopWhenLagrangeMultiplierLess (parameters (kw (:: mode Symbol) (inert estimate)) (kw (:: names B) nothing)) (:: tols A)) (<: T Real) (<: A (curly AbstractVector (<: T))) (<: B (curly Union Nothing (<: (curly AbstractVector (<: String)))))) (block (return (call (curly new T A B) tols (call zero tols) names mode -1)))))))  └─ @ /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76  Stacktrace:  [1] iterate(A::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}})  @ Base /source/usr/share/julia/JuliaLowering/src/ast.jl:23 [inlined]  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1106  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1223  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1253  [5] 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:33  [6] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [7] top-level scope  @ ~/.julia/packages/Manopt/iNyem/src/plans/plan.jl:132  [8] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [9] top-level scope  @ ~/.julia/packages/Manopt/iNyem/src/Manopt.jl:184  [10] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [11] 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  [12] top-level scope  @ stdin:5  [13] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [14] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [15] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [16] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [17] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 in expression starting at /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/plan.jl:132 in expression starting at /home/pkgeval/.julia/packages/Manopt/iNyem/src/Manopt.jl:1 in expression starting at stdin:5 ✗ Manopt 22 dependencies successfully precompiled in 1232 seconds. 12 already precompiled. Precompilation completed after 1242.86s ################################################################################ # Loading # Loading Manopt... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 =# @doc " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``$(_tex(:abs, "g"))`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``$(_tex(:abs, "d"))`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = $(_tex(:abs, "g"))^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ $(_tex(:abs, "d"))^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``$(_tex(:abs, "g"))`` (``$(_tex(:abs, "d"))``), respectively.\n" mutable struct StopWhenLagrangeMultiplierLess{T <: Real, A <: AbstractVector{<:T}, B <: Union{Nothing, <:AbstractVector{<:String}}} <: StoppingCriterion │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:107 =# │ tolerances::A │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:108 =# │ values::A │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:109 =# │ names::B │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:110 =# │ mode::Symbol │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:111 =# │ at_iteration::Int │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:112 =# │ function StopWhenLagrangeMultiplierLess(tol::T; mode::Symbol = :estimate, names::B = nothing) where {T <: Real, B <: Union{Nothing, <:AbstractVector{<:String}}} │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:112 =# │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:115 =# │ return new{T, Vector{T}, B}([tol], zero([tol]), names, mode, -1) │ end │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117 =# │ function StopWhenLagrangeMultiplierLess(tols::A; mode::Symbol = :estimate, names::B = nothing) where {T <: Real, A <: AbstractVector{<:T}, B <: Union{Nothing, <:AbstractVector{<:String}}} │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117 =# │ #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:120 =# │ return new{T, A, B}(tols, zero(tols), names, mode, -1) │ 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 │ │ :(#= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 =#) :: Value │ │ [string] │ │ " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ │ "`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ │ "`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = " :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ │ "^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ " :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ │ "^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ │ "`` (``" :: Value │ │ [call] │ │ _tex :: Identifier │ │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ │ "``), respectively.\n" :: Value │ │ [struct] │ │ true :: Value │ │ [<:] │ │ [curly] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ A :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ T :: Identifier │ │ [<:] │ │ B :: Identifier │ │ [curly] │ │ Union :: Identifier │ │ Nothing :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ String :: Identifier │ │ StoppingCriterion :: Identifier │ │ [block] │ │ [::] │ │ tolerances :: Identifier │ │ A :: Identifier │ │ [::] │ │ values :: Identifier │ │ A :: Identifier │ │ [::] │ │ names :: Identifier │ │ B :: Identifier │ │ [::] │ │ mode :: Identifier │ │ Symbol :: Identifier │ │ [::] │ │ at_iteration :: Identifier │ │ Int :: Identifier │ │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ │ B :: Identifier │ │ nothing :: Identifier │ │ [::] │ │ tol :: Identifier │ │ T :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ B :: Identifier │ │ [curly] │ │ Union :: Identifier │ │ Nothing :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ String :: Identifier │ │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ T :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ T :: Identifier │ │ B :: Identifier │ │ [vect] │ │ tol :: Identifier │ │ [call] │ │ zero :: Identifier │ │ [vect] │ │ tol :: Identifier │ │ names :: Identifier │ │ mode :: Identifier │ │ -1 :: Value │ │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ │ Symbol :: Identifier │ │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ │ B :: Identifier │ │ nothing :: Identifier │ │ [::] │ │ tols :: Identifier │ │ A :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ A :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ T :: Identifier │ │ [<:] │ │ B :: Identifier │ │ [curly] │ │ Union :: Identifier │ │ Nothing :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [<:] │ │ String :: Identifier │ │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ T :: Identifier │ │ A :: Identifier │ │ B :: Identifier │ │ tols :: Identifier │ │ [call] │ │ zero :: Identifier │ │ tols :: Identifier │ │ names :: Identifier │ │ mode :: Identifier │ │ -1 :: Value │ │ │ 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] │ │ true :: Value │ macro_source=186 │ [<:] │ scope_layer=1 │ [curly] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ StoppingCriterion :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ tolerances :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [::] │ │ values :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [::] │ │ names :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [::] │ │ mode :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [::] │ │ at_iteration :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ scope_layer=1 │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [::] │ │ tol :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [vect] │ │ tol :: Identifier │ scope_layer=1 │ [call] │ │ zero :: Identifier │ scope_layer=1 │ [vect] │ │ tol :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ mode :: Identifier │ scope_layer=1 │ -1 :: Value │ macro_source=186 │ [function] │ │ [where] │ │ [call] │ │ StopWhenLagrangeMultiplierLess :: Identifier │ scope_layer=1 │ [parameters] │ │ [kw] │ │ [::] │ │ mode :: Identifier │ scope_layer=1 │ Symbol :: Identifier │ scope_layer=1 │ [inert] │ │ estimate :: Identifier │ │ [kw] │ │ [::] │ │ names :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [::] │ │ tols :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ [block] │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ B :: Identifier │ scope_layer=1 │ tols :: Identifier │ scope_layer=1 │ [call] │ │ zero :: Identifier │ scope_layer=1 │ tols :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ mode :: Identifier │ scope_layer=1 │ -1 :: Value │ macro_source=186 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=186 │ Manopt :: Value │ macro_source=186 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=186 │ Manopt :: Value │ │ [inert] │ jl_source=L65 │ StopWhenLagrangeMultiplierLess :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=186 │ [call] │ │ Core.svec :: Value │ macro_source=186 │ " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ macro_source=186 │ "`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ macro_source=186 │ "`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = " :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ macro_source=186 │ "^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ " :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ macro_source=186 │ "^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "g" :: Value │ macro_source=186 │ "`` (``" :: Value │ macro_source=186 │ [call] │ │ _tex :: Identifier │ scope_layer=1 │ [inert] │ │ abs :: Identifier │ │ "d" :: Value │ macro_source=186 │ "``), respectively.\n" :: Value │ macro_source=186 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=186 │ :path => "/home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl" :: Value │ macro_source=186 │ :linenumber => 76 :: Value │ macro_source=186 │ :module => Manopt :: Value │ macro_source=186 │ [call] │ │ Pair :: Value │ macro_source=186 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=186 │ Dict{Symbol, Any} :: Value │ macro_source=186 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl" │ line = 76 └ mod = Manopt ERROR: LoadError: internal lowering bug: #= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117 =# - `jl_assert(!(haskey(ssa_rewrites, lhs_id)), _)`: multiple assignments to ssavalue Expression:  (= #₅₉ (call core.TypeVar :#T1 #₃₀₈/T)) Containing expressions:  (= #₅₉ (call core.TypeVar :#T1 #₃₀₈/T))  Detailed provenance:  (= #₅₉ (call core.TypeVar :#T1 #₃₀₈/T)) @#= /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:366 =#  └─ (= #₅₉ (call core.TypeVar :#T1 #₁₁₉/T)) @#= /source/usr/share/julia/JuliaLowering/src/closure_conversion.jl:197 =#  └─ (= #₅₉ (call core.TypeVar :#T1 #₁₁₉/T)) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₅₉ (call core.TypeVar :#T1 T)) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₅₉ (call core.TypeVar :#T1 T))  └─ (call core.TypeVar :#T1 T) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3025 =#  └─ (<: T)  └─ (<: T)  └─ (<: T)  └─ (<: T)  ├─ @ /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:117  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 =#) (string " StopWhenLagrangeMultiplierLess <: StoppingCriterion\n\nStopping Criteria for Lagrange multipliers.\n\nCurrently these are meant for the [`convex_bundle_method`](@ref) and [`proximal_bundle_method`](@ref),\nwhere based on the Lagrange multipliers an approximate (sub)gradient ``g`` and an error estimate ``ε``\nis computed.\n\nThe `mode=:both` requires that both\n``ε`` and ``" (call _tex (inert abs) "g") "`` are smaller than their `tolerance`s for the [`convex_bundle_method`](@ref),\nand that\n``c`` and ``" (call _tex (inert abs) "d") "`` are smaller than their `tolerance`s for the [`proximal_bundle_method`](@ref).\n\nThe `mode=:estimate` requires that, for the [`convex_bundle_method`](@ref)\n``-ξ = " (call _tex (inert abs) "g") "^2 + ε`` is less than a given `tolerance`.\nFor the [`proximal_bundle_method`](@ref), the equation reads ``-ν = μ " (call _tex (inert abs) "d") "^2 + c``.\n\n# Constructors\n\n StopWhenLagrangeMultiplierLess(tolerance=1e-6; mode::Symbol=:estimate, names=nothing)\n\nCreate the stopping criterion for one of the `mode`s mentioned.\nNote that tolerance can be a single number for the `:estimate` case,\nbut a vector of two values is required for the `:both` mode.\nHere the first entry specifies the tolerance for ``ε`` (``c``),\nthe second the tolerance for ``" (call _tex (inert abs) "g") "`` (``" (call _tex (inert abs) "d") "``), respectively.\n") (struct true (<: (curly StopWhenLagrangeMultiplierLess (<: T Real) (<: A (curly AbstractVector (<: T))) (<: B (curly Union Nothing (<: (curly AbstractVector (<: String)))))) StoppingCriterion) (block (:: tolerances A) (:: values A) (:: names B) (:: mode Symbol) (:: at_iteration Int) (function (where (call StopWhenLagrangeMultiplierLess (parameters (kw (:: mode Symbol) (inert estimate)) (kw (:: names B) nothing)) (:: tol T)) (<: T Real) (<: B (curly Union Nothing (<: (curly AbstractVector (<: String)))))) (block (return (call (curly new T (curly Vector T) B) (vect tol) (call zero (vect tol)) names mode -1)))) (function (where (call StopWhenLagrangeMultiplierLess (parameters (kw (:: mode Symbol) (inert estimate)) (kw (:: names B) nothing)) (:: tols A)) (<: T Real) (<: A (curly AbstractVector (<: T))) (<: B (curly Union Nothing (<: (curly AbstractVector (<: String)))))) (block (return (call (curly new T A B) tols (call zero tols) names mode -1)))))))  └─ @ /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76  Stacktrace:  [1] iterate(A::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}})  @ Base /source/usr/share/julia/JuliaLowering/src/ast.jl:23 [inlined]  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1106  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1223  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1253  [5] 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:33  [6] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [7] top-level scope  @ ~/.julia/packages/Manopt/iNyem/src/plans/plan.jl:132  [8] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [9] top-level scope  @ ~/.julia/packages/Manopt/iNyem/src/Manopt.jl:184  [10] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [11] 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  [12] top-level scope  @ stdin:5  [13] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [14] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [15] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [16] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [17] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/bundle_plan.jl:76 in expression starting at /home/pkgeval/.julia/packages/Manopt/iNyem/src/plans/plan.jl:132 in expression starting at /home/pkgeval/.julia/packages/Manopt/iNyem/src/Manopt.jl:1 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ Manopt │ [Output was shown above] └ ERROR: The following 1 package failed to precompile: Manopt Failed to precompile Manopt [0fc0a36d-df90-57f3-8f93-d78a9fc72bb5] to "/home/pkgeval/.julia/compiled/v1.14/Manopt/jl_frIu0P" (ProcessExited(1)). Loading failed after 159.79s 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 Manopt'`, 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 1445.18s: package fails to precompile