yaeos__newton_solver Module

Estimated condition number of J (or J^T J + lambda I when LM active) at the final iteration, via LAPACK dgecon. Dimensionless.

||dX||_inf of the last computed Newton step at exit. Units: same as x.

||F||_inf at iterations 0, 1, …, result%iterations. Allocated only when settings%save_history = .true. Size: (iterations + 1).

||F(x)||_inf at exit. Should be < atol on NEWTON_SUCCESS. Units: same as F.

Total number of Newton iterations performed (accepted + rejected).

Value of the LM regularisation parameter at exit. 0.0 means the final solve was a pure Newton step. Units: [J]^2.

Exit status code. Compare with NEWTON_SUCCESS, NEWTON_MAX_ITS, etc. Use newton_status_msg(status) for a human-readable string.

Sufficient decrease constant (Wolfe c1 condition). Smaller values accept more steps but give weaker convergence guarantees. Must satisfy 0 < armijo_c < 0.5. Dimensionless. Default: 1e-4.

Maximum number of backtracking halvings per Newton step. If reached without satisfying Armijo, ls_failed is set .true. Default: 50.

Step-length reduction factor applied each backtracking iteration. t_new = armijo_tau * t_old until Armijo or t < t_min. Must satisfy 0 < armijo_tau < 1. Dimensionless. Default: 0.5.

Absolute residual tolerance. Converged when max_i |F_i(x)| < atol. Units: same as F. Default: 1e-8.

Condition number threshold above which LM regularization is activated (or strengthened) to stabilise the linear solve. Estimated via LAPACK dgecon. Dimensionless. Default: 1e10.

Initial value of the LM damping parameter. 0.0 = start as pure Newton; the solver activates LM automatically if conditioning is poor. Set > 0 to force LM from the first iteration. Units: [J]^2 (scales with the Jacobian entries squared). Default: 0.

Factor by which lambda is divided after a successful step with t > 0.1. Drives the solver back toward pure Newton as the iterate improves. Dimensionless. Default: 5.

Maximum lambda, expressed as a multiplier of jacobian_scale. If lambda exceeds this ceiling the solver returns NEWTON_LINE_SEARCH_FAIL. Dimensionless multiplier. Default: 1e8.

Minimum non-zero lambda, expressed as a multiplier of jacobian_scale. Effective floor = lambda_min * ||J||_F^2/n. Prevents lambda from decaying to numerical zero after a good step. Dimensionless multiplier. Default: 1e-6.

Factor by which lambda is multiplied on a line-search failure. Larger values recover faster from bad Jacobians but may overshoot. Dimensionless. Default: 10.

Maximum number of Newton iterations before returning NEWTON_MAX_ITS. Default: 100.

Relative step tolerance. Converged when max_i |dX_i| < rtol * (max_i |x_i| + atol). Catches the case where the step becomes negligible compared to x. Dimensionless. Default: 1e-6.

If .true., allocate result%f_history(0:iterations) and store ||F||_inf at each iteration. Slightly increases memory use. Default: .false.

Number of consecutive iterations with negligible change in ||dX|| before the solver exits with NEWTON_STAGNATION. Default: 5.

Relative threshold for stagnation: iteration is counted as stagnant when |||dX||_prev - ||dX||_curr| < stagnation_tol * (||dX|| + 1). Dimensionless. Default: 1e-12.

Minimum accepted step length. If t < t_min the line search declares failure instead of accepting a micro-step that satisfies Armijo trivially (m changes by ~machine eps). Dimensionless (fraction of the full Newton step). Default: 1e-8.

Controls stdout output. 0 – silent 1 – print header + one-line summary at exit 2 – also print one line per accepted iteration Default: 0.

Jacobian matrix, shape (n,n)

Iterations done

||F||_inf at exit

||dX||_inf at exit

LM lambda at exit

cond(J) at exit

Jacobian at x

Residual at x

LM damping (absolute)

||J||_F^2/n

Solver settings

Computed Newton/LM step

cond(A) estimate