Bump to Krylov 0.10 (#148)

* Bump to Krylov 0.10

* up docs

Author: tmigot

Project.toml

@@ -22,14 +22,14 @@ StoppingInterface = "53949629-e8ff-437b-b6e7-14da1a85bf25"
 
 [compat]
 FastClosures = "0.2, 0.3"
-JSOSolvers = "0.9, 0.10, 0.11, 0.12, 0.13"
-Krylov = "0.8, 0.9"
+JSOSolvers = "0.14"
+Krylov = "0.10"
 LDLFactorizations = "0.8, 0.9, 0.10"
 LinearOperators = "^2.7"
-NLPModels = "0.18, 0.19, 0.20, 0.21"
+NLPModels = "0.21"
 NLPModelsIpopt = "0.10"
 NLPModelsKnitro = "0.9"
-NLPModelsModifiers = "0.5, 0.6, 0.7"
+NLPModelsModifiers = "0.7"
 SolverCore = "0.3"
 Stopping = "0.6"
 StoppingInterface = "0.5"

docs/Project.toml

@@ -13,7 +13,7 @@ Stopping = "c4fe5a9e-e7fb-5c3d-89d5-7f405ab2214f"
 [compat]
 ADNLPModels = "0.8"
 Documenter = "0.27"
-JSOSolvers = "0.13"
+JSOSolvers = "0.14"
 NLPModels = "0.21"
 NLPModelsIpopt = "0.10"
 OptimizationProblems = "0.9"

docs/src/fine-tuneFPS.md

@@ -108,5 +108,5 @@ The metadata for the feasibility procedure is defined in a `GNSolver` structure
 | `Δ₀`                | `Real`                          | `1.0`                                                | Feasibility step: initial radius.                                                                         |
 | `feas_expected_decrease` | `Real`                          | `0.95`                                               | Feasibility step: bad steps are when ‖c(z)‖ / ‖c(x)‖ >feas_expected_decrease.                             |
 | `bad_steps_lim`          | `Integer`                                 | `3`                                                  | Feasibility step: consecutive bad steps before using a second order step.                                 |
-| `TR_compute_step`        | `KrylovSolver`                                  | `LsmrSolver`                                           | Compute the direction in feasibility step.                                           |
-| `aggressive_step` | `KrylovSolver` | `CgSolver` | Compute the (aggressive) direction in feasibility step. |
+| `TR_compute_step`        | `KrylovWorkspace`                                  | `LsmrWorkspace`                                           | Compute the direction in feasibility step.                                           |
+| `aggressive_step` | `KrylovWorkspace` | `CgWorkspace` | Compute the (aggressive) direction in feasibility step. |

src/feasibility.jl

@@ -117,7 +117,7 @@ function feasibility_step(
     # Safeguard: aggressive normal step
     if normcz > ρ && (consecutive_bad_steps ≥ bad_steps_lim || failed_step_comp)
       Hz = hess_op(nlp, z, cz, obj_weight = zero(T))
-      Krylov.solve!(feasibility_solver.aggressive_step, Hz + Jz' * Jz, Jz' * cz)
+      krylov_solve!(feasibility_solver.aggressive_step, Hz + Jz' * Jz, Jz' * cz)
       d = feasibility_solver.aggressive_step.x
       stats = feasibility_solver.aggressive_step.stats
       if !stats.solved
@@ -206,7 +206,7 @@ using `lsmr` method from `Krylov.jl`.
 - `solved`: `true` if the problem has been successfully solved.
 """
 function TR_lsmr(solver, cz, Jz, ctol::AbstractFloat, Δ::T, normcz::AbstractFloat, Jd) where {T}
-  Krylov.solve!(
+  krylov_solve!(
     solver,
     Jz,
     -cz,

src/parameters.jl

@@ -137,8 +137,8 @@ The keyword arguments may include:
 - `Δ₀::T=one(T)`: Feasibility step: initial radius.
 - `bad_steps_lim::Integer=3`: Feasibility step: consecutive bad steps before using a second order step.
 - `feas_expected_decrease::T=T(0.95)`: Feasibility step: bad steps are when `‖c(z)‖ / ‖c(x)‖ >feas_expected_decrease`.
-- `TR_compute_step = LsmrSolver(length(y0), length(x0), S)`: Compute the direction in feasibility step.
-- `aggressive_step = CgSolver(length(x0), length(x0), S)`: Compute the direction in feasibility step in agressive mode.
+- `TR_compute_step = LsmrWorkspace(length(y0), length(x0), S)`: Compute the direction in feasibility step.
+- `aggressive_step = CgWorkspace(length(x0), length(x0), S)`: Compute the direction in feasibility step in agressive mode.
 """
 mutable struct GNSolver
   # Parameters
@@ -158,8 +158,8 @@ mutable struct GNSolver
   workspace_Jtv
 
   # Compute TR-step
-  TR_compute_step # ::KrylovSolver{eltype(S), S}
-  aggressive_step # ::KrylovSolver{eltype(S), S}
+  TR_compute_step # ::KrylovWorkspace{eltype(S), S}
+  aggressive_step # ::KrylovWorkspace{eltype(S), S}
 end
 
 function GNSolver(
@@ -172,8 +172,8 @@ function GNSolver(
   Δ₀::AbstractFloat = one(eltype(S)),
   bad_steps_lim::Integer = 3,
   feas_expected_decrease::AbstractFloat = eltype(S)(0.95),
-  TR_compute_step = LsmrSolver(length(y0), length(x0), S),
-  aggressive_step = CgSolver(length(x0), length(x0), S),
+  TR_compute_step = LsmrWorkspace(length(y0), length(x0), S),
+  aggressive_step = CgWorkspace(length(x0), length(x0), S),
 ) where {S}
   n, m = length(x0), length(y0)
   return GNSolver(

src/solve_linear_system.jl

@@ -57,7 +57,7 @@ function solve_two_extras(
 
   JtJ = nlp.Aop * nlp.Aop' # this allocates
   # (invJtJSsv, stats) = minres(JtJ, rhs2, λ = τ)
-  Krylov.solve!(
+  krylov_solve!(
     nlp.qdsolver.solver_struct_pinv,
     JtJ,
     rhs2,
@@ -151,10 +151,10 @@ function solve_two_extras(
   else
     nlp.Aop = jac_op(nlp.nlp, x)
   end
-  (invJtJJv, invJtJJvstats) = cgls(nlp.Aop', rhs1, λ = τ) # use Krylov.solve!
+  (invJtJJv, invJtJJvstats) = cgls(nlp.Aop', rhs1, λ = τ) # use krylov_solve!
 
   JtJ = nlp.Aop * nlp.Aop'
-  (invJtJSsv, stats) = minres(JtJ, rhs2, λ = τ) # use Krylov.solve!
+  (invJtJSsv, stats) = minres(JtJ, rhs2, λ = τ) # use krylov_solve!
   return invJtJJv, invJtJSsv
 end
 
@@ -163,7 +163,7 @@ function solve_two_least_squares(
   x::AbstractVector,
   rhs1,
   rhs2,
-) where {T, S, Tt, A, P, S2, Si, Str}
+) where {T, S, A, P, S2, Si, Str}
   #set the memory for the matrix in the FletcherPenaltyNLP
   nvar = nlp.nlp.meta.nvar
   ncon = nlp.explicit_linear_constraints ? nlp.nlp.meta.nnln : nlp.nlp.meta.ncon

src/solve_two_systems_struct.jl

@@ -23,9 +23,9 @@ It uses `Krylov.jl` methods to solve least-squares and least-norm problems.
 struct IterativeSolver{
   T <: AbstractFloat,
   S,
-  SS1 <: KrylovSolver{T, T, S},
-  SS2 <: KrylovSolver{T, T, S},
-  SS3 <: KrylovSolver{T, T, S},
+  SS1 <: KrylovWorkspace{T, T, S},
+  SS2 <: KrylovWorkspace{T, T, S},
+  SS3 <: KrylovWorkspace{T, T, S},
   It <: Integer,
 } <: QDSolver
   # parameters for least-square solve
@@ -72,15 +72,15 @@ struct IterativeSolver{
   q2::S # part 2: solution of 2nd LS
 end
 
-# import Krylov.LsqrSolver
+# import Krylov.LsqrWorkspace
 #=
-mutable struct LsqrSolver2{T,S} <: KrylovSolver{T,S}
+mutable struct LsqrWorkspace2{T,S} <: KrylovWorkspace{T,S}
   x  :: S
   Nv :: S
   w  :: S
   Mu :: S
 
-  function LsqrSolver2(n, m, S, T)
+  function LsqrWorkspace2(n, m, S, T)
     x  = S(undef, m)
     Nv = S(undef, m)
     w  = S(undef, m)
@@ -113,17 +113,17 @@ function IterativeSolver(
   ne_etol::T = √eps(T),
   ne_itmax::Int = 0,
   ne_conlim::T = 1 / √eps(T),
-  solver_struct_least_square::KrylovSolver{T, T, S} = LsqrSolver(
+  solver_struct_least_square::KrylovWorkspace{T, T, S} = LsqrWorkspace(
     nlp.meta.nvar,
     explicit_linear_constraints ? nlp.meta.nnln : nlp.meta.ncon,
     S,
   ),
-  solver_struct_least_norm::KrylovSolver{T, T, S} = CraigSolver( # LnlqSolver(
+  solver_struct_least_norm::KrylovWorkspace{T, T, S} = CraigWorkspace( # LnlqSolver(
     explicit_linear_constraints ? nlp.meta.nnln : nlp.meta.ncon,
     nlp.meta.nvar,
     S,
   ),
-  solver_struct_pinv::KrylovSolver{T, T, S} = MinresSolver(
+  solver_struct_pinv::KrylovWorkspace{T, T, S} = MinresWorkspace(
     explicit_linear_constraints ? nlp.meta.nnln : nlp.meta.ncon,
     explicit_linear_constraints ? nlp.meta.nnln : nlp.meta.ncon,
     S,
@@ -170,7 +170,7 @@ function solve_least_square(
   b,
   λ,
 ) where {T, S, SS1, SS2, SS3, It}
-  Krylov.solve!(
+  krylov_solve!(
     qdsolver.solver_struct_least_square,
     A,
     b,
@@ -212,7 +212,7 @@ function solve_least_norm(
   A,
   b,
   δ,
-) where {T, S, SS1, SS2 <: CraigSolver, SS3, It}
+) where {T, S, SS1, SS2 <: CraigWorkspace, SS3, It}
   if δ != 0
     craig!(
       qdsolver.solver_struct_least_norm,
@@ -256,7 +256,7 @@ function solve_least_norm(
 ) where {T, S, SS1, SS2, SS3, It}
   ncon = length(b)
   if δ != 0
-    Krylov.solve!(
+    krylov_solve!(
       qdsolver.solver_struct_least_norm,
       A,
       b,
@@ -266,7 +266,7 @@ function solve_least_norm(
       itmax = qdsolver.ln_itmax,
     )
   else
-    Krylov.solve!(
+    krylov_solve!(
       qdsolver.solver_struct_least_norm,
       A,
       b,