JuliaSmoothOptimizers · farhadrclass · Jan 13, 2026 · Jan 29, 2026 · Jan 29, 2026 · Jan 29, 2026
diff --git a/Project.toml b/Project.toml
@@ -3,25 +3,40 @@ uuid = "10dff2fc-5484-5881-a0e0-c90441020f8a"
 version = "0.14.8"
 
 [deps]
+Arpack = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97"
+GenericLinearAlgebra = "14197337-ba66-59df-a3e3-ca00e7dcff7a"
+HSL = "34c5aeac-e683-54a6-a0e9-6e0fdc586c50"
+HSL_jll = "017b0a0e-03f4-516a-9b91-836bbd1904dd"
 Krylov = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearOperators = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
 NLPModelsModifiers = "e01155f1-5c6f-4375-a9d8-616dd036575f"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+QRMumps = "422b30a1-cc69-4d85-abe7-cc07b540c444"
 SolverCore = "ff4d7338-4cf1-434d-91df-b86cb86fb843"
 SolverParameters = "d076d87d-d1f9-4ea3-a44b-64b4cdd1e470"
 SolverTools = "b5612192-2639-5dc1-abfe-fbedd65fab29"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+SparseMatricesCOO = "fa32481b-f100-4b48-8dc8-c62f61b13870"
+TSVD = "9449cd9e-2762-5aa3-a617-5413e99d722e"
 
 [compat]
-Krylov = "0.10.0"
-LinearOperators = "2.0"
+Arpack = "0.5.4"
+GenericLinearAlgebra = "0.3.19"
+HSL = "0.5.2"
+Krylov = "0.10.1"
+LinearOperators = "2.14.1"
 NLPModels = "0.21"
 NLPModelsModifiers = "0.7, 0.8"
+QRMumps = "0.3.2"
 SolverCore = "0.3"
 SolverParameters = "0.1"
 SolverTools = "0.10"
+SparseArrays = "1.11.0"
+SparseMatricesCOO = "0.2.6"
+TSVD = "0.4.4"
 julia = "1.10"
 
 [extras]

diff --git a/README.md b/README.md
@@ -26,13 +26,17 @@ This package provides an implementation of four classic algorithms for unconstra
     > DOI: [10.1007/BF01589116](https://doi.org/10.1007/BF01589116)
 
 
+- `R2N`: An inexact second-order quadratic regularization method for unconstrained optimization (with shifted L-BFGS or shifted Hessian operator);
+
 - `R2`: a first-order quadratic regularization method for unconstrained optimization;
 
     > E. G. Birgin, J. L. Gardenghi, J. M. Martínez, S. A. Santos, Ph. L. Toint. (2017).
     > Worst-case evaluation complexity for unconstrained nonlinear optimization using
     > high-order regularized models. *Mathematical Programming*, 163(1), 359-368.
     > DOI: [10.1007/s10107-016-1065-8](https://doi.org/10.1007/s10107-016-1065-8)
 
+- `R2NLS`: an inexact second-order quadratic regularization method for nonlinear least-squares problems;
+
 - `fomo`: a first-order method with momentum for unconstrained optimization;
 
 - `tron`: a pure Julia implementation of TRON, a trust-region solver for bound-constrained optimization described in
@@ -68,7 +72,7 @@ using JSOSolvers, ADNLPModels
 
 # Rosenbrock
 nlp = ADNLPModel(x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0])
-stats = lbfgs(nlp) # or trunk, tron, R2
+stats = lbfgs(nlp) # or trunk, tron, R2, R2N
 ```
 
 ## Documentation

diff --git a/docs/src/benchmark.md b/docs/src/benchmark.md
@@ -131,3 +131,47 @@ print_pp_column(:neval_obj, stats) # with respect to number of objective evaluat
 ``` @example ex1
 print_pp_column(:neval_grad, stats) # with respect to number of gradient evaluations
 ```
+
+## Unconstrained Benchmark
+
+We can also benchmark unconstrained solvers, such as `R2N`, on the `pnames_unconstrained` subset we identified earlier. For instance, comparing `R2N` against `trunk`:
+
+```@example ex1
+cutest_unc_problems = (CUTEstModel(p) for p in pnames_unconstrained)
+
+solvers_unc = Dict(
+  :trunk => nlp -> trunk(
+    nlp,
+    max_time = max_time,
+    max_iter = typemax(Int64),
+    max_eval = typemax(Int64),
+    atol = tol,
+    rtol = tol,
+  ),
+  :R2N => nlp -> R2N(
+    nlp,
+    max_time = max_time,
+    max_iter = typemax(Int64),
+    max_eval = typemax(Int64),
+    atol = tol,
+    rtol = tol,
+  ),
+)
+
+stats_unc = bmark_solvers(solvers_unc, cutest_unc_problems)
+
+```
+
+We can explore the results and generate performance profiles for these unconstrained solvers just as we did before:
+
+```@example ex1
+pretty_stats(stats_unc[:R2N])
+
+```
+
+```@example ex1
+print_pp_column(:elapsed_time, stats_unc)
+
+```
+
+**Note on `R2NLS`:** To benchmark the `R2NLS` solver on nonlinear least-squares (NLS) problems, you can follow this exact same pattern by providing a collection of `AbstractNLSModel` instances instead of general `CUTEstModel`s.
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -80,7 +80,7 @@ The main dependencies required to use the solvers are:
 
 - `SolverTools.jl` – provides common optimization components such as line searches, stopping conditions, and trace utilities;
 
-- `Krylov.jl` – used by second-order methods such as TRON and TRUNK for solving Newton or trust-region subproblems;
+- `Krylov.jl` – used by second-order methods such as TRON, TRUNK, R2N, and R2NLS for solving Newton, regularized, or trust-region subproblems;
 
 - `LinearOperators.jl` – provides abstractions for matrix-free linear operators used by iterative methods;
 
@@ -116,7 +116,7 @@ where `nlp` is an AbstractNLPModel or some specialization, such as an `AbstractN
 - `max_eval` is the maximum number of objective and constraints function evaluations (default: `-1`, which means no limit);
 - `max_time` is the maximum allowed elapsed time (default: `30.0`);
 - `callback` is a function that is called at each iteration;
-- `callback_quasi_newton` is a function that is called at each iteration to perform quasi-Newton updates, if appropriate (currently only supported by TRON and TRUNK);
+- `callback_quasi_newton` is a function that is called at each iteration to perform quasi-Newton updates, if appropriate (currently only supported by TRON , TRUNK, and R2N);
 - `stats` is a `SolverTools.GenericExecutionStats` with the output of the solver.
 
 ### Callbacks

diff --git a/docs/src/solvers.md b/docs/src/solvers.md
@@ -7,11 +7,13 @@
 - [`trunk`](@ref)
 - [`R2`](@ref)
 - [`fomo`](@ref)
+- [`R2N`](@ref)
+- [`R2NLS`](@ref)
 
 | Problem type          | Solvers  |
 | --------------------- | -------- |
-| Unconstrained Nonlinear Optimization Problem     | [`lbfgs`](@ref), [`tron`](@ref), [`trunk`](@ref), [`R2`](@ref), [`fomo`](@ref)|
-| Unconstrained Nonlinear Least Squares     | [`trunk`](@ref), [`tron`](@ref) |
+| Unconstrained Nonlinear Optimization Problem     | [`lbfgs`](@ref), [`tron`](@ref), [`trunk`](@ref), [`R2`](@ref), [`fomo`](@ref), [`R2N`](@ref)|
+| Unconstrained Nonlinear Least Squares     | [`trunk`](@ref), [`tron`](@ref), [`R2NLS`](@ref)|
 | Bound-constrained Nonlinear Optimization Problem  | [`tron`](@ref) |
 | Bound-constrained Nonlinear Least Squares | [`tron`](@ref) |
 
@@ -23,4 +25,6 @@ tron
 trunk
 R2
 fomo
+R2N
+R2NLS
 ```
diff --git a/src/JSOSolvers.jl b/src/JSOSolvers.jl
@@ -1,12 +1,14 @@
 module JSOSolvers
 
 # stdlib
-using LinearAlgebra, Logging, Printf
+using LinearAlgebra, Logging, Printf, SparseArrays
 
 # JSO packages
+using Arpack, TSVD, GenericLinearAlgebra
 using Krylov,
   LinearOperators, NLPModels, NLPModelsModifiers, SolverCore, SolverParameters, SolverTools
 
+
 import SolverTools.reset!
 import SolverCore.solve!
 export default_callback_quasi_newton, solve!
@@ -58,14 +60,20 @@ function default_callback_quasi_newton(
     end
   end
 end
+# subsolver interface
+include("r2n_subsolver_common.jl")
+include("R2N_subsolvers.jl")
+include("R2NLS_subsolvers.jl")
 
 # Unconstrained solvers
 include("lbfgs.jl")
 include("trunk.jl")
 include("fomo.jl")
+include("R2N.jl")
 
 # Unconstrained solvers for NLS
 include("trunkls.jl")
+include("R2NLS.jl")
 
 # List of keywords accepted by TRONTrustRegion
 const tron_keys = (