Revert JuliaFormatter changes

Author: MaxenceGollier

.JuliaFormatter.toml

@@ -1,3 +1,7 @@
+annotate_untyped_fields_with_any = false
 indent = 2
 margin = 92
 normalize_line_endings = "unix"
+remove_extra_newlines = true
+whitespace_ops_in_indices = true
+whitespace_typedefs = true

benchmarks/tables/fh-table.jl

@@ -178,7 +178,7 @@ if display_sol
   data = zeros(length(subset) + 1, 5)
   data[1, :] .= x0
   for i = 1:length(subset)
-    data[i+1, :] .= stats[i].solution
+    data[i + 1, :] .= stats[i].solution
   end
   pretty_table(
     data;

benchmarks/tables/regulopt-tables.jl

@@ -62,8 +62,8 @@ function benchmark_table(
   pb_name::String,
   random_seed::Int;
   tex::Bool = false,
-  nls_train::Union{Nothing,AbstractNLSModel} = nothing, # for SVM
-  nls_test::Union{Nothing,AbstractNLSModel} = nothing, # for SVM
+  nls_train::Union{Nothing, AbstractNLSModel} = nothing, # for SVM
+  nls_test::Union{Nothing, AbstractNLSModel} = nothing, # for SVM
 )
   solver_names = [
     "$(solver)$(subsolvername(subsolver))$(options_str(opt, solver, subsolver_opt, subsolver))"

examples/plot-utils-fh.jl

@@ -3,9 +3,9 @@ using PGFPlots
 function plot_fh(outstruct, F, data, name = "tr-qr")
   Comp_pg = outstruct.solver_specific[:SubsolverCounter]
   objdec = outstruct.solver_specific[:Fhist] + outstruct.solver_specific[:Hhist]
-  F1 = @view F[1:2:(end-1)]
+  F1 = @view F[1:2:(end - 1)]
   F2 = @view F[2:2:end]
-  data1 = @view data[1:2:(end-1)]
+  data1 = @view data[1:2:(end - 1)]
   data2 = @view data[2:2:end]
   a = Axis(
     [

examples/plot-utils-nnmf.jl

@@ -5,8 +5,8 @@ function plot_nnmf(outstruct, Avec, m, n, k, name = "tr-qr")
   objdec = outstruct.solver_specific[:Fhist] + outstruct.solver_specific[:Hhist]
   x = outstruct.solution
   A = reshape(Avec, m, n)
-  W = reshape(x[1:(m*k)], m, k)
-  H = reshape(x[(m*k+1):end], k, n)
+  W = reshape(x[1:(m * k)], m, k)
+  H = reshape(x[(m * k + 1):end], k, n)
   WH = W * H
 
   a = GroupPlot(2, 2, groupStyle = "horizontal sep = 2.5cm")

src/AL_alg.jl

@@ -140,17 +140,17 @@ Notably, you can access, and modify, the following:
   - `stats.solver_specific[:smooth_obj]`: current value of the smooth part of the objective function;
   - `stats.solver_specific[:nonsmooth_obj]`: current value of the nonsmooth part of the objective function.
 """
-mutable struct ALSolver{T,V,M,Pb,ST} <: AbstractOptimizationSolver
+mutable struct ALSolver{T, V, M, Pb, ST} <: AbstractOptimizationSolver
   x::V
   cx::V
   y::V
   has_bnds::Bool
   sub_problem::Pb
   sub_solver::ST
-  sub_stats::GenericExecutionStats{T,V,V,T}
+  sub_stats::GenericExecutionStats{T, V, V, T}
 end
 
-function ALSolver(reg_nlp::AbstractRegularizedNLPModel{T,V}; kwargs...) where {T,V}
+function ALSolver(reg_nlp::AbstractRegularizedNLPModel{T, V}; kwargs...) where {T, V}
   nlp = reg_nlp.model
   nvar, ncon = nlp.meta.nvar, nlp.meta.ncon
   x = V(undef, nvar)
@@ -163,7 +163,7 @@ function ALSolver(reg_nlp::AbstractRegularizedNLPModel{T,V}; kwargs...) where {T
   sub_stats = RegularizedExecutionStats(sub_problem)
   M = typeof(nlp)
   ST = typeof(sub_solver)
-  return ALSolver{T,V,M,typeof(sub_problem),ST}(
+  return ALSolver{T, V, M, typeof(sub_problem), ST}(
     x,
     cx,
     y,
@@ -202,9 +202,9 @@ function SolverCore.solve!(
 end
 
 function SolverCore.solve!(
-  solver::ALSolver{T,V},
-  reg_nlp::AbstractRegularizedNLPModel{T,V},
-  stats::GenericExecutionStats{T,V};
+  solver::ALSolver{T, V},
+  reg_nlp::AbstractRegularizedNLPModel{T, V},
+  stats::GenericExecutionStats{T, V};
   callback = (args...) -> nothing,
   x::V = reg_nlp.model.meta.x0,
   y::V = reg_nlp.model.meta.y0,
@@ -223,7 +223,7 @@ function SolverCore.solve!(
   factor_primal_linear_improvement::T = T(3 // 4),
   factor_decrease_subtol::T = T(1 // 4),
   dual_safeguard = project_y!,
-) where {T,V}
+) where {T, V}
   reset!(stats)
 
   # Retrieve workspace

src/LMModel.jl

@@ -17,20 +17,20 @@ where `J` is the Jacobian of `F` at `xk`, represented via matrix-free operations
 `σ > 0` is a regularization parameter and `v` is a vector of the same size as `F(xk)` used for intermediary computations.
 """
 mutable struct LMModel{
-  T<:Real,
-  V<:AbstractVector{T},
-  Jac<:Union{AbstractMatrix,AbstractLinearOperator},
-} <: AbstractNLPModel{T,V}
+  T <: Real,
+  V <: AbstractVector{T},
+  Jac <: Union{AbstractMatrix, AbstractLinearOperator},
+} <: AbstractNLPModel{T, V}
   J::Jac
   F::V
   v::V
   xk::V
   σ::T
-  meta::NLPModelMeta{T,V}
+  meta::NLPModelMeta{T, V}
   counters::Counters
 end
 
-function LMModel(J::Jac, F::V, σ::T, xk::V) where {T,V,Jac}
+function LMModel(J::Jac, F::V, σ::T, xk::V) where {T, V, Jac}
   meta = NLPModelMeta(
     length(xk),
     x0 = xk, # Perhaps we should add lvar and uvar as well here.

src/LMTR_alg.jl

@@ -49,7 +49,7 @@ function LMTR(
   subsolver = R2,
   subsolver_options = ROSolverOptions(ϵa = options.ϵa),
   selected::AbstractVector{<:Integer} = 1:(nls.meta.nvar),
-) where {H,X}
+) where {H, X}
   start_time = time()
   elapsed_time = 0.0
   # initialize passed options

src/LM_alg.jl

@@ -3,11 +3,11 @@ export LM, LMSolver, solve!
 import SolverCore.solve!
 
 mutable struct LMSolver{
-  T<:Real,
-  G<:ShiftedProximableFunction,
-  V<:AbstractVector{T},
-  ST<:AbstractOptimizationSolver,
-  PB<:AbstractRegularizedNLPModel,
+  T <: Real,
+  G <: ShiftedProximableFunction,
+  V <: AbstractVector{T},
+  ST <: AbstractOptimizationSolver,
+  PB <: AbstractRegularizedNLPModel,
 } <: AbstractOptimizationSolver
   xk::V
   ∇fk::V
@@ -26,13 +26,13 @@ mutable struct LMSolver{
   u_bound_m_x::V
   subsolver::ST
   subpb::PB
-  substats::GenericExecutionStats{T,V,V,T}
+  substats::GenericExecutionStats{T, V, V, T}
 end
 
 function LMSolver(
-  reg_nls::AbstractRegularizedNLPModel{T,V};
+  reg_nls::AbstractRegularizedNLPModel{T, V};
   subsolver = R2Solver,
-) where {T,V}
+) where {T, V}
   x0 = reg_nls.model.meta.x0
   l_bound = reg_nls.model.meta.lvar
   u_bound = reg_nls.model.meta.uvar
@@ -67,7 +67,7 @@ function LMSolver(
   substats = RegularizedExecutionStats(subpb)
   subsolver = subsolver(subpb)
 
-  return LMSolver{T,typeof(ψ),V,typeof(subsolver),typeof(subpb)}(
+  return LMSolver{T, typeof(ψ), V, typeof(subsolver), typeof(subpb)}(
     xk,
     ∇fk,
     mν∇fk,
@@ -176,9 +176,9 @@ function LM(reg_nls::AbstractRegularizedNLPModel; kwargs...)
 end
 
 function SolverCore.solve!(
-  solver::LMSolver{T,G,V},
-  reg_nls::AbstractRegularizedNLPModel{T,V},
-  stats::GenericExecutionStats{T,V};
+  solver::LMSolver{T, G, V},
+  reg_nls::AbstractRegularizedNLPModel{T, V},
+  stats::GenericExecutionStats{T, V};
   callback = (args...) -> nothing,
   x::V = reg_nls.model.meta.x0,
   nonlinear::Bool = true,
@@ -195,7 +195,7 @@ function SolverCore.solve!(
   η2::T = T(0.9),
   γ::T = T(3),
   θ::T = 1/(1 + eps(T)^(1 / 5)),
-) where {T,V,G}
+) where {T, V, G}
   reset!(stats)
 
   # Retrieve workspace
@@ -243,7 +243,7 @@ function SolverCore.solve!(
     @info log_header(
       [:outer, :inner, :fx, :hx, :xi, :ρ, :σ, :normx, :norms, :normJ, :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/ν)",
@@ -364,7 +364,7 @@ function SolverCore.solve!(
           σk,
           norm(xk),
           norm(s),
-          1/ν,
+          1 / ν,
           (η2 ≤ ρk < Inf) ? '↘' : (ρk < η1 ? '↗' : '='),
         ],
         colsep = 1,
@@ -445,7 +445,7 @@ function SolverCore.solve!(
 
   if verbose > 0 && stats.status == :first_order
     @info log_row(
-      Any[stats.iter, 0, fk, hk, sqrt_ξ1_νInv, ρk, σk, norm(xk), norm(s), 1/ν, ""],
+      Any[stats.iter, 0, fk, hk, sqrt_ξ1_νInv, ρk, σk, norm(xk), norm(s), 1 / ν, ""],
       colsep = 1,
     )
     @info "LM: terminating with √(ξ1/ν) = $(sqrt_ξ1_νInv)"

src/R2DH.jl

@@ -3,10 +3,10 @@ export R2DH, R2DHSolver, solve!
 import SolverCore.solve!
 
 mutable struct R2DHSolver{
-  T<:Real,
-  G<:ShiftedProximableFunction,
-  V<:AbstractVector{T},
-  QN<:AbstractDiagonalQuasiNewtonOperator{T},
+  T <: Real,
+  G <: ShiftedProximableFunction,
+  V <: AbstractVector{T},
+  QN <: AbstractDiagonalQuasiNewtonOperator{T},
 } <: AbstractOptimizationSolver
   xk::V
   ∇fk::V
@@ -26,10 +26,10 @@ mutable struct R2DHSolver{
 end
 
 function R2DHSolver(
-  reg_nlp::AbstractRegularizedNLPModel{T,V};
+  reg_nlp::AbstractRegularizedNLPModel{T, V};
   m_monotone::Int = 6,
-  D::Union{Nothing,AbstractDiagonalQuasiNewtonOperator} = nothing,
-) where {T,V}
+  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
@@ -151,11 +151,11 @@ Notably, you can access, and modify, the following:
   - `stats.elapsed_time`: elapsed time in seconds.
 """
 function R2DH(
-  nlp::AbstractDiagonalQNModel{T,V},
+  nlp::AbstractDiagonalQNModel{T, V},
   h,
   options::ROSolverOptions{T};
   kwargs...,
-) where {T,V}
+) where {T, V}
   kwargs_dict = Dict(kwargs...)
   selected = pop!(kwargs_dict, :selected, 1:(nlp.meta.nvar))
   x0 = pop!(kwargs_dict, :x0, nlp.meta.x0)
@@ -188,7 +188,13 @@ function R2DH(
   x0::AbstractVector{R};
   selected::AbstractVector{<:Integer} = 1:length(x0),
   kwargs...,
-) where {F<:Function,G<:Function,H,R<:Real,DQN<:AbstractDiagonalQuasiNewtonOperator}
+) where {
+  F <: Function,
+  G <: Function,
+  H,
+  R <: Real,
+  DQN <: AbstractDiagonalQuasiNewtonOperator,
+}
   nlp = FirstOrderModel(f, ∇f!, x0)
   reg_nlp = RegularizedNLPModel(nlp, h, selected)
   stats = R2DH(
@@ -213,7 +219,7 @@ function R2DH(
   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)
@@ -225,8 +231,8 @@ end
 
 function SolverCore.solve!(
   solver::R2DHSolver{T},
-  reg_nlp::AbstractRegularizedNLPModel{T,V},
-  stats::GenericExecutionStats{T,V};
+  reg_nlp::AbstractRegularizedNLPModel{T, V},
+  stats::GenericExecutionStats{T, V};
   callback = (args...) -> nothing,
   x::V = reg_nlp.model.meta.x0,
   atol::T = √eps(T),
@@ -242,7 +248,7 @@ function SolverCore.solve!(
   η2::T = T(0.9),
   γ::T = T(3),
   θ::T = 1/(1 + eps(T)^(1 / 5)),
-) where {T,V}
+) where {T, V}
   reset!(stats)
 
   # Retrieve workspace
@@ -292,7 +298,7 @@ function SolverCore.solve!(
     @info log_header(
       [:iter, :fx, :hx, :xi, :ρ, :σ, :normx, :norms, :arrow],
       [Int, T, T, T, T, T, T, T, Char],
-      hdr_override = Dict{Symbol,String}(   # TODO: Add this as constant dict elsewhere
+      hdr_override = Dict{Symbol, String}(   # TODO: Add this as constant dict elsewhere
         :fx => "f(x)",
         :hx => "h(x)",
         :xi => "√(ξ/ν)",
@@ -328,7 +334,7 @@ function SolverCore.solve!(
   set_solver_specific!(stats, :nonsmooth_obj, hk)
   set_solver_specific!(stats, :sigma, σk)
   set_solver_specific!(stats, :sigma_cauchy, 1/ν₁)
-  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)
@@ -437,7 +443,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)