🚦 simplify syntax for callback in newton

Author: romain.veltz@inria.fr

examples/SHpde_snaking.jl

@@ -103,7 +103,6 @@ br, = @time continuation(
 	normN = x -> norm(x, Inf64),
 	recordFromSolution = (x, p) -> (s5 = x[end ÷ 5], n2 = norm(x), nw = normweighted(x), s = sum(x), s2 = x[end ÷ 2], s4 = x[end ÷ 4],),
 	# tangentAlgo = SecantPred(),
-	# callbackN = (x, f, J, res, iteration, itlinear, options; kwargs...) ->(true)
 	)
 
 plot(br..., legend=false, linewidth=1, vars = (:param, :n2))

examples/brusselator.jl

@@ -189,7 +189,7 @@ outpo_f, _, flag = @time newton(poTrap,
 		# jacobianPO = :BorderedLU,
 		# jacobianPO = :FullSparseInplace,
 		normN = norminf,
-		callback = (x, f, J, res, iteration, itl, options; kwargs...) -> (println("--> amplitude = ", BK.amplitude(x, n, M; ratio = 2));true)
+		callback = (state; kwargs...) -> (println("--> amplitude = ", BK.amplitude(state.x, n, M; ratio = 2));true)
 		)
 	flag && printstyled(color=:red, "--> T = ", outpo_f[end], ", amplitude = ", BK.amplitude(outpo_f, n, M; ratio = 2),"\n")
 	BK.plotPeriodicPOTrap(outpo_f, n, M; ratio = 2)
@@ -207,7 +207,6 @@ opts_po_cont = ContinuationPar(dsmin = 0.001, dsmax = 0.1, ds= 0.01, pMax = 3.0,
 		jacobianPO = :BorderedSparseInplace,
 		# tangentAlgo = BorderedPred(),
 		verbosity = 3,	plot = true,
-		# callbackN = (x, f, J, res, iteration, options; kwargs...) -> (println("--> amplitude = ", BK.amplitude(x, n, M));true),
 		# finaliseSolution = (z, tau, step, contResult; k...) ->
 			# (Base.display(contResult.eig[end].eigenvals) ;true),
 		plotSolution = (x, p;kwargs...) -> heatmap!(reshape(x[1:end-1], 2*n, M)'; ylabel="time", color=:viridis, kwargs...),
@@ -247,7 +246,6 @@ opts_po_cont = ContinuationPar(dsmin = 0.0001, dsmax = 0.05, ds= 0.01, pMax = 2.
 		opts_po_cont; jacobianPO = :BorderedMatrixFree,
 		verbosity = 2,
 		plot = true,
-		# callbackN = (x, f, J, res, iteration, options; kwargs...) -> (println("--> amplitude = ", BK.amplitude(x, n, M));true),
 		# plotSolution = (x, p;kwargs...) -> heatmap!(reshape(x[1:end-1], 2*n, M)'; ylabel="time", color=:viridis, kwargs...)
 		normC = norminf)
 ####################################################################################################

examples/cGL2d-shooting.jl

@@ -172,7 +172,7 @@ br_po, = continuation(
 	# probSh;
 	ShootingProblem(Mt, prob_sp, ETDRK2(krylov = true); abstol = 1e-10, reltol = 1e-8) ;
 	verbosity = 3, plot = true, ampfactor = 1.5, δp = 0.01,
-	# callbackN = (x, f, J, res, iteration, itl, options; kwargs...) -> (println("--> amplitude = ", BK.amplitude(x, n, M; ratio = 2));true),
+	# callbackN = (state; kwargs...) -> (println("--> amplitude = ", BK.amplitude(state.x, n, M; ratio = 2));true),
 	linearAlgo = MatrixFreeBLS(@set ls.N = Mt*2n+2),
 	finaliseSolution = (z, tau, step, contResult; k...) ->begin
 		BK.haseigenvalues(contResult) && Base.display(contResult.eig[end].eigenvals)

examples/cGL2d.jl

@@ -226,7 +226,7 @@ opt_po = @set opt_newton.verbose = true
 			orbitguess_f, (@set par_cgl.r = r_hopf - 0.01),
 			(@set opt_po.linsolver = ls); jacobianPO = :FullMatrixFree,
 			normN = norminf,
-			# callback = (x, f, J, res, iteration, options) -> (println("--> amplitude = ", BK.amplitude(x, Nx*Ny, M; ratio = 2));true)
+			# callback = (state; k...) -> (println("--> amplitude = ", BK.amplitude(state.x, Nx*Ny, M; ratio = 2));true)
 			)
 	flag && printstyled(color=:red, "--> T = ", outpo_f[end], ", amplitude = ", BK.amplitude(outpo_f, Nx*Ny, M; ratio = 2),"\n")
 plot();BK.plotPeriodicPOTrap(outpo_f, M, Nx, Ny; ratio = 2);title!("")
@@ -255,7 +255,6 @@ br_po, _ = continuation(
 	opts_po_cont, poTrapMF;
 	ampfactor = 3., jacobianPO = :FullMatrixFree,
 	verbosity = 3,	plot = true,
-	# callbackN = (x, f, J, res, iteration, itl, options; kwargs...) -> (println("--> amplitude = ", BK.amplitude(x, n, M; ratio = 2));true),
 	finaliseSolution = (z, tau, step, contResult; k...) ->
 	(BK.haseigenvalues(contResult) && Base.display(contResult.eig[end].eigenvals) ;true),
 	plotSolution = (x, p; kwargs...) -> BK.plotPeriodicPOTrap(x, M, Nx, Ny; ratio = 2, kwargs...),
@@ -281,12 +280,12 @@ opt_po = @set opt_newton.verbose = true
 			(@set opt_po.linsolver = ls); jacobianPO = :BorderedMatrixFree,
 			normN = norminf)
 
-function callbackPO(x, f, J, res, iteration, linsolver = ls, prob = poTrap, p = par_cgl; kwargs...)
+function callbackPO(state; linsolver = ls, prob = poTrap, p = par_cgl, kwargs...)
 	@show ls.N keys(kwargs)
 	# we update the preconditioner every 10 continuation steps
 	if mod(kwargs[:iterationC], 10) == 9 && iteration == 1
 		@info "update Preconditioner"
-		Jpo = poTrap(Val(:JacCyclicSparse), x, (@set p.r = kwargs[:p]))
+		Jpo = poTrap(Val(:JacCyclicSparse), state.x, (@set p.r = kwargs[:p]))
 		Precilu = @time ilu(Jpo, τ = 0.003)
 		ls.Pl = Precilu
 	end
@@ -585,7 +584,6 @@ outpo_f, hist, flag = @time newton(
 		poTrapMF, orbitguess_f, (@set par_cgl.r = r_hopf - 0.01),
 		(@set opt_po.linsolver = ls); jacobianPO = :FullMatrixFree,
 		normN = x -> maximum(abs.(x)),
-		# callback = (x, f, J, res, iteration, options) -> (println("--> amplitude = ", amplitude(x));true)
 		) #14s
 flag && printstyled(color=:red, "--> T = ", outpo_f[end], ", amplitude = ", amplitude(outpo_f, Nx*Ny, M),"\n")
 
@@ -596,7 +594,6 @@ opt_po = @set opt_newton.verbose = true
 			orbitguess_cu, (@set par_cgl_gpu.r = r_hopf - 0.01),
 			(@set opt_po.linsolver = lsgpu); jacobianPO = :FullMatrixFree,
 			normN = x -> maximum(abs.(x)),
-			# callback = (x, f, J, res, iteration, options) -> (println("--> amplitude = ", BK.amplitude(x, Nx*Ny, M));true)
 			) #7s
 	flag && printstyled(color=:red, "--> T = ", outpo_f[end:end], ", amplitude = ", amplitude(outpo_f, Nx*Ny, M),"\n")
 

examples/carrier.jl

@@ -76,7 +76,6 @@ outdef1, _, flag = @time newton(
 	# perturbsol(deflationOp[1],0,0), par_def,
 	perturbsol(-out, 0, 0), par_def,
 	optdef, deflationOp;
-	# callback = (x, f, J, res, iteration, itlinear, options; kwargs...) ->(res < 1e8)
 	)
 	flag && push!(deflationOp, outdef1)
 

examples/pd-1d.jl

@@ -170,7 +170,7 @@ ls = GMRESIterativeSolvers(reltol = 1e-7, N = length(initpo), maxiter = 50, verb
 	optn = NewtonPar(verbose = true, tol = 1e-9,  maxIter = 20, linsolver = ls)
 	# deflationOp = BK.DeflationOperator(2 (x,y) -> dot(x[1:end-1], y[1:end-1]),1.0, [outpo])
 	outposh, _, flag = @time newton(probSh, initpo, par_br_hopf, optn;
-		callbackN = (x, f, J, res, iteration; kw...) -> (@show x[end];true),
+		callbackN = (state; kw...) -> (@show state.x[end];true),
 		normN = norminf)
 	flag && printstyled(color=:red, "--> T = ", outposh[end], ", amplitude = ", BK.getAmplitude(probSh, outposh, par_br_hopf; ratio = 2),"\n")
 
@@ -219,7 +219,7 @@ ls = GMRESIterativeSolvers(reltol = 1e-7, N = length(initpo_pd), maxiter = 50, v
 	optn = NewtonPar(verbose = true, tol = 1e-9,  maxIter = 120, linsolver = ls)
 	# deflationOp = BK.DeflationOperator(2 (x,y) -> dot(x[1:end-1], y[1:end-1]),1.0, [outpo])
 	outposh_pd, _, flag = @time newton(probSh, initpo_pd, par_br_pd, optn;
-		callback = (x, f, J, res, iteration, itlinear, options; kwargs...) -> (@show x[end];true),
+		callback = (state; kwargs...) -> (@show state.x[end];true),
 		normN = norminf)
 	flag && printstyled(color=:red, "--> T = ", outposh_pd[end], ", amplitude = ", BK.getAmplitude(probSh, outposh_pd, (@set par_br.C = -0.86); ratio = 2),"\n")
 

src/DeflatedContinuation.jl

@@ -141,7 +141,7 @@ function continuation(F, J, par, lens::Lens, contParams::ContinuationPar, defOp:
 			recordFromSolution = (x, p) -> norm(x),
 			plotSolution = (x, p ;kwargs...) -> plot!(x; kwargs...),
 			perturbSolution = (x, p, id) -> x,
-			callbackN = (x, f, J, res, iteration, itlinear, options; kwargs...) -> true,
+			callbackN = (state; kwargs...) -> true,
 			acceptSolution = (x, p) -> true,
 			updateDeflationOp = (defOp, x, p) -> push!(defOp, x),
 			normN = norm) where vectype

src/Newton.jl

@@ -43,7 +43,7 @@ This is the Newton-Krylov Solver for `F(x, p0) = 0` with Jacobian w.r.t. `x` wri
 - `x0` initial guess
 - `p0` set of parameters to be passed to `F` and `J`
 - `options::NewtonPar` variable holding the internal parameters used by the `newton` method
-- `callback` function passed by the user which is called at the end of each iteration. The default one is the following `cbDefault(x, f, J, res, it, itlinear, options; k...) = true`. Can be used to update a preconditionner for example. You can use for example `cbMaxNorm` to limit the residuals norms. If yo  want to specify your own, the arguments passed to the callback are as follows
+- `callback` function passed by the user which is called at the end of each iteration. The default one is the following `cbDefault(state; k...) = true`. Can be used to update a preconditionner for example. You can use for example `cbMaxNorm` to limit the residuals norms. If yo  want to specify your own, the elements passed in `state` to the callback are the following
     - `x` current solution
     - `f` current residual
     - `J` current jacobian
@@ -112,7 +112,7 @@ function newton(Fhandle, Jhandle, x0, p0, options::NewtonPar; normN = norm, call
 	verbose && displayIteration(it, res)
 
 	# invoke callback before algo really starts
-	compute = callback(x, f, nothing, res, it, 0, options; x0 = x0, resHist = resHist, fromNewton = true, kwargs...)
+	compute = callback((;x, f, nothing, res, it, options); x0 = x0, resHist = resHist, fromNewton = true, kwargs...)
 	# Main loop
 	while (res > tol) && (it < maxIter) && compute
 		J = Jhandle(x, p0)
@@ -130,10 +130,10 @@ function newton(Fhandle, Jhandle, x0, p0, options::NewtonPar; normN = norm, call
 
 		verbose && displayIteration(it, res, itlinear)
 
-		compute = callback(x, f, J, res, it, itlinear, options; x0 = x0, resHist = resHist, fromNewton = true, kwargs...)
+		compute = callback((;x, f, J, res, it, itlinear, options, x0, resHist); fromNewton = true, kwargs...)
 	end
 	((resHist[end] > tol) && verbose) && @error("\n--> Newton algorithm failed to converge, residual = $(res[end])")
-	flag = (resHist[end] < tol) & callback(x, f, nothing, res, it, nothing, options; x0 = x0, resHist = resHist, fromNewton = true, kwargs...)
+	flag = (resHist[end] < tol) & callback((;x, f, res, it, options, x0, resHist); fromNewton = true, kwargs...)
 	verbose && displayIteration(0, res, 0, true) # display last line of the table
 	return x, resHist, flag, it, itlineartot
 end
@@ -146,7 +146,7 @@ end
 
 
 # default callback
-cbDefault(x, f, J, res, it, itlinear, options; k...) = true
+cbDefault(state; k...) = true
 
 # newton callback to limit residual
 """
@@ -157,4 +157,4 @@ Create a callback used to reject residals larger than `cb.maxres` in the Newton
 struct cbMaxNorm{T}
 	maxres::T
 end
-(cb::cbMaxNorm)(x, f, J, res, it, itlinear, options; k...) = (return res < cb.maxres)
+(cb::cbMaxNorm)(state; k...) = (return state.res < cb.maxres)

src/Predictor.jl

@@ -503,7 +503,7 @@ function newtonPALC(F, Jh, par, paramlens::Lens,
 	line_step = true
 
 	# invoke callback before algo really starts
-	compute = callback(x, res_f, nothing, res, 0, 0, contparams; p = p, resHist = resHist, fromNewton = false, kwargs...)
+	compute = callback((;x, res_f, res, contparams, p, resHist); fromNewton = false, kwargs...)
 
 	# Main loop
 	while (res > tol) && (it < maxIter) && line_step && compute
@@ -565,10 +565,10 @@ function newtonPALC(F, Jh, par, paramlens::Lens,
 		verbose && displayIteration(it, res, itlinear)
 
 		# shall we break the loop?
-		compute = callback(x, res_f, J, res, it, itlinear, contparams; p = p, resHist = resHist, fromNewton = false, kwargs...)
+		compute = callback((;x, res_f, J, res, it, itlinear, contparams, z0, p, resHist); fromNewton = false, kwargs...)
 	end
 	verbose && displayIteration(it, res, 0, true) # display last line of the table
-	flag = (resHist[end] < tol) & callback(x, res_f, nothing, res, it, -1, contparams; p = p, resHist = resHist, fromNewton = false, kwargs...)
+	flag = (resHist[end] < tol) & callback((;x, res_f, res, it, contparams, p, resHist); fromNewton = false, kwargs...)
 	return BorderedArray(x, p), resHist, flag, it, itlineartot
 end
 

src/Utils.jl

@@ -1,6 +1,13 @@
 rightmost(ev) = ev[sortperm(ev, by = abs∘real)]
 getinterval(a, b) = (min(a, b), max(a, b))
 ####################################################################################################
+# display eigenvals with color
+function displayEV(eigenvals, color = :black)
+	for r in eigenvals
+		printstyled(color=color, r, "\n")
+	end
+end
+####################################################################################################
 function displayIteration(i, residual, itlinear = 0, lastRow = false)
 	if lastRow
 		lastRow && println("└─────────────┴──────────────────────┴────────────────┘")