Format using JuliaFormatter

Author: abelsiqueira

.JuliaFormatter.toml

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

docs/make.jl

@@ -5,15 +5,16 @@ makedocs(
   doctest = true,
   linkcheck = true,
   strict = true,
-  format = Documenter.HTML(assets = ["assets/style.css"], prettyurls = get(ENV, "CI", nothing) == "true"),
+  format = Documenter.HTML(
+    assets = ["assets/style.css"],
+    prettyurls = get(ENV, "CI", nothing) == "true",
+  ),
   sitename = "SolverCore.jl",
-  pages = ["Home" => "index.md",
-           "Reference" => "reference.md",
-          ]
+  pages = ["Home" => "index.md", "Reference" => "reference.md"],
 )
 
 deploydocs(
   repo = "github.com/JuliaSmoothOptimizers/SolverCore.jl.git",
   push_preview = true,
-  devbranch = "master"
+  devbranch = "master",
 )

solver-example.jl

@@ -8,7 +8,7 @@ nlp = ADNLPModel(
   [-1.2; 1.0],
   x -> [x[1]^2 + x[2]^2 - 1],
   [0.0],
-  [0.0]
+  [0.0],
 )
 solver = DummySolver(Float16, nlp.meta)
 output = solve!(solver, nlp, δ = 1e-2)
@@ -26,6 +26,12 @@ output, solver = DummySolver(nlp)
 #%%
 include("test/dummy_solver.jl")
 problems = (
-  ADNLPModel(x -> (x[1] - a)^2 + b^2 * (x[2] - x[1]^2)^2, [-1.2; 1.0], x -> [x[1]^2 + x[2]^2 - 1], [0.0], [0.0]) for a = 0:0.1:1, b = 2:3
+  ADNLPModel(
+    x -> (x[1] - a)^2 + b^2 * (x[2] - x[1]^2)^2,
+    [-1.2; 1.0],
+    x -> [x[1]^2 + x[2]^2 - 1],
+    [0.0],
+    [0.0],
+  ) for a = 0:0.1:1, b = 2:3
 )
-o = grid_search_tune(DummySolver, problems)
+o = grid_search_tune(DummySolver, problems)

src/SolverCore.jl

@@ -7,6 +7,7 @@ using OrderedCollections
 include("solver.jl")
 include("output.jl")
 
+include("logger.jl")
 include("parameters.jl")
 include("traits.jl")
 

src/grid-search-tuning.jl

@@ -34,18 +34,14 @@ function grid_search_tune(
   ::Type{Solver},
   problems;
   success = o -> o.status == :first_order,
-  costs = [
-    (o -> o.elapsed_time, 100.0),
-    (o -> !success(o), 1),
-  ],
+  costs = [(o -> o.elapsed_time, 100.0), (o -> !success(o), 1)],
   grid_length = 10,
   solver_kwargs = Dict(),
-  kwargs...
-) where Solver <: AbstractSolver
-
+  kwargs...,
+) where {Solver <: AbstractSolver}
   solver_params = parameters(Solver)
   params = OrderedDict()
-  for (k,v) in pairs(solver_params)
+  for (k, v) in pairs(solver_params)
     if v[:type] <: AbstractFloat && (!haskey(v, :scale) || v[:scale] == :linear)
       params[k] = LinRange(v[:min], v[:max], grid_length)
     elseif v[:type] <: AbstractFloat && v[:scale] == :log
@@ -56,7 +52,7 @@ function grid_search_tune(
       params[k] = v[:min]:v[:max]
     end
   end
-  for (k,v) in kwargs
+  for (k, v) in kwargs
     params[k] = v
   end
 
@@ -77,7 +73,7 @@ function grid_search_tune(
       reset!(problem)
       try
         solver = Solver(problem)
-        P = (k => θi for (k,θi) in zip(keys(solver_params), θ))
+        P = (k => θi for (k, θi) in zip(keys(solver_params), θ))
         output = with_logger(NullLogger()) do
           solve!(solver, problem; P...)
         end
@@ -101,4 +97,4 @@ function grid_search_tune(
   end
 
   [θ => cost(θ) for θ in Iterators.product(values(params)...)]
-end
+end

src/logger.jl

@@ -1,29 +1,32 @@
 export log_header, log_row
 
-const formats = Dict{DataType, String}(Signed => "%6d",
-                                       AbstractFloat => "%8.1e",
-                                       AbstractString => "%15s",
-                                       Symbol => "%15s",
-                                       Missing => "%15s"
-                                      )
-
-const default_headers = Dict{Symbol, String}(:name => "Name",
-                                             :elapsed_time => "Time",
-                                             :objective => "f(x)",
-                                             :dual_feas => "Dual",
-                                             :primal_feas => "Primal")
+const formats = Dict{DataType, String}(
+  Signed => "%6d",
+  AbstractFloat => "%8.1e",
+  AbstractString => "%15s",
+  Symbol => "%15s",
+  Missing => "%15s",
+)
+
+const default_headers = Dict{Symbol, String}(
+  :name => "Name",
+  :elapsed_time => "Time",
+  :objective => "f(x)",
+  :dual_feas => "Dual",
+  :primal_feas => "Primal",
+)
 
 for (typ, fmt) in formats
   hdr_fmt_foo = Symbol("header_formatter_$typ")
   len = match(r"\%([0-9]*)", fmt)[1]
   fmt2 = "%$(len)s"
 
   @eval begin
-    row_formatter(x :: $typ) = @sprintf($fmt, x)
-    row_formatter(:: Type{<:$typ}) = @sprintf($fmt2, "-")
+    row_formatter(x::$typ) = @sprintf($fmt, x)
+    row_formatter(::Type{<:$typ}) = @sprintf($fmt2, "-")
 
     $hdr_fmt_foo(x) = @sprintf($fmt2, x)
-    header_formatter(x :: Union{Symbol,String}, :: Type{<:$typ}) = $hdr_fmt_foo(x)
+    header_formatter(x::Union{Symbol, String}, ::Type{<:$typ}) = $hdr_fmt_foo(x)
   end
 end
 
@@ -44,10 +47,12 @@ Keyword arguments:
 
 See also [`log_row`](@ref).
 """
-function log_header(colnames :: AbstractVector{Symbol}, coltypes :: AbstractVector{DataType};
-                    hdr_override :: Dict{Symbol,String} = Dict{Symbol,String}(),
-                    colsep :: Int = 2,
-                   )
+function log_header(
+  colnames::AbstractVector{Symbol},
+  coltypes::AbstractVector{DataType};
+  hdr_override::Dict{Symbol, String} = Dict{Symbol, String}(),
+  colsep::Int = 2,
+)
   out_vec = String[]
   for (name, typ) in zip(colnames, coltypes)
     x = if haskey(hdr_override, name)
@@ -59,7 +64,7 @@ function log_header(colnames :: AbstractVector{Symbol}, coltypes :: AbstractVect
     end
     push!(out_vec, header_formatter(x, typ))
   end
-  return join(out_vec,  " "^colsep)
+  return join(out_vec, " "^colsep)
 end
 
 """
@@ -82,7 +87,7 @@ Prints
 Keyword arguments:
 - `colsep::Int`: Number of spaces between columns (Default: 2)
 """
-function log_row(vals; colsep :: Int = 2)
+function log_row(vals; colsep::Int = 2)
   string_cols = (row_formatter(val) for val in vals)
   return join(string_cols, " "^colsep)
 end

src/output.jl

@@ -13,24 +13,24 @@ abstract type AbstractSolverOutput{T} end
 
 # TODO: Decision: Should STATUSES be fixed? Should it be all here?
 const STATUSES = Dict(
-  :exception      => "unhandled exception",
-  :first_order    => "first-order stationary",
-  :acceptable     => "solved to within acceptable tolerances",
-  :infeasible     => "problem may be infeasible",
-  :max_eval       => "maximum number of function evaluations",
-  :max_iter       => "maximum iteration",
-  :max_time       => "maximum elapsed time",
-  :neg_pred       => "negative predicted reduction",
-  :not_desc       => "not a descent direction",
+  :exception => "unhandled exception",
+  :first_order => "first-order stationary",
+  :acceptable => "solved to within acceptable tolerances",
+  :infeasible => "problem may be infeasible",
+  :max_eval => "maximum number of function evaluations",
+  :max_iter => "maximum iteration",
+  :max_time => "maximum elapsed time",
+  :neg_pred => "negative predicted reduction",
+  :not_desc => "not a descent direction",
   :small_residual => "small residual",
-  :small_step     => "step too small",
-  :stalled        => "stalled",
-  :unbounded      => "objective function may be unbounded from below",
-  :unknown        => "unknown",
-  :user           => "user-requested stop",
+  :small_step => "step too small",
+  :stalled => "stalled",
+  :unbounded => "objective function may be unbounded from below",
+  :unknown => "unknown",
+  :user => "user-requested stop",
 )
 
-function Base.show(io :: IO, output :: AbstractSolverOutput)
+function Base.show(io::IO, output::AbstractSolverOutput)
   println(io, "Solver output of type $(typeof(output))")
   println(io, "Status: $(STATUSES[output.status])")
-end
+end

src/parameters.jl

@@ -27,8 +27,8 @@ Solvers should define
 """
 function parameters end
 
-parameters(::Type{S}) where S <: AbstractSolver = parameters(S{Float64})
-parameters(::S) where S <: AbstractSolver = parameters(S)
+parameters(::Type{S}) where {S <: AbstractSolver} = parameters(S{Float64})
+parameters(::S) where {S <: AbstractSolver} = parameters(S)
 
 """
     are_valid_parameters(solver, args...)
@@ -41,5 +41,6 @@ Solvers should define
     SolverCore.are_valid_parameters(::Type{Solver{T}}, arg1, arg2, ...) where T
 """
 function are_valid_parameters end
-are_valid_parameters(::Type{S}, args...) where S <: AbstractSolver = are_valid_parameters(S{Float64}, args...)
-are_valid_parameters(::S, args...) where S <: AbstractSolver = are_valid_parameters(S, args...)
+are_valid_parameters(::Type{S}, args...) where {S <: AbstractSolver} =
+  are_valid_parameters(S{Float64}, args...)
+are_valid_parameters(::S, args...) where {S <: AbstractSolver} = are_valid_parameters(S, args...)

src/solver.jl

@@ -12,7 +12,7 @@ A solver must have three members:
 """
 abstract type AbstractSolver{T} end
 
-function Base.show(io :: IO, solver :: AbstractSolver)
+function Base.show(io::IO, solver::AbstractSolver)
   println(io, "Solver $(typeof(solver))")
 end
 
@@ -23,4 +23,4 @@ Solve `problem` with `solver`.
 """
 function solve! end
 
-# TODO: Define general constructors that automatically call `solve!`, etc.?
+# TODO: Define general constructors that automatically call `solve!`, etc.?

src/traits.jl

@@ -14,6 +14,6 @@ problem_types_handled(::Type{<:AbstractSolver}) = []
 Check if the `solver` can solve problems of `type`.
 Call `problem_types_handled` for a list of problem types that the `solver` can solve.
 """
-function can_solve_type(::Type{S}, t :: Symbol) where S <: AbstractSolver
+function can_solve_type(::Type{S}, t::Symbol) where {S <: AbstractSolver}
   return t ∈ problem_types_handled(S)
 end