🤖 Format .jl files

Author: dpo

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 = "SolverTools.jl",
-  pages = ["Home" => "index.md",
-           "Reference" => "reference.md",
-          ]
+  pages = ["Home" => "index.md", "Reference" => "reference.md"],
 )
 
 deploydocs(
   repo = "github.com/JuliaSmoothOptimizers/SolverTools.jl.git",
   push_preview = true,
-  devbranch = "master"
+  devbranch = "master",
 )

src/auxiliary/blas.jl

@@ -4,26 +4,40 @@ import LinearAlgebra.BLAS: nrm2, blascopy!, axpy!, axpby!, scal!
 
 export dot, nrm2, blascopy!, axpy!, axpby!, scal!, copyaxpy!
 
-nrm2(n :: Int, x :: Vector{T}) where T <: BLAS.BlasReal = BLAS.nrm2(n, x, 1)
-nrm2(n :: Int, x :: AbstractVector{T}) where T <: Number = norm(x)
-
-dot(n :: Int, x :: Vector{T}, y :: Vector{T}) where T <: BLAS.BlasReal = BLAS.dot(n, x, 1, y, 1)
-dot(n :: Int, x :: AbstractVector{T}, y :: AbstractVector{T}) where T <: Number = dot(x, y)
-
-axpy!(n :: Int, t :: T, d :: Vector{T}, x :: Vector{T}) where T <: BLAS.BlasReal = BLAS.axpy!(n, t, d, 1, x, 1)
-axpy!(n :: Int, t :: T, d :: AbstractVector{T}, x :: AbstractVector{T}) where T <: Number = (x .+= t .* d)
-
-axpby!(n :: Int, t :: T, d :: Vector{T}, s :: T, x :: Vector{T}) where T <: BLAS.BlasReal = BLAS.axpby!(n, t, d, 1, s, x, 1)
-axpby!(n :: Int, t :: T, d :: AbstractVector{T}, s :: T, x :: AbstractVector{T}) where T <: Number = (x .= t .* d .+ s .* x)
-
-scal!(n :: Int, t :: T, x :: Vector{T}) where T <: BLAS.BlasReal = BLAS.scal!(n, t, x, 1)
-scal!(n :: Int, t :: T, x :: AbstractVector{T}) where T <: Number = (x .*= t)
-
-function copyaxpy!(n :: Int, t :: T, d :: Vector{T}, x :: Vector{T}, xt :: Vector{T}) where T <: BLAS.BlasReal
+nrm2(n::Int, x::Vector{T}) where {T <: BLAS.BlasReal} = BLAS.nrm2(n, x, 1)
+nrm2(n::Int, x::AbstractVector{T}) where {T <: Number} = norm(x)
+
+dot(n::Int, x::Vector{T}, y::Vector{T}) where {T <: BLAS.BlasReal} = BLAS.dot(n, x, 1, y, 1)
+dot(n::Int, x::AbstractVector{T}, y::AbstractVector{T}) where {T <: Number} = dot(x, y)
+
+axpy!(n::Int, t::T, d::Vector{T}, x::Vector{T}) where {T <: BLAS.BlasReal} =
+  BLAS.axpy!(n, t, d, 1, x, 1)
+axpy!(n::Int, t::T, d::AbstractVector{T}, x::AbstractVector{T}) where {T <: Number} = (x .+= t .* d)
+
+axpby!(n::Int, t::T, d::Vector{T}, s::T, x::Vector{T}) where {T <: BLAS.BlasReal} =
+  BLAS.axpby!(n, t, d, 1, s, x, 1)
+axpby!(n::Int, t::T, d::AbstractVector{T}, s::T, x::AbstractVector{T}) where {T <: Number} =
+  (x .= t .* d .+ s .* x)
+
+scal!(n::Int, t::T, x::Vector{T}) where {T <: BLAS.BlasReal} = BLAS.scal!(n, t, x, 1)
+scal!(n::Int, t::T, x::AbstractVector{T}) where {T <: Number} = (x .*= t)
+
+function copyaxpy!(
+  n::Int,
+  t::T,
+  d::Vector{T},
+  x::Vector{T},
+  xt::Vector{T},
+) where {T <: BLAS.BlasReal}
   BLAS.blascopy!(n, x, 1, xt, 1)
   BLAS.axpy!(n, t, d, 1, xt, 1)
 end
-function copyaxpy!(n :: Int, t :: T, d :: AbstractVector{T}, x :: AbstractVector{T}, xt :: AbstractVector{T}) where T <: Number
+function copyaxpy!(
+  n::Int,
+  t::T,
+  d::AbstractVector{T},
+  x::AbstractVector{T},
+  xt::AbstractVector{T},
+) where {T <: Number}
   xt .= x .+ t .* d
 end
-

src/auxiliary/bounds.jl

@@ -8,9 +8,13 @@ export active, breakpoints, compute_Hs_slope_qs!, project!, project_step!
 Computes the active bounds at x, using tolerance `min(rtol * (uᵢ-ℓᵢ), atol)`.
 If ℓᵢ or uᵢ is not finite, only `atol` is used.
 """
-function active(x::AbstractVector{T}, ℓ::AbstractVector{T},
-                u::AbstractVector{T}; rtol::Real = sqrt(eps(eltype(x))),
-                atol::Real = sqrt(eps(eltype(x)))) where {T <: Real}
+function active(
+  x::AbstractVector{T},
+  ℓ::AbstractVector{T},
+  u::AbstractVector{T};
+  rtol::Real = sqrt(eps(eltype(x))),
+  atol::Real = sqrt(eps(eltype(x))),
+) where {T <: Real}
   A = Int[]
   n = length(x)
   for i = 1:n
@@ -33,10 +37,14 @@ Find the smallest and largest values of `α` such that `x + αd` lies on the
 boundary. `x` is assumed to be feasible. `nbrk` is the number of breakpoints
 from `x` in the direction `d`.
 """
-function breakpoints(x::AbstractVector{T}, d::AbstractVector{T},
-                     ℓ::AbstractVector{T}, u::AbstractVector{T}) where {T <: Real}
-  pos = findall( (d .> 0) .& (x .< u) )
-  neg = findall( (d .< 0) .& (x .> ℓ) )
+function breakpoints(
+  x::AbstractVector{T},
+  d::AbstractVector{T},
+  ℓ::AbstractVector{T},
+  u::AbstractVector{T},
+) where {T <: Real}
+  pos = findall((d .> 0) .& (x .< u))
+  neg = findall((d .< 0) .& (x .> ℓ))
 
   nbrk = length(pos) + length(neg)
   nbrk == 0 && return 0, zero(T), zero(T)
@@ -65,10 +73,14 @@ Computes
     slope = dot(g,s)
     qs = ¹/₂sᵀHs + slope
 """
-function compute_Hs_slope_qs!(Hs::AbstractVector{T}, H::Union{AbstractMatrix,AbstractLinearOperator},
-                              s::AbstractVector{T}, g::AbstractVector{T}) where {T <: Real}
+function compute_Hs_slope_qs!(
+  Hs::AbstractVector{T},
+  H::Union{AbstractMatrix, AbstractLinearOperator},
+  s::AbstractVector{T},
+  g::AbstractVector{T},
+) where {T <: Real}
   Hs .= H * s
-  slope = dot(g,s)
+  slope = dot(g, s)
   qs = dot(s, Hs) / 2 + slope
   return slope, qs
 end
@@ -79,8 +91,12 @@ end
 Projects `x` into bounds `ℓ` and `u`, in the sense of
 `yᵢ = max(ℓᵢ, min(xᵢ, uᵢ))`.
 """
-function project!(y :: AbstractVector{T}, x :: AbstractVector{T},
-                  ℓ :: AbstractVector{T}, u :: AbstractVector{T}) where {T <: Real}
+function project!(
+  y::AbstractVector{T},
+  x::AbstractVector{T},
+  ℓ::AbstractVector{T},
+  u::AbstractVector{T},
+) where {T <: Real}
   y .= max.(ℓ, min.(x, u))
 end
 
@@ -89,9 +105,14 @@ end
 
 Computes the projected direction `y = P(x + α * d) - x`.
 """
-function project_step!(y::AbstractVector{T}, x::AbstractVector{T},
-                       d::AbstractVector{T}, ℓ::AbstractVector{T},
-                       u::AbstractVector{T}, α::Real = 1.0) where {T <: Real}
+function project_step!(
+  y::AbstractVector{T},
+  x::AbstractVector{T},
+  d::AbstractVector{T},
+  ℓ::AbstractVector{T},
+  u::AbstractVector{T},
+  α::Real = 1.0,
+) where {T <: Real}
   y .= x .+ α .* d
   project!(y, y, ℓ, u)
   y .-= x

src/linesearch/armijo_wolfe.jl

@@ -35,40 +35,42 @@ The following keyword arguments can be provided:
 - `bW_max`: maximum number of increases (default `5`);
 - `verbose`: whether to print information (default `false`).
 """
-function armijo_wolfe(h :: LineModel,
-                      h₀ :: T,
-                      slope :: T,
-                      g :: Array{T,1};
-                      t :: T=one(T),
-                      τ₀ :: T=max(T(1.0e-4), sqrt(eps(T))),
-                      τ₁ :: T=T(0.9999),
-                      bk_max :: Int=10,
-                      bW_max :: Int=5,
-                      verbose :: Bool=false) where T <: AbstractFloat
+function armijo_wolfe(
+  h::LineModel,
+  h₀::T,
+  slope::T,
+  g::Array{T, 1};
+  t::T = one(T),
+  τ₀::T = max(T(1.0e-4), sqrt(eps(T))),
+  τ₁::T = T(0.9999),
+  bk_max::Int = 10,
+  bW_max::Int = 5,
+  verbose::Bool = false,
+) where {T <: AbstractFloat}
 
   # Perform improved Armijo linesearch.
   nbk = 0
   nbW = 0
 
   # First try to increase t to satisfy loose Wolfe condition
   ht, slope_t = objgrad!(h, t, g)
-  while (slope_t < τ₁*slope) && (ht <= h₀ + τ₀ * t * slope) && (nbW < bW_max)
+  while (slope_t < τ₁ * slope) && (ht <= h₀ + τ₀ * t * slope) && (nbW < bW_max)
     t *= 5
     ht, slope_t = objgrad!(h, t, g)
     nbW += 1
   end
 
-  hgoal = h₀ + slope * t * τ₀;
+  hgoal = h₀ + slope * t * τ₀
   fact = -T(0.8)
-  ϵ = eps(T)^T(3/5)
+  ϵ = eps(T)^T(3 / 5)
 
   # Enrich Armijo's condition with Hager & Zhang numerical trick
   Armijo = (ht <= hgoal) || ((ht <= h₀ + ϵ * abs(h₀)) && (slope_t <= fact * slope))
   good_grad = true
   while !Armijo && (nbk < bk_max)
     t *= T(0.4)
     ht = obj(h, t)
-    hgoal = h₀ + slope * t * τ₀;
+    hgoal = h₀ + slope * t * τ₀
 
     # avoids unused grad! calls
     Armijo = false
@@ -86,7 +88,7 @@ function armijo_wolfe(h :: LineModel,
     nbk += 1
   end
 
-  verbose && @printf("  %4d %4d\n", nbk, nbW);
+  verbose && @printf("  %4d %4d\n", nbk, nbW)
 
   return (t, good_grad, ht, nbk, nbW)
 end

src/linesearch/line_model.jl

@@ -13,23 +13,23 @@ represents the function ϕ : R → R defined by
     ϕ(t) := f(x + td).
 """
 mutable struct LineModel <: AbstractNLPModel
-  meta :: NLPModelMeta
-  counters :: Counters
-  nlp :: AbstractNLPModel
-  x :: AbstractVector
-  d :: AbstractVector
+  meta::NLPModelMeta
+  counters::Counters
+  nlp::AbstractNLPModel
+  x::AbstractVector
+  d::AbstractVector
 end
 
-function LineModel(nlp :: AbstractNLPModel, x :: AbstractVector, d :: AbstractVector)
-  meta = NLPModelMeta(1, x0=zeros(eltype(x), 1), name="LineModel to $(nlp.meta.name))")
+function LineModel(nlp::AbstractNLPModel, x::AbstractVector, d::AbstractVector)
+  meta = NLPModelMeta(1, x0 = zeros(eltype(x), 1), name = "LineModel to $(nlp.meta.name))")
   return LineModel(meta, Counters(), nlp, x, d)
 end
 
 """`redirect!(ϕ, x, d)`
 
 Change the values of x and d of the LineModel ϕ, but retains the counters.
 """
-function redirect!(ϕ :: LineModel, x :: AbstractVector, d :: AbstractVector)
+function redirect!(ϕ::LineModel, x::AbstractVector, d::AbstractVector)
   ϕ.x, ϕ.d = x, d
   return ϕ
 end
@@ -38,7 +38,7 @@ end
 
     ϕ(t) := f(x + td).
 """
-function obj(f :: LineModel, t :: AbstractFloat)
+function obj(f::LineModel, t::AbstractFloat)
   NLPModels.increment!(f, :neval_obj)
   return obj(f.nlp, f.x + t * f.d)
 end
@@ -51,11 +51,11 @@ i.e.,
 
     ϕ'(t) = ∇f(x + td)ᵀd.
 """
-function grad(f :: LineModel, t :: AbstractFloat)
+function grad(f::LineModel, t::AbstractFloat)
   NLPModels.increment!(f, :neval_grad)
   return dot(grad(f.nlp, f.x + t * f.d), f.d)
 end
-derivative(f :: LineModel, t :: AbstractFloat) = grad(f, t)
+derivative(f::LineModel, t::AbstractFloat) = grad(f, t)
 
 """`grad!(f, t, g)` evaluates the first derivative of the `LineModel`
 
@@ -67,11 +67,11 @@ i.e.,
 
 The gradient ∇f(x + td) is stored in `g`.
 """
-function grad!(f :: LineModel, t :: AbstractFloat, g :: AbstractVector)
+function grad!(f::LineModel, t::AbstractFloat, g::AbstractVector)
   NLPModels.increment!(f, :neval_grad)
   return dot(grad!(f.nlp, f.x + t * f.d, g), f.d)
 end
-derivative!(f :: LineModel, t :: AbstractFloat, g :: AbstractVector) = grad!(f, t, g)
+derivative!(f::LineModel, t::AbstractFloat, g::AbstractVector) = grad!(f, t, g)
 
 """`objgrad!(f, t, g)` evaluates the objective and first derivative of the `LineModel`
 
@@ -83,7 +83,7 @@ and
 
 The gradient ∇f(x + td) is stored in `g`.
 """
-function objgrad!(f :: LineModel, t :: AbstractFloat, g :: AbstractVector)
+function objgrad!(f::LineModel, t::AbstractFloat, g::AbstractVector)
   NLPModels.increment!(f, :neval_obj)
   NLPModels.increment!(f, :neval_grad)
   fx, gx = objgrad!(f.nlp, f.x + t * f.d, g)
@@ -98,7 +98,7 @@ and
 
     ϕ'(t) = ∇f(x + td)ᵀd.
 """
-function objgrad(f :: LineModel, t :: AbstractFloat)
+function objgrad(f::LineModel, t::AbstractFloat)
   return obj(f, t), grad(f, t)
 end
 
@@ -110,7 +110,7 @@ i.e.,
 
     ϕ"(t) = dᵀ∇²f(x + td)d.
 """
-function hess(f :: LineModel, t :: AbstractFloat)
+function hess(f::LineModel, t::AbstractFloat)
   NLPModels.increment!(f, :neval_hess)
   return dot(f.d, hprod(f.nlp, f.x + t * f.d, f.d))
 end