Add documentation for EisenstatWalkerForcing2

- Add Eisenstat & Walker (1996) reference to refs.bib
- Add forcing parameter to General Keyword Arguments section
- Add new Forcing Term Strategies section with EisenstatWalkerForcing2 docs
- Update NewtonRaphson docstring with detailed keyword argument descriptions
- Add mention of Newton-Krylov support in solver recommendations

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: ChrisRackauckas

docs/src/native/solvers.md

@@ -35,6 +35,10 @@ documentation.
     differencing tricks (without ever constructing the Jacobian). However, if the Jacobian
     is still needed, for example for a preconditioner, `concrete_jac = true` can be passed
     in order to force the construction of the Jacobian.
+  - `forcing`: Adaptive forcing term strategy for Newton-Krylov methods. When using an
+    iterative linear solver (Krylov method), this controls how accurately the linear system
+    is solved at each Newton iteration. Defaults to `nothing` (fixed tolerance). See
+    [Forcing Term Strategies](@ref forcing_strategies) for available options.
 
 ## Nonlinear Solvers
 
@@ -81,3 +85,43 @@ QuasiNewtonAlgorithm
 GeneralizedFirstOrderAlgorithm
 GeneralizedDFSane
 ```
+
+## [Forcing Term Strategies](@id forcing_strategies)
+
+Forcing term strategies control how accurately the linear system is solved at each Newton
+iteration when using iterative (Krylov) linear solvers. This is the key idea behind
+Newton-Krylov methods: instead of solving ``J \delta u = -f(u)`` exactly, we solve it only
+approximately with a tolerance ``\eta_k`` (the forcing term).
+
+The [eisenstat1996choosing](@citet) paper introduced adaptive strategies for choosing
+``\eta_k`` that can significantly improve convergence, especially for problems where the
+initial guess is far from the solution.
+
+```@docs
+EisenstatWalkerForcing2
+```
+
+### Example Usage
+
+```julia
+using NonlinearSolve, LinearSolve
+
+# Define a large nonlinear problem
+function f!(F, u, p)
+    for i in 2:(length(u) - 1)
+        F[i] = u[i - 1] - 2u[i] + u[i + 1] + sin(u[i])
+    end
+    F[1] = u[1] - 1.0
+    F[end] = u[end]
+end
+
+n = 1000
+u0 = zeros(n)
+prob = NonlinearProblem(f!, u0)
+
+# Use Newton-Raphson with GMRES and Eisenstat-Walker forcing
+sol = solve(prob, NewtonRaphson(
+    linsolve = KrylovJL_GMRES(),
+    forcing = EisenstatWalkerForcing2()
+))
+```

docs/src/refs.bib

@@ -1,3 +1,14 @@
+@article{eisenstat1996choosing,
+  title     = {Choosing the forcing terms in an inexact Newton method},
+  author    = {Eisenstat, Stanley C and Walker, Homer F},
+  journal   = {SIAM Journal on Scientific Computing},
+  volume    = {17},
+  number    = {1},
+  pages     = {16--32},
+  year      = {1996},
+  publisher = {SIAM}
+}
+
 @article{bastin2010retrospective,
   title     = {A retrospective trust-region method for unconstrained optimization},
   author    = {Bastin, Fabian and Malmedy, Vincent and Mouffe, M{\'e}lodie and Toint, Philippe L and Tomanos, Dimitri},

docs/src/solvers/nonlinear_system_solvers.md

@@ -50,7 +50,8 @@ sparse/structured matrix support, etc. These methods support the largest set of
 features, but have a bit of overhead on very small problems.
 
   - [`NewtonRaphson()`](@ref): A Newton-Raphson method with swappable nonlinear solvers and
-    autodiff methods for high performance on large and sparse systems.
+    autodiff methods for high performance on large and sparse systems. Supports Newton-Krylov
+    methods with adaptive forcing via [`EisenstatWalkerForcing2`](@ref).
   - [`TrustRegion()`](@ref): A Newton Trust Region dogleg method with swappable nonlinear
     solvers and autodiff methods for high performance on large and sparse systems.
   - [`LevenbergMarquardt()`](@ref): An advanced Levenberg-Marquardt implementation with the

lib/NonlinearSolveFirstOrder/src/raphson.jl

@@ -8,6 +8,24 @@
 An advanced NewtonRaphson implementation with support for efficient handling of sparse
 matrices via colored automatic differentiation and preconditioned linear solvers. Designed
 for large-scale and numerically-difficult nonlinear systems.
+
+### Keyword Arguments
+
+  - `autodiff`: determines the backend used for the Jacobian. Defaults to `nothing` which
+    means that a default is selected according to the problem specification.
+  - `concrete_jac`: whether to build a concrete Jacobian. If a Krylov-subspace method is
+    used, then the Jacobian will not be constructed. Defaults to `nothing`.
+  - `linsolve`: the [LinearSolve.jl](https://github.com/SciML/LinearSolve.jl) solver used
+    for the linear solves within the Newton method. Defaults to `nothing`, which means it
+    uses the LinearSolve.jl default algorithm choice.
+  - `linesearch`: the line search algorithm to use. Defaults to `missing` (no line search).
+  - `vjp_autodiff`: backend for computing Vector-Jacobian products.
+  - `jvp_autodiff`: backend for computing Jacobian-Vector products.
+  - `forcing`: Adaptive forcing term strategy for Newton-Krylov methods. When using an
+    iterative linear solver (e.g., `KrylovJL_GMRES()`), this controls how accurately the
+    linear system is solved at each iteration. Use `EisenstatWalkerForcing2()` for the
+    classical Eisenstat-Walker adaptive forcing strategy. Defaults to `nothing` (fixed
+    tolerance from the termination condition).
 """
 function NewtonRaphson(;
         concrete_jac = nothing, linsolve = nothing, linesearch = missing,