🤖 Format .jl files (#67)

Co-authored-by: tmigot <[email protected]>

Author: github-actions[bot]

docs/make.jl

@@ -5,21 +5,21 @@ using Printf
 using AdaptiveRegularization
 
 pages = [
-    "Introduction" => "index.md",
-    "Tutorial" => "benchmark.md",
-    "Do it yourself" => "doityourself.md",
-    "Reference" => "reference.md",
+  "Introduction" => "index.md",
+  "Tutorial" => "benchmark.md",
+  "Do it yourself" => "doityourself.md",
+  "Reference" => "reference.md",
 ]
 
 makedocs(
-    sitename = "AdaptiveRegularization.jl",
-    format = Documenter.HTML(prettyurls = get(ENV, "CI", nothing) == "true"),
-    modules = [AdaptiveRegularization],
-    pages = pages,
+  sitename = "AdaptiveRegularization.jl",
+  format = Documenter.HTML(prettyurls = get(ENV, "CI", nothing) == "true"),
+  modules = [AdaptiveRegularization],
+  pages = pages,
 )
 
 deploydocs(
-    repo = "github.com/JuliaSmoothOptimizers/AdaptiveRegularization.jl.git",
-    push_preview = true,
-    devbranch = "main",
+  repo = "github.com/JuliaSmoothOptimizers/AdaptiveRegularization.jl.git",
+  push_preview = true,
+  devbranch = "main",
 )

src/AdaptiveRegularization.jl

@@ -14,15 +14,15 @@ include("./utils/utils.jl")
 include("./utils/increase_decrease.jl")
 
 path = joinpath(dirname(@__FILE__), "SolveModel")
-files = filter(x -> x[(end-2):end] == ".jl", readdir(path))
+files = filter(x -> x[(end - 2):end] == ".jl", readdir(path))
 for file in files
-    include("SolveModel/" * file)
+  include("SolveModel/" * file)
 end
 
 path = joinpath(dirname(@__FILE__), "PreProcess")
-files = filter(x -> x[(end-2):end] == ".jl", readdir(path))
+files = filter(x -> x[(end - 2):end] == ".jl", readdir(path))
 for file in files
-    include("PreProcess/" * file)
+  include("PreProcess/" * file)
 end
 
 include("main.jl")
@@ -88,39 +88,34 @@ stats = TRARC(nlp)
 """
 function TRARC end
 
-function TRARC(nlp::AbstractNLPModel{T,S}; kwargs...) where {T,S}
-    nlpstop = NLPStopping(nlp; optimality_check = (pb, state) -> norm(state.gx), kwargs...)
-    nlpstop = TRARC(nlpstop; kwargs...)
-    return stopping_to_stats(nlpstop)
+function TRARC(nlp::AbstractNLPModel{T, S}; kwargs...) where {T, S}
+  nlpstop = NLPStopping(nlp; optimality_check = (pb, state) -> norm(state.gx), kwargs...)
+  nlpstop = TRARC(nlpstop; kwargs...)
+  return stopping_to_stats(nlpstop)
 end
 
 for fun in union(keys(solvers_const), keys(solvers_nls_const))
-
-    ht, pt, sm, ka = merge(solvers_const, solvers_nls_const)[fun]
-    @eval begin
-        function $fun(nlpstop::NLPStopping; kwargs...)
-            kw_list = Dict{Symbol,Any}()
-            if $ka != ()
-                for t in $ka
-                    push!(kw_list, t)
-                end
-            end
-            merge!(kw_list, Dict(kwargs))
-            TRARC(nlpstop; hess_type = $ht, pdata_type = $pt, solve_model = $sm, kw_list...)
+  ht, pt, sm, ka = merge(solvers_const, solvers_nls_const)[fun]
+  @eval begin
+    function $fun(nlpstop::NLPStopping; kwargs...)
+      kw_list = Dict{Symbol, Any}()
+      if $ka != ()
+        for t in $ka
+          push!(kw_list, t)
         end
+      end
+      merge!(kw_list, Dict(kwargs))
+      TRARC(nlpstop; hess_type = $ht, pdata_type = $pt, solve_model = $sm, kw_list...)
     end
-    @eval begin
-        function $fun(nlp::AbstractNLPModel{T,S}; kwargs...) where {T,S}
-            nlpstop = NLPStopping(
-                nlp;
-                optimality_check = (pb, state) -> norm(state.gx),
-                kwargs...,
-            )
-            nlpstop = $fun(nlpstop; kwargs...)
-            return stopping_to_stats(nlpstop)
-        end
+  end
+  @eval begin
+    function $fun(nlp::AbstractNLPModel{T, S}; kwargs...) where {T, S}
+      nlpstop = NLPStopping(nlp; optimality_check = (pb, state) -> norm(state.gx), kwargs...)
+      nlpstop = $fun(nlpstop; kwargs...)
+      return stopping_to_stats(nlpstop)
     end
-    @eval export $fun
+  end
+  @eval export $fun
 end
 
 end # module

src/PreProcess/PreProcessKARC.jl

@@ -1,45 +1,45 @@
 function preprocess(PData::PDataKARC, Hop, g, gNorm2, calls, max_calls, α)
-    ζ, ξ, maxtol, mintol = PData.ζ, PData.ξ, PData.maxtol, PData.mintol
-    nshifts = PData.nshifts
-    shifts = PData.shifts
+  ζ, ξ, maxtol, mintol = PData.ζ, PData.ξ, PData.maxtol, PData.mintol
+  nshifts = PData.nshifts
+  shifts = PData.shifts
 
-    n = length(g)
-    # Tolerance used in Assumption 2.6b in the paper ( ξ > 0, 0 < ζ ≤ 1 )
-    atol = PData.cgatol(ζ, ξ, maxtol, mintol, gNorm2)
-    rtol = PData.cgrtol(ζ, ξ, maxtol, mintol, gNorm2)
+  n = length(g)
+  # Tolerance used in Assumption 2.6b in the paper ( ξ > 0, 0 < ζ ≤ 1 )
+  atol = PData.cgatol(ζ, ξ, maxtol, mintol, gNorm2)
+  rtol = PData.cgrtol(ζ, ξ, maxtol, mintol, gNorm2)
 
-    nshifts = length(shifts)
-    cb = (slv) -> begin
-        for i = 1:length(shifts)
-            if !slv.not_cv[i] && (norm(slv.x[i]) / shifts[i] - α > 0)
-                return true
-            end
-        end
-        return false
+  nshifts = length(shifts)
+  cb = (slv) -> begin
+    for i = 1:length(shifts)
+      if !slv.not_cv[i] && (norm(slv.x[i]) / shifts[i] - α > 0)
+        return true
+      end
     end
-    solver = PData.solver
-    cg_lanczos_shift!(
-        solver,
-        Hop,
-        g,
-        shifts,
-        itmax = min(max_calls - sum(calls), 2 * n),
-        atol = atol,
-        rtol = rtol,
-        verbose = 0,
-        check_curvature = true,
-        callback = cb,
-    )
+    return false
+  end
+  solver = PData.solver
+  cg_lanczos_shift!(
+    solver,
+    Hop,
+    g,
+    shifts,
+    itmax = min(max_calls - sum(calls), 2 * n),
+    atol = atol,
+    rtol = rtol,
+    verbose = 0,
+    check_curvature = true,
+    callback = cb,
+  )
 
-    PData.indmin = 0
-    PData.positives .= solver.converged
-    for i = 1:nshifts
-        PData.xShift[i] .= .-solver.x[i]
-        PData.norm_dirs[i] = norm(solver.x[i]) # Get it from cg_lanczos?
-    end
-    PData.shifts .= shifts
-    PData.nshifts = nshifts
-    PData.OK = sum(solver.converged) != 0 # at least one system was solved
+  PData.indmin = 0
+  PData.positives .= solver.converged
+  for i = 1:nshifts
+    PData.xShift[i] .= .-solver.x[i]
+    PData.norm_dirs[i] = norm(solver.x[i]) # Get it from cg_lanczos?
+  end
+  PData.shifts .= shifts
+  PData.nshifts = nshifts
+  PData.OK = sum(solver.converged) != 0 # at least one system was solved
 
-    return PData
+  return PData
 end

src/PreProcess/PreProcessTRK.jl

@@ -1,50 +1,50 @@
 function preprocess(PData::PDataTRK, Hop, g, gNorm2, calls, max_calls, α)
-    ζ, ξ, maxtol, mintol = PData.ζ, PData.ξ, PData.maxtol, PData.mintol
-    nshifts = PData.nshifts
-    shifts = PData.shifts
+  ζ, ξ, maxtol, mintol = PData.ζ, PData.ξ, PData.maxtol, PData.mintol
+  nshifts = PData.nshifts
+  shifts = PData.shifts
 
-    n = length(g)
-    # Tolerance used in Assumption 2.6b in the paper ( ξ > 0, 0 < ζ ≤ 1 )
-    cgatol = PData.cgatol(ζ, ξ, maxtol, mintol, gNorm2)
-    cgrtol = PData.cgrtol(ζ, ξ, maxtol, mintol, gNorm2)
+  n = length(g)
+  # Tolerance used in Assumption 2.6b in the paper ( ξ > 0, 0 < ζ ≤ 1 )
+  cgatol = PData.cgatol(ζ, ξ, maxtol, mintol, gNorm2)
+  cgrtol = PData.cgrtol(ζ, ξ, maxtol, mintol, gNorm2)
 
-    nshifts = length(shifts)
-    solver = PData.solver
+  nshifts = length(shifts)
+  solver = PData.solver
 
-    cb = (slv) -> begin
-        if slv.converged[1]
-            return norm(slv.x[1]) ≤ α
-        else
-            for i = 1:length(shifts)
-                if !slv.not_cv[i] && (norm(slv.x[i]) - α > 0)
-                    return true
-                end
-            end
+  cb = (slv) -> begin
+    if slv.converged[1]
+      return norm(slv.x[1]) ≤ α
+    else
+      for i = 1:length(shifts)
+        if !slv.not_cv[i] && (norm(slv.x[i]) - α > 0)
+          return true
         end
-        return false
+      end
     end
-    cg_lanczos_shift!(
-        solver,
-        Hop,
-        g,
-        shifts,
-        itmax = min(max_calls - sum(calls), 2 * n),
-        atol = cgatol,
-        rtol = cgrtol,
-        verbose = 0,
-        check_curvature = true,
-        callback = cb,
-    )
+    return false
+  end
+  cg_lanczos_shift!(
+    solver,
+    Hop,
+    g,
+    shifts,
+    itmax = min(max_calls - sum(calls), 2 * n),
+    atol = cgatol,
+    rtol = cgrtol,
+    verbose = 0,
+    check_curvature = true,
+    callback = cb,
+  )
 
-    PData.indmin = 0
-    PData.positives .= solver.converged
-    for i = 1:nshifts
-        @. PData.xShift[i] = -solver.x[i]
-        PData.norm_dirs[i] = norm(solver.x[i]) # Get it from cg_lanczos?
-    end
-    PData.shifts .= shifts
-    PData.nshifts = nshifts
-    PData.OK = sum(solver.converged) != 0 # at least one system was solved
+  PData.indmin = 0
+  PData.positives .= solver.converged
+  for i = 1:nshifts
+    @. PData.xShift[i] = -solver.x[i]
+    PData.norm_dirs[i] = norm(solver.x[i]) # Get it from cg_lanczos?
+  end
+  PData.shifts .= shifts
+  PData.nshifts = nshifts
+  PData.OK = sum(solver.converged) != 0 # at least one system was solved
 
-    return PData
+  return PData
 end

src/SolveModel/SolveModelKARC.jl

@@ -1,23 +1,23 @@
 function solve_modelKARC(X::PDataKARC, H, g, gNorm2, calls, max_calls, α::T) where {T}
-    # target value should be close to satisfy αλ=||d||
-    start = findfirst(X.positives)
-    if isnothing(start)
-        start = 1
-    end
-    if VERSION < v"1.7.0"
-        positives = collect(start:length(X.positives))
-        target = [(abs(α * X.shifts[i] - X.norm_dirs[i])) for i in positives]
-    else
-        positives = start:length(X.positives)
-        target = ((abs(α * X.shifts[i] - X.norm_dirs[i])) for i in positives)
-    end
+  # target value should be close to satisfy αλ=||d||
+  start = findfirst(X.positives)
+  if isnothing(start)
+    start = 1
+  end
+  if VERSION < v"1.7.0"
+    positives = collect(start:length(X.positives))
+    target = [(abs(α * X.shifts[i] - X.norm_dirs[i])) for i in positives]
+  else
+    positives = start:length(X.positives)
+    target = ((abs(α * X.shifts[i] - X.norm_dirs[i])) for i in positives)
+  end
 
-    # pick the closest shift to the target within positive definite H+λI
-    indmin = argmin(target)
-    X.indmin = start + indmin - 1
-    p_imin = X.indmin
-    X.d .= X.xShift[p_imin]
-    X.λ = X.shifts[p_imin]
+  # pick the closest shift to the target within positive definite H+λI
+  indmin = argmin(target)
+  X.indmin = start + indmin - 1
+  p_imin = X.indmin
+  X.d .= X.xShift[p_imin]
+  X.λ = X.shifts[p_imin]
 
-    return X.d, X.λ
+  return X.d, X.λ
 end

src/SolveModel/SolveModelNLSST_TR.jl

@@ -1,37 +1,29 @@
-function solve_modelNLSST_TR(
-    PData::PDataNLSST,
-    Jx,
-    Fx,
-    norm_∇f,
-    calls,
-    max_calls,
-    δ::T,
-) where {T}
-    # cas particulier Steihaug-Toint
-    # ϵ = sqrt(eps(T)) # * 100.0 # old
-    # cgtol = max(ϵ, min(cgtol, 9 * cgtol / 10, 0.01 * norm(g)^(1.0 + PData.ζ))) # old
+function solve_modelNLSST_TR(PData::PDataNLSST, Jx, Fx, norm_∇f, calls, max_calls, δ::T) where {T}
+  # cas particulier Steihaug-Toint
+  # ϵ = sqrt(eps(T)) # * 100.0 # old
+  # cgtol = max(ϵ, min(cgtol, 9 * cgtol / 10, 0.01 * norm(g)^(1.0 + PData.ζ))) # old
 
-    ζ, ξ, maxtol, mintol = PData.ζ, PData.ξ, PData.maxtol, PData.mintol
-    n = length(Fx)
-    # precision = max(1e-12, min(0.5, (norm_∇f^ζ)))
-    # Tolerance used in Assumption 2.6b in the paper ( ξ > 0, 0 < ζ ≤ 1 )
-    cgatol = PData.cgatol(ζ, ξ, maxtol, mintol, norm_∇f)
-    cgrtol = PData.cgrtol(ζ, ξ, maxtol, mintol, norm_∇f)
+  ζ, ξ, maxtol, mintol = PData.ζ, PData.ξ, PData.maxtol, PData.mintol
+  n = length(Fx)
+  # precision = max(1e-12, min(0.5, (norm_∇f^ζ)))
+  # Tolerance used in Assumption 2.6b in the paper ( ξ > 0, 0 < ζ ≤ 1 )
+  cgatol = PData.cgatol(ζ, ξ, maxtol, mintol, norm_∇f)
+  cgrtol = PData.cgrtol(ζ, ξ, maxtol, mintol, norm_∇f)
 
-    solver = PData.solver
-    Krylov.solve!(
-        solver,
-        Jx,
-        Fx,
-        atol = cgatol,
-        rtol = cgrtol,
-        radius = δ,
-        itmax = min(max_calls - sum(calls), max(2 * n, 50)),
-        verbose = 0,
-    )
+  solver = PData.solver
+  Krylov.solve!(
+    solver,
+    Jx,
+    Fx,
+    atol = cgatol,
+    rtol = cgrtol,
+    radius = δ,
+    itmax = min(max_calls - sum(calls), max(2 * n, 50)),
+    verbose = 0,
+  )
 
-    @. PData.d = -solver.x
-    PData.OK = solver.stats.solved
+  @. PData.d = -solver.x
+  PData.OK = solver.stats.solved
 
-    return PData.d, PData.λ
+  return PData.d, PData.λ
 end