HomotopyContinuation.jl icon indicating copy to clipboard operation
HomotopyContinuation.jl copied to clipboard

Published 20 hours ago • verified publisher icon JuliaHomotopyContinuation

Errors during parameter homotopies

Open alexheaton2 opened this issue 4 years ago • 9 comments

Hello again,

I have been running some optimization algorithms using parameter homotopy, and most of the time it works great! However, two errors have come up. To be clear, they do not come up usually. But I've been running so many different examples, and these two errors arose. When I run my algorithm with different inputs, everything works fine. However, occasionally my code seems to be running into these errors, which I copy below.

mul_float: types of a and b must match

Stacktrace:
 [1] mul_fast at ./fastmath.jl:166 [inlined]
 [2] mul_fast at ./fastmath.jl:220 [inlined]
 [3] muladd_fast at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/model_kit/instructions.jl:118 [inlined]
 [4] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/model_kit/slp_compiler.jl:88 [inlined]
 [5] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/model_kit/compiled_system_homotopy.jl:185 [inlined]
 [6] evaluate!(::Array{Complex{Float64},1}, ::CompiledSystem{(0xffe49967415743d0, 1)}, ::Array{Complex{Float64},1}, ::Array{Complex{Float64},1}) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/model_kit/compiled_system_homotopy.jl:185
 [7] evaluate! at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/systems/mixed_system.jl:29 [inlined]
 [8] evaluate! at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/homotopies/parameter_homotopy.jl:91 [inlined]
 [9] init_newton!(::Array{Complex{Float64},1}, ::HomotopyContinuation.NewtonCorrector, ::ParameterHomotopy{MixedSystem{Float64,(0xffe49967415743d0, 1)}}, ::Array{Complex{Float64},1}, ::Complex{Float64}, ::HomotopyContinuation.Jacobian{StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::WeightedNorm{InfNorm}; a::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/newton_corrector.jl:247
 [10] init!(::Tracker{ParameterHomotopy{MixedSystem{Float64,(0xffe49967415743d0, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64, ::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/tracker.jl:675
 [11] init!(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xffe49967415743d0, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; ω::Float64, μ::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:266
 [12] #track!#150 at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:301 [inlined]
 [13] track! at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:301 [inlined]
 [14] track(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xffe49967415743d0, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:897
 [15] serial_solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xffe49967415743d0, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}, ::ProgressMeter.Progress, ::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/solve.jl:568
 [16] solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xffe49967415743d0, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/solve.jl:522
 [17] solve(::System, ::Vararg{Any,N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Array{Complex{Float64},1}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol,Array{Float64,1},Tuple{Symbol},NamedTuple{(:start_parameters,),Tuple{Array{Float64,1}}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/solve.jl:487
 [18] twostep(::System, ::Array{Float64,1}, ::Float64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:89
 [19] takelocalsteps(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::typeof(evaluateobjectivefunctiongradient); decreasefactor::Float64, increasefactor::Float64, maxsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:167
 [20] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function; maxseconds::Int64, maxlocalsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:286
 [21] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:273
 [22] top-level scope at In[52]:9
 [23] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091

and also separately, I also found this second error, which looks different.

MethodError: no method matching svdvals!(::StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64})
Closest candidates are:
  svdvals!(::SymTridiagonal) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:350
  svdvals!(::StridedArray{T, 2}) where T<:Union{Complex{Float32}, Complex{Float64}, Float32, Float64} at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/svd.jl:193
  svdvals!(::StridedArray{T, 2}, ::StridedArray{T, 2}) where T<:Union{Complex{Float32}, Complex{Float64}, Float32, Float64} at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/svd.jl:501
  ...

Stacktrace:
 [1] svdvals(::StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/svd.jl:194
 [2] #rank#15 at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/generic.jl:985 [inlined]
 [3] init!(::Tracker{ParameterHomotopy{MixedSystem{Float64,(0x0458ff2ff5bb1101, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64, ::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/tracker.jl:714
 [4] init!(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x0458ff2ff5bb1101, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; ω::Float64, μ::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:266
 [5] #track!#150 at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:301 [inlined]
 [6] track! at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:301 [inlined]
 [7] track(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x0458ff2ff5bb1101, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/endgame_tracker.jl:897
 [8] serial_solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x0458ff2ff5bb1101, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}, ::ProgressMeter.Progress, ::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/solve.jl:568
 [9] solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x0458ff2ff5bb1101, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/solve.jl:522
 [10] solve(::System, ::Vararg{Any,N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Array{Complex{Float64},1}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol,Array{Float64,1},Tuple{Symbol},NamedTuple{(:start_parameters,),Tuple{Array{Float64,1}}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/xsVeI/src/solve.jl:487
 [11] twostep(::System, ::Array{Float64,1}, ::Float64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:89
 [12] takelocalsteps(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::typeof(evaluateobjectivefunctiongradient); decreasefactor::Float64, increasefactor::Float64, maxsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:167
 [13] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function; maxseconds::Int64, maxlocalsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:286
 [14] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:273
 [15] top-level scope at In[43]:8
 [16] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091

Thanks for taking a look. This might be finding some weird errors during path tracking...

alexheaton2 avatar Apr 14 '21 23:04 alexheaton2

Thanks for the report! I am moving these days, so it could take some more days until I get to this

saschatimme avatar Apr 15 '21 04:04 saschatimme

This should be fixed with 2.5.3. Let me know if you still see these coming up after updating

saschatimme avatar Apr 15 '21 07:04 saschatimme

Hi Sascha, unfortunately I still get the following error, even after doing Pkg.update("HomotopyContinuation") and restarting with a new notebook/kernel. Here is the error again:

mul_float: types of a and b must match

Stacktrace:
 [1] mul_fast at ./fastmath.jl:166 [inlined]
 [2] mul_fast at ./fastmath.jl:220 [inlined]
 [3] muladd_fast at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/model_kit/instructions.jl:122 [inlined]
 [4] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/model_kit/slp_compiler.jl:88 [inlined]
 [5] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/model_kit/compiled_system_homotopy.jl:185 [inlined]
 [6] evaluate!(::Array{Complex{Float64},1}, ::CompiledSystem{(0xdb753123a3b45c4b, 1)}, ::Array{Complex{Float64},1}, ::Array{Complex{Float64},1}) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/model_kit/compiled_system_homotopy.jl:185
 [7] evaluate! at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/systems/mixed_system.jl:29 [inlined]
 [8] evaluate! at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/homotopies/parameter_homotopy.jl:91 [inlined]
 [9] init_newton!(::Array{Complex{Float64},1}, ::HomotopyContinuation.NewtonCorrector, ::ParameterHomotopy{MixedSystem{Float64,(0xdb753123a3b45c4b, 1)}}, ::Array{Complex{Float64},1}, ::Complex{Float64}, ::HomotopyContinuation.Jacobian{StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::WeightedNorm{InfNorm}; a::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/newton_corrector.jl:247
 [10] init!(::Tracker{ParameterHomotopy{MixedSystem{Float64,(0xdb753123a3b45c4b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64, ::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/tracker.jl:675
 [11] init!(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xdb753123a3b45c4b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; ω::Float64, μ::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/endgame_tracker.jl:266
 [12] #track!#150 at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/endgame_tracker.jl:301 [inlined]
 [13] track! at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/endgame_tracker.jl:301 [inlined]
 [14] track(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xdb753123a3b45c4b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/endgame_tracker.jl:897
 [15] serial_solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xdb753123a3b45c4b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}, ::ProgressMeter.Progress, ::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/solve.jl:568
 [16] solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0xdb753123a3b45c4b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/solve.jl:522
 [17] solve(::System, ::Vararg{Any,N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Array{Complex{Float64},1}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol,Array{Float64,1},Tuple{Symbol},NamedTuple{(:start_parameters,),Tuple{Array{Float64,1}}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/w4WA4/src/solve.jl:487
 [18] twostep(::System, ::Array{Float64,1}, ::Float64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:89
 [19] takelocalsteps(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::typeof(evaluateobjectivefunctiongradient); decreasefactor::Float64, increasefactor::Float64, maxsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:167
 [20] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function; maxseconds::Int64, maxlocalsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:286
 [21] top-level scope at In[27]:9
 [22] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091

alexheaton2 avatar Apr 15 '21 18:04 alexheaton2

I tried to fix it, but I think I failed. Here is a copy of the error now:

mul_float: types of a and b must match

Stacktrace:
 [1] * at ./float.jl:405 [inlined]
 [2] * at ./complex.jl:320 [inlined]
 [3] muladd_fast at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/model_kit/instructions.jl:139 [inlined]
 [4] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/model_kit/slp_compiler.jl:128 [inlined]
 [5] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/model_kit/compiled_system_homotopy.jl:216 [inlined]
 [6] evaluate_and_jacobian!(::Array{Complex{Float64},1}, ::StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}, ::CompiledSystem{(0x76b5e12acde9819b, 1)}, ::Array{Complex{Float64},1}, ::Array{Complex{Float64},1}) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/model_kit/compiled_system_homotopy.jl:216
 [7] evaluate_and_jacobian! at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/systems/mixed_system.jl:31 [inlined]
 [8] evaluate_and_jacobian! at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/homotopies/parameter_homotopy.jl:96 [inlined]
 [9] init_newton!(::Array{Complex{Float64},1}, ::HomotopyContinuation.NewtonCorrector, ::ParameterHomotopy{MixedSystem{Float64,(0x76b5e12acde9819b, 1)}}, ::Array{Complex{Float64},1}, ::Complex{Float64}, ::HomotopyContinuation.Jacobian{StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::WeightedNorm{InfNorm}; a::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/newton_corrector.jl:221
 [10] init!(::Tracker{ParameterHomotopy{MixedSystem{Float64,(0x76b5e12acde9819b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64, ::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/tracker.jl:675
 [11] init!(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x76b5e12acde9819b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; ω::Float64, μ::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/endgame_tracker.jl:266
 [12] #track!#150 at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/endgame_tracker.jl:301 [inlined]
 [13] track! at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/endgame_tracker.jl:301 [inlined]
 [14] track(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x76b5e12acde9819b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/endgame_tracker.jl:897
 [15] serial_solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x76b5e12acde9819b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}, ::ProgressMeter.Progress, ::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/solve.jl:568
 [16] solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x76b5e12acde9819b, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/solve.jl:522
 [17] solve(::System, ::Vararg{Any,N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Array{Complex{Float64},1}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol,Array{Complex{Float64},1},Tuple{Symbol},NamedTuple{(:start_parameters,),Tuple{Array{Complex{Float64},1}}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/zIN25/src/solve.jl:487
 [18] twostep(::System, ::Array{Float64,1}, ::Float64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:113
 [19] takelocalsteps(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::typeof(evaluateobjectivefunctiongradient); decreasefactor::Float64, increasefactor::Float64, maxsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:191
 [20] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function; maxseconds::Int64, maxlocalsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:310
 [21] top-level scope at In[19]:11
 [22] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091

alexheaton2 avatar Apr 21 '21 19:04 alexheaton2

I used the updated code, and now I get this error below. It appears that the error was not the fast arithmetic, but something else?

mul_float: types of a and b must match

Stacktrace:
 [1] * at ./float.jl:405 [inlined]
 [2] * at ./complex.jl:320 [inlined]
 [3] muladd_instr at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/instructions.jl:119 [inlined]
 [4] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/slp_compiler.jl:128 [inlined]
 [5] macro expansion at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/compiled_system_homotopy.jl:216 [inlined]
 [6] evaluate_and_jacobian!(::Array{Complex{Float64},1}, ::StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}, ::CompiledSystem{(0x307c491bf37057ea, 1)}, ::Array{Complex{Float64},1}, ::Array{Complex{Float64},1}) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/compiled_system_homotopy.jl:216
 [7] evaluate_and_jacobian! at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/systems/mixed_system.jl:31 [inlined]
 [8] evaluate_and_jacobian! at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/homotopies/parameter_homotopy.jl:96 [inlined]
 [9] init_newton!(::Array{Complex{Float64},1}, ::HomotopyContinuation.NewtonCorrector, ::ParameterHomotopy{MixedSystem{Float64,(0x307c491bf37057ea, 1)}}, ::Array{Complex{Float64},1}, ::Complex{Float64}, ::HomotopyContinuation.Jacobian{StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::WeightedNorm{InfNorm}; a::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/newton_corrector.jl:221
 [10] init!(::Tracker{ParameterHomotopy{MixedSystem{Float64,(0x307c491bf37057ea, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64, ::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/tracker.jl:675
 [11] init!(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x307c491bf37057ea, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; ω::Float64, μ::Float64, extended_precision::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:266
 [12] #track!#150 at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:301 [inlined]
 [13] track! at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:301 [inlined]
 [14] track(::EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x307c491bf37057ea, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}, ::Array{Float64,1}, ::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:897
 [15] serial_solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x307c491bf37057ea, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}, ::ProgressMeter.Progress, ::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/solve.jl:568
 [16] solve(::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64,(0x307c491bf37057ea, 1)}},StructArrays.StructArray{Complex{Float64},2,NamedTuple{(:re, :im),Tuple{Array{Float64,2},Array{Float64,2}}},Int64}}}, ::Array{Array{Float64,1},1}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/solve.jl:522
 [17] solve(::System, ::Vararg{Any,N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Array{Complex{Float64},1}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol,Array{Complex{Float64},1},Tuple{Symbol},NamedTuple{(:start_parameters,),Tuple{Array{Complex{Float64},1}}}}) at /Users/heaton/.julia/packages/HomotopyContinuation/bPsOT/src/solve.jl:487
 [18] twostep(::System, ::Array{Float64,1}, ::Float64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:113
 [19] takelocalsteps(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::typeof(evaluateobjectivefunctiongradient); decreasefactor::Float64, increasefactor::Float64, maxsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:191
 [20] findminima(::Array{Float64,1}, ::Float64, ::Float64, ::ConstraintVariety, ::Function; maxseconds::Int64, maxlocalsteps::Int64) at /Users/heaton/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:310
 [21] top-level scope at In[23]:11
 [22] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091

alexheaton2 avatar Apr 30 '21 20:04 alexheaton2

Updated to julia 1.6 and tried. At first no errors for a while, but then this:

mul_float: types of a and b must match

Stacktrace:
  [1] *
    @ ./float.jl:332 [inlined]
  [2] *
    @ ./complex.jl:320 [inlined]
  [3] muladd_instr
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/instructions.jl:119 [inlined]
  [4] macro expansion
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/slp_compiler.jl:128 [inlined]
  [5] macro expansion
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/compiled_system_homotopy.jl:216 [inlined]
  [6] evaluate_and_jacobian!(u::Vector{ComplexF64}, U::StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}, T::CompiledSystem{(0x91e25e35f07cc179, 1)}, x::Vector{ComplexF64}, p::Vector{ComplexF64})
    @ HomotopyContinuation.ModelKit ~/.julia/packages/HomotopyContinuation/bPsOT/src/model_kit/compiled_system_homotopy.jl:216
  [7] evaluate_and_jacobian!
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/systems/mixed_system.jl:31 [inlined]
  [8] evaluate_and_jacobian!
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/homotopies/parameter_homotopy.jl:96 [inlined]
  [9] init_newton!(x̄::Vector{ComplexF64}, NC::HomotopyContinuation.NewtonCorrector, H::ParameterHomotopy{MixedSystem{Float64, (0x91e25e35f07cc179, 1)}}, x₀::Vector{ComplexF64}, t::ComplexF64, J::HomotopyContinuation.Jacobian{StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, norm::WeightedNorm{InfNorm}; a::Float64, extended_precision::Bool)
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/newton_corrector.jl:221
 [10] init!(tracker::Tracker{ParameterHomotopy{MixedSystem{Float64, (0x91e25e35f07cc179, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, x₁::Vector{Float64}, t₁::Float64, t₀::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool)
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/tracker.jl:675
 [11] init!(endgame_tracker::EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x91e25e35f07cc179, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, x::Vector{Float64}, t₁::Float64; ω::Float64, μ::Float64, extended_precision::Bool)
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:266
 [12] #track!#150
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:301 [inlined]
 [13] track!
    @ ~/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:301 [inlined]
 [14] track(endgame_tracker::EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x91e25e35f07cc179, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, x::Vector{Float64}, t₁::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/endgame_tracker.jl:897
 [15] serial_solve(solver::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x91e25e35f07cc179, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}}, starts::Vector{Vector{Float64}}, progress::ProgressMeter.Progress, stop_early_cb::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool)
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/solve.jl:568
 [16] solve(S::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x91e25e35f07cc179, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}}, starts::Vector{Vector{Float64}}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool)
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/solve.jl:522
 [17] solve(::System, ::Vararg{Any, N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Vector{ComplexF64}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol, Vector{ComplexF64}, Tuple{Symbol}, NamedTuple{(:start_parameters,), Tuple{Vector{ComplexF64}}}})
    @ HomotopyContinuation ~/.julia/packages/HomotopyContinuation/bPsOT/src/solve.jl:487
 [18] twostep(F::System, p::Vector{Float64}, stepsize::Float64)
    @ Main ~/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:113
 [19] takelocalsteps(p::Vector{Float64}, ε0::Float64, tolerance::Float64, G::ConstraintVariety, evaluateobjectivefunctiongradient::typeof(evaluateobjectivefunctiongradient); decreasefactor::Float64, increasefactor::Float64, maxsteps::Int64)
    @ Main ~/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:191
 [20] findminima(p0::Vector{Float64}, initialstepsize::Float64, tolerance::Float64, G::ConstraintVariety, evaluateobjectivefunctiongradient::Function; maxseconds::Int64, maxlocalsteps::Int64)
    @ Main ~/Julia notebooks/Myf and Matthias/BMNparameterhomotopyoptimization.jl:310
 [21] top-level scope
    @ In[21]:8
 [22] eval
    @ ./boot.jl:360 [inlined]
 [23] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:1094

alexheaton2 avatar May 01 '21 02:05 alexheaton2

Thanks for trying this. I have to try to reach out to some Julia folks, since I really have no clue what is going on.

saschatimme avatar May 01 '21 10:05 saschatimme

Hi Sascha, I am sure that I am doing something silly... maybe asking for a parameter homotopy with too small or too large a stepsize? I don't know. I'm playing around with an algorithm for constrained optimization. In case it helps, here is the last function I call before I call HomotopyContinuation.solve for a parameter homotopy. I could of course upload all the code, but don't want to overwhelm with too much information.

function twostep(F, p, stepsize)
    # we want parameter homotopy from 0.0 to stepsize, so we take two steps
    # first from 0.0 to a complex number parameter, then from that parameter to stepsize.
    midparam = stepsize/2 + stepsize/2*1.0im # complex number *midway* between 0 and stepsize, but off real line
    solveresult = HomotopyContinuation.solve(F, [p]; start_parameters=[0.0 + 0.0im], target_parameters=[midparam])
    midsols = HomotopyContinuation.solutions(solveresult)
    success = false
    if length(midsols) > 0
        midsolution = midsols[1] # only tracked one solution path, thus there should only be one solution
        solveresult = HomotopyContinuation.solve(F, [midsolution]; start_parameters=[midparam],
                                                    target_parameters=[stepsize + 0.0im])
        realsols = HomotopyContinuation.real_solutions(solveresult)
        if length(realsols) > 0
            q = realsols[1] # only tracked one solution path, thus there should only be one solution
            success = true
        else
            q = p
        end
    else
        q = p
    end
    return q, success
end

alexheaton2 avatar May 01 '21 19:05 alexheaton2

Hi Sascha, I am sure that I am doing something silly... maybe asking for a parameter homotopy with too small or too large a stepsize? I don't know. I'm playing around with an algorithm for constrained optimization. In case it helps, here is the last function I call before I call HomotopyContinuation.solve for a parameter homotopy. I could of course upload all the code, but don't want to overwhelm with too much information.

I don't think this is it. I believe I reproduced the error with both a onestep homotopy (similar to above but without the midparam) and the twostep homotopy from above with several step sizes between 1e-6 and 50. The error in every case was the same:

ERROR: LoadError: TaskFailedException
Stacktrace:
  [1] wait
    @ .\task.jl:317 [inlined]
  [2] threaded_solve(solver::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}}, S::Vector{Vector{Float64}}, progress::Nothing, stop_early_cb::typeof(HomotopyContinuation.always_false); catch_interrupt::Bool)
    @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\solve.jl:611
  [3] solve(S::Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}}, starts::Vector{Vector{Float64}}; stop_early_cb::Function, show_progress::Bool, threading::Bool, catch_interrupt::Bool)
    @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\solve.jl:514
  [4] solve(::System, ::Vararg{Any, N} where N; show_progress::Bool, threading::Bool, catch_interrupt::Bool, target_parameters::Vector{Float64}, stop_early_cb::Function, transform_result::Nothing, transform_parameters::typeof(identity), flatten::Nothing, target_subspaces::Nothing, kwargs::Base.Iterators.Pairs{Symbol, Vector{Float64}, Tuple{Symbol}, NamedTuple{(:start_parameters,), Tuple{Vector{Float64}}}})
    @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\solve.jl:487
  [5] onestep(F::System, p::Vector{Float64}, stepsize::Float64)
    @ Main ~\backtrackingmatthias.jl:86
  [6] backtracking_linesearch(Q::typeof(energyfunction), F::System, G::ConstraintVariety, evaluateobjectivefunctiongradient::var"#204#205"{typeof(energyfunction)}, p0::Vector{Float64}, stepsize::Float64; τ::Float64, r::Float64, s::Float64, twostepcheck::Bool)
    @ Main ~\backtrackingmatthias.jl:132
  [7] takelocalsteps(p::Vector{Float64}, ε0::Float64, tolerance::Float64, G::ConstraintVariety, objectiveFunction::typeof(energyfunction), evaluateobjectivefunctiongradient::var"#204#205"{typeof(energyfunction)}; maxsteps::Int64, decreasefactor::Int64, initialtime::Float64, maxseconds::Int64, twostepcheck::Bool)
    @ Main ~\backtrackingmatthias.jl:226
  [8] findminima(p0::Vector{Float64}, tolerance::Float64, G::ConstraintVariety, objectiveFunction::typeof(energyfunction); maxseconds::Int64, maxlocalsteps::Int64, initialstepsize::Float64, twostepcheck::Bool)
    @ Main ~\backtrackingmatthias.jl:300
  [9] top-level scope
    @ ~\BMNTest.jl:35
 [10] include(fname::String)
    @ Base.MainInclude .\client.jl:444
 [11] top-level scope
    @ none:1

    nested task error: mul_float: types of a and b must match
    Stacktrace:
      [1] mul_fast
        @ .\fastmath.jl:167 [inlined]
      [2] mul_fast
        @ .\fastmath.jl:221 [inlined]
      [3] muladd_fast
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\model_kit\instructions.jl:122 [inlined]
      [4] macro expansion
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\model_kit\slp_compiler.jl:88 [inlined]
      [5] macro expansion
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\model_kit\compiled_system_homotopy.jl:185 [inlined]
      [6] evaluate!(u::Vector{ComplexF64}, T::CompiledSystem{(0x3bc9389576b5e3de, 1)}, x::Vector{ComplexF64}, p::Vector{ComplexF64})
        @ HomotopyContinuation.ModelKit ~\.julia\packages\HomotopyContinuation\w4WA4\src\model_kit\compiled_system_homotopy.jl:185
      [7] evaluate!
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\systems\mixed_system.jl:29 [inlined]
      [8] evaluate!
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\homotopies\parameter_homotopy.jl:91 [inlined]
      [9] init_newton!(x̄::Vector{ComplexF64}, NC::HomotopyContinuation.NewtonCorrector, H::ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, x₀::Vector{ComplexF64}, t::ComplexF64, J::HomotopyContinuation.Jacobian{StructArrays.StructArray{ComplexF64, 
2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, norm::WeightedNorm{InfNorm}; a::Float64, extended_precision::Bool)
        @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\newton_corrector.jl:247
     [10] init!(tracker::Tracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, x₁::Vector{Float64}, t₁::Float64, t₀::Float64; ω::Float64, μ::Float64, τ::Float64, max_initial_step_size::Float64, keep_steps::Bool, extended_precision::Bool)
        @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\tracker.jl:675
     [11] init!(endgame_tracker::EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, x::Vector{Float64}, t₁::Float64; ω::Float64, μ::Float64, extended_precision::Bool)
        @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\endgame_tracker.jl:266
     [12] #track!#150
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\endgame_tracker.jl:301 [inlined]
     [13] track!
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\endgame_tracker.jl:301 [inlined]
     [14] track(endgame_tracker::EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, x::Vector{Float64}, t₁::Float64; path_number::Int64, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
        @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\endgame_tracker.jl:897
     [15] macro expansion
        @ ~\.julia\packages\HomotopyContinuation\w4WA4\src\solve.jl:599 [inlined]
     [16] (::HomotopyContinuation.var"#285#287"{EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}, Solver{EndgameTracker{ParameterHomotopy{MixedSystem{Float64, (0x3bc9389576b5e3de, 1)}}, StructArrays.StructArray{ComplexF64, 2, NamedTuple{(:re, :im), Tuple{Matrix{Float64}, Matrix{Float64}}}, Int64}}}, Vector{Vector{Float64}}, Nothing, typeof(HomotopyContinuation.always_false), Base.Threads.Atomic{Int64}, Base.Threads.Atomic{Int64}, Vector{PathResult}, Int64})()
        @ HomotopyContinuation ~\.julia\packages\HomotopyContinuation\w4WA4\src\utils.jl:274
in expression starting at C:\Users\matth\BMNTest.jl:34

matthiashimmelmann avatar May 07 '21 09:05 matthiashimmelmann