format code

Author: MaxenceGollier

src/R2DH.jl

@@ -6,7 +6,7 @@ mutable struct R2DHSolver{
   T <: Real,
   G <: ShiftedProximableFunction,
   V <: AbstractVector{T},
-  QN <: AbstractDiagonalQuasiNewtonOperator{T}
+  QN <: AbstractDiagonalQuasiNewtonOperator{T},
 } <: AbstractOptimizationSolver
   xk::V
   ∇fk::V
@@ -25,7 +25,11 @@ mutable struct R2DHSolver{
   m_fh_hist::V
 end
 
-function R2DHSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; m_monotone::Int = 6, D :: Union{Nothing, AbstractDiagonalQuasiNewtonOperator} = nothing) where{T, V}
+function R2DHSolver(
+  reg_nlp::AbstractRegularizedNLPModel{T, V};
+  m_monotone::Int = 6,
+  D::Union{Nothing, AbstractDiagonalQuasiNewtonOperator} = nothing,
+) where {T, V}
   x0 = reg_nlp.model.meta.x0
   l_bound = reg_nlp.model.meta.lvar
   u_bound = reg_nlp.model.meta.uvar
@@ -49,8 +53,14 @@ function R2DHSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; m_monotone::Int
   end
   m_fh_hist = fill(T(-Inf), m_monotone - 1)
 
-  ψ = has_bnds ? shifted(reg_nlp.h, xk, l_bound_m_x, u_bound_m_x, reg_nlp.selected) : shifted(reg_nlp.h, xk)
-  isnothing(D) && (D = isa(reg_nlp.model, AbstractDiagonalQNModel) ? hess_op(reg_nlp.model, x0) : SpectralGradient(T(1), reg_nlp.model.meta.nvar))
+  ψ =
+    has_bnds ? shifted(reg_nlp.h, xk, l_bound_m_x, u_bound_m_x, reg_nlp.selected) :
+    shifted(reg_nlp.h, xk)
+  isnothing(D) && (
+    D =
+      isa(reg_nlp.model, AbstractDiagonalQNModel) ? hess_op(reg_nlp.model, x0) :
+      SpectralGradient(T(1), reg_nlp.model.meta.nvar)
+  )
 
   return R2DHSolver(
     xk,
@@ -67,10 +77,9 @@ function R2DHSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; m_monotone::Int
     u_bound,
     l_bound_m_x,
     u_bound_m_x,
-    m_fh_hist
+    m_fh_hist,
   )
 end
-  
 
 """
     R2DH(reg_nlp; kwargs…)
@@ -141,12 +150,7 @@ Notably, you can access, and modify, the following:
   - `stats.status`: current status of the algorithm. Should be `:unknown` unless the algorithm has attained a stopping criterion. Changing this to anything will stop the algorithm, but you should use `:user` to properly indicate the intention.
   - `stats.elapsed_time`: elapsed time in seconds.
 """
-function R2DH(
-  nlp::AbstractNLPModel{T, V},
-  h,
-  options::ROSolverOptions{T};
-  kwargs...,
-) where{T, V}
+function R2DH(nlp::AbstractNLPModel{T, V}, h, options::ROSolverOptions{T}; kwargs...) where {T, V}
   kwargs_dict = Dict(kwargs...)
   selected = pop!(kwargs_dict, :selected, 1:(nlp.meta.nvar))
   x0 = pop!(kwargs_dict, :x0, nlp.meta.x0)
@@ -200,14 +204,11 @@ function R2DH(
     θ = options.θ,
     kwargs...,
   )
-  
+
   return stats.solution, stats.iter, nothing
 end
 
-function R2DH(
-  reg_nlp::AbstractRegularizedNLPModel{T, V};
-  kwargs...
-) where{T, V}
+function R2DH(reg_nlp::AbstractRegularizedNLPModel{T, V}; kwargs...) where {T, V}
   kwargs_dict = Dict(kwargs...)
   m_monotone = pop!(kwargs_dict, :m_monotone, 6)
   D = pop!(kwargs_dict, :D, nothing)
@@ -236,8 +237,7 @@ function SolverCore.solve!(
   ν::T = eps(T)^(1 / 5),
   γ::T = T(3),
   θ::T = 1/(1 + eps(T)^(1 / 5)),
-) where{T, V}
-
+) where {T, V}
   reset!(stats)
 
   # Retrieve workspace
@@ -269,7 +269,6 @@ function SolverCore.solve!(
   end
   m_monotone = length(m_fh_hist) + 1
 
-
   # initialize parameters
   improper = false
   hk = @views h(xk[selected])
@@ -324,7 +323,7 @@ function SolverCore.solve!(
   set_objective!(stats, fk + hk)
   set_solver_specific!(stats, :smooth_obj, fk)
   set_solver_specific!(stats, :nonsmooth_obj, hk)
-  m_monotone > 1 && (m_fh_hist[(stats.iter)%(m_monotone - 1) + 1] = fk + hk)
+  m_monotone > 1 && (m_fh_hist[(stats.iter) % (m_monotone - 1) + 1] = fk + hk)
 
   φ(d) = begin
     result = zero(T)
@@ -334,12 +333,12 @@ function SolverCore.solve!(
     end
     return result
   end
-  
+
   mk(d)::T = φ(d) + ψ(d)::T
 
   spectral_test ? prox!(s, ψ, mν∇fk, ν₁) : iprox!(s, ψ, ∇fk, dkσk)
 
-  mks = mk(s) 
+  mks = mk(s)
 
   ξ = hk - mks + max(1, abs(hk)) * 10 * eps()
   sqrt_ξ_νInv = ξ ≥ 0 ? sqrt(ξ / ν₁) : sqrt(-ξ / ν₁)
@@ -431,7 +430,7 @@ function SolverCore.solve!(
     ν₁ = θ / (DNorm + σk)
 
     @. mν∇fk = -ν₁ * ∇fk
-    m_monotone > 1 && (m_fh_hist[stats.iter%(m_monotone - 1) + 1] = fk + hk)
+    m_monotone > 1 && (m_fh_hist[stats.iter % (m_monotone - 1) + 1] = fk + hk)
 
     spectral_test ? prox!(s, ψ, mν∇fk, ν₁) : iprox!(s, ψ, ∇fk, dkσk)
     mks = mk(s)
@@ -479,7 +478,7 @@ function SolverCore.solve!(
     @info "R2DH: terminating with √(ξ/ν) = $(sqrt_ξ_νInv)"
   end
 
-  set_solution!(stats,xk)
+  set_solution!(stats, xk)
   set_residuals!(stats, zero(eltype(xk)), sqrt_ξ_νInv)
   return stats
-end
+end

src/R2N.jl

@@ -7,7 +7,7 @@ mutable struct R2NSolver{
   G <: ShiftedProximableFunction,
   V <: AbstractVector{T},
   ST <: AbstractOptimizationSolver,
-  PB <: AbstractRegularizedNLPModel
+  PB <: AbstractRegularizedNLPModel,
 } <: AbstractOptimizationSolver
   xk::V
   ∇fk::V
@@ -28,7 +28,11 @@ mutable struct R2NSolver{
   substats::GenericExecutionStats{T, V, V, T}
 end
 
-function R2NSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; subsolver = R2Solver, m_monotone::Int = 1) where {T, V}
+function R2NSolver(
+  reg_nlp::AbstractRegularizedNLPModel{T, V};
+  subsolver = R2Solver,
+  m_monotone::Int = 1,
+) where {T, V}
   x0 = reg_nlp.model.meta.x0
   l_bound = reg_nlp.model.meta.lvar
   u_bound = reg_nlp.model.meta.uvar
@@ -53,15 +57,12 @@ function R2NSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; subsolver = R2Sol
   end
   m_fh_hist = fill(T(-Inf), m_monotone - 1)
 
-  ψ = has_bnds ? shifted(reg_nlp.h, xk, l_bound_m_x, u_bound_m_x, reg_nlp.selected) : shifted(reg_nlp.h, xk)
+  ψ =
+    has_bnds ? shifted(reg_nlp.h, xk, l_bound_m_x, u_bound_m_x, reg_nlp.selected) :
+    shifted(reg_nlp.h, xk)
 
   Bk = hess_op(reg_nlp.model, x0)
-  sub_nlp = R2NModel(
-    Bk,
-    ∇fk,
-    T(1),
-    x0
-  )
+  sub_nlp = R2NModel(Bk, ∇fk, T(1), x0)
   subpb = RegularizedNLPModel(sub_nlp, ψ)
   substats = RegularizedExecutionStats(subpb)
   subsolver = subsolver(subpb)
@@ -83,10 +84,9 @@ function R2NSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; subsolver = R2Sol
     m_fh_hist,
     subsolver,
     subpb,
-    substats
+    substats,
   )
 end
-  
 
 """
     R2N(reg_nlp; kwargs…)
@@ -212,9 +212,9 @@ function SolverCore.solve!(
   ν::T = eps(T)^(1 / 5),
   γ::T = T(3),
   β::T = 1 / eps(T),
-  θ::T = 1/(1+eps(T)^(1 / 5)),
-  kwargs...
-) where{T, V, G}
+  θ::T = 1/(1 + eps(T)^(1 / 5)),
+  kwargs...,
+) where {T, V, G}
   reset!(stats)
 
   # Retrieve workspace
@@ -263,7 +263,7 @@ function SolverCore.solve!(
     @info log_header(
       [:outer, :inner, :fx, :hx, :xi, :ρ, :σ, :normx, :norms, :normB, :arrow],
       [Int, Int, T, T, T, T, T, T, T, T, Char],
-      hdr_override = Dict{Symbol, String}( 
+      hdr_override = Dict{Symbol, String}(
         :fx => "f(x)",
         :hx => "h(x)",
         :xi => "√(ξ1/ν)",
@@ -294,7 +294,7 @@ function SolverCore.solve!(
 
   ν₁ = θ / (λmax + σk)
   ν_sub = ν₁
-  
+
   sqrt_ξ1_νInv = one(T)
 
   @. mν∇fk = -ν₁ * ∇fk
@@ -305,7 +305,7 @@ function SolverCore.solve!(
   set_objective!(stats, fk + hk)
   set_solver_specific!(stats, :smooth_obj, fk)
   set_solver_specific!(stats, :nonsmooth_obj, hk)
-  m_monotone > 1 && (m_fh_hist[stats.iter%(m_monotone - 1) + 1] = fk + hk)
+  m_monotone > 1 && (m_fh_hist[stats.iter % (m_monotone - 1) + 1] = fk + hk)
 
   φ1 = let ∇fk = ∇fk
     d -> dot(∇fk, d)
@@ -328,7 +328,7 @@ function SolverCore.solve!(
   (ξ1 < 0 && sqrt_ξ1_νInv > neg_tol) &&
     error("R2N: prox-gradient step should produce a decrease but ξ1 = $(ξ1)")
   atol += rtol * sqrt_ξ1_νInv # make stopping test absolute and relative
-  
+
   set_status!(
     stats,
     get_status(
@@ -348,20 +348,19 @@ function SolverCore.solve!(
   done = stats.status != :unknown
 
   while !done
+    sub_atol = stats.iter == 0 ? 1.0e-3 : min(sqrt_ξ1_νInv ^ (1.5), sqrt_ξ1_νInv * 1e-3)
 
-    sub_atol = stats.iter == 0 ? 1.0e-3 : min(sqrt_ξ1_νInv ^ (1.5) , sqrt_ξ1_νInv * 1e-3)
-    
     solver.subpb.model.σ = σk
     isa(solver.subsolver, R2DHSolver) && (solver.subsolver.D.d[1] = 1/ν₁)
     ν_sub = isa(solver.subsolver, R2DHSolver) ? 1/σk : ν₁
     solve!(
-      solver.subsolver, 
-      solver.subpb, 
+      solver.subsolver,
+      solver.subpb,
       solver.substats;
       x = s1,
       atol = sub_atol,
       ν = ν_sub,
-      kwargs...
+      kwargs...,
     )
 
     s .= solver.substats.solution
@@ -424,7 +423,7 @@ function SolverCore.solve!(
         push!(nlp, s, ∇fk⁻)
       end
       solver.subpb.model.B = hess_op(nlp, xk)
-    
+
       λmax, found_λ = opnorm(solver.subpb.model.B)
       found_λ || error("operator norm computation failed")
 
@@ -438,25 +437,25 @@ function SolverCore.solve!(
     if ρk < η1 || ρk == Inf
       σk = σk * γ
     end
-    
+
     ν₁ = θ / (λmax + σk)
-    m_monotone > 1 && (m_fh_hist[stats.iter%(m_monotone - 1) + 1] = fk + hk)
+    m_monotone > 1 && (m_fh_hist[stats.iter % (m_monotone - 1) + 1] = fk + hk)
 
     set_objective!(stats, fk + hk)
     set_solver_specific!(stats, :smooth_obj, fk)
     set_solver_specific!(stats, :nonsmooth_obj, hk)
     set_iter!(stats, stats.iter + 1)
     set_time!(stats, time() - start_time)
 
-    @. mν∇fk = - ν₁ * ∇fk  
+    @. mν∇fk = - ν₁ * ∇fk
     prox!(s1, ψ, mν∇fk, ν₁)
     mks = mk1(s1)
 
     ξ1 = hk - mks + max(1, abs(hk)) * 10 * eps()
 
     sqrt_ξ1_νInv = ξ1 ≥ 0 ? sqrt(ξ1 / ν₁) : sqrt(-ξ1 / ν₁)
     solved = (ξ1 < 0 && sqrt_ξ1_νInv ≤ neg_tol) || (ξ1 ≥ 0 && sqrt_ξ1_νInv ≤ atol)
-		
+
     (ξ1 < 0 && sqrt_ξ1_νInv > neg_tol) &&
       error("R2N: prox-gradient step should produce a decrease but ξ1 = $(ξ1)")
     set_status!(
@@ -501,4 +500,4 @@ function SolverCore.solve!(
   set_solution!(stats, xk)
   set_residuals!(stats, zero(eltype(xk)), sqrt_ξ1_νInv)
   return stats
-end
+end

src/R2NModel.jl

@@ -14,50 +14,39 @@ this model represents the smooth R2N subproblem:
 where `B` is either an approximation of the Hessian of `f` or the Hessian itself and `∇f` represents the gradient of `f` at `x0`.
 `σ > 0` is a regularization parameter and `v` is a vector of the same size as `x0` used for intermediary computations.
 """
-mutable struct R2NModel{T <: Real, V <: AbstractVector{T}, G <: AbstractLinearOperator{T}} <: AbstractNLPModel{T, V}
-  B :: G
-  ∇f :: V
-  v :: V
-  σ :: T
+mutable struct R2NModel{T <: Real, V <: AbstractVector{T}, G <: AbstractLinearOperator{T}} <:
+               AbstractNLPModel{T, V}
+  B::G
+  ∇f::V
+  v::V
+  σ::T
   meta::NLPModelMeta{T, V}
   counters::Counters
 end
-  
-function R2NModel(
-  B :: G,
-  ∇f :: V,
-  σ :: T,
-  x0 :: V
-) where{T, V, G}
+
+function R2NModel(B::G, ∇f::V, σ::T, x0::V) where {T, V, G}
   @assert length(x0) == length(∇f)
   meta = NLPModelMeta(
     length(∇f),
     x0 = x0, # Perhaps we should add lvar and uvar as well here.
   )
   v = similar(x0)
-  return R2NModel(
-    B :: G,
-    ∇f :: V,
-    v :: V,
-    σ :: T,
-    meta,
-    Counters()
-  )
+  return R2NModel(B::G, ∇f::V, v::V, σ::T, meta, Counters())
 end
-  
+
 function NLPModels.obj(nlp::R2NModel, x::AbstractVector)
   @lencheck nlp.meta.nvar x
   increment!(nlp, :neval_obj)
   mul!(nlp.v, nlp.B, x)
-  return dot(nlp.v, x)/2 + dot(nlp.∇f, x) + nlp.σ * dot(x, x) / 2 
+  return dot(nlp.v, x)/2 + dot(nlp.∇f, x) + nlp.σ * dot(x, x) / 2
 end
-  
+
 function NLPModels.grad!(nlp::R2NModel, x::AbstractVector, g::AbstractVector)
   @lencheck nlp.meta.nvar x
   @lencheck nlp.meta.nvar g
   increment!(nlp, :neval_grad)
   mul!(g, nlp.B, x)
   g .+= nlp.∇f
   g .+= nlp.σ .* x
-  return  g
-end
+  return g
+end

test/test_allocs.jl

@@ -41,7 +41,7 @@ end
 
 # Test non allocating solve!
 @testset "allocs" begin
-  for (h, h_name) ∈ ((NormL0(λ), "l0"), )
+  for (h, h_name) ∈ ((NormL0(λ), "l0"),)
     for (solver, solver_name) ∈ ((:R2Solver, "R2"), (:R2DHSolver, "R2DH"), (:R2NSolver, "R2N"))
       @testset "$(solver_name)" begin
         solver_name == "R2N" && continue #FIXME