Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Errors during parameter homotopies #466

Open
alexheaton2 opened this issue Apr 14, 2021 · 9 comments
Open

Errors during parameter homotopies #466

alexheaton2 opened this issue Apr 14, 2021 · 9 comments

Comments

@alexheaton2
Copy link

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...
@saschatimme
Copy link
Member

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

@saschatimme saschatimme mentioned this issue Apr 15, 2021
Merged
@saschatimme
Copy link
Member

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

@alexheaton2
Copy link
Author

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

@saschatimme saschatimme reopened this Apr 15, 2021
@alexheaton2
Copy link
Author

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 alexheaton2 mentioned this issue Apr 21, 2021
Closed
@alexheaton2
Copy link
Author

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
Copy link
Author

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

@saschatimme
Copy link
Member

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.

@alexheaton2
Copy link
Author

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

@matthiashimmelmann
Copy link

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

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
3 participants
@alexheaton2 @saschatimme @matthiashimmelmann