Rename xtol, ftol to x_tol, f_tol

src/nlsolve/fixedpoint.jl

@@ -3,8 +3,8 @@
 function fixedpoint(f,
     initial_x::AbstractArray{T};
     method::Symbol = :anderson,
-    xtol::Real = zero(T),
-    ftol::Real = convert(T,1e-8),
+    x_tol::Real = zero(T),
+    f_tol::Real = convert(T,1e-8),
     iterations::Integer = 1_000,
     store_trace::Bool = false,
     show_trace::Bool = false,
@@ -32,7 +32,7 @@ function fixedpoint(f,
     end
 
     return nlsolve(dg,
-            initial_x, method = method, xtol = xtol, ftol = ftol,
+            initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
             iterations = iterations, store_trace = store_trace,
             show_trace = show_trace, extended_trace = extended_trace,
             linesearch = linesearch, factor = factor, autoscale = autoscale,

src/nlsolve/nlsolve.jl

@@ -1,8 +1,8 @@
 function nlsolve(df::TDF,
                  initial_x::AbstractArray{T};
                  method::Symbol = :trust_region,
-                 xtol::Real = zero(T),
-                 ftol::Real = convert(T,1e-8),
+                 x_tol::Real = zero(T),
+                 f_tol::Real = convert(T,1e-8),
                  iterations::Integer = 1_000,
                  store_trace::Bool = false,
                  show_trace::Bool = false,
@@ -20,17 +20,17 @@ function nlsolve(df::TDF,
         @printf "------   --------------   --------------\n"
     end
     if method == :newton
-        newton(df, initial_x, xtol, ftol, iterations,
+        newton(df, initial_x, x_tol, f_tol, iterations,
                store_trace, show_trace, extended_trace, linesearch; linsolve=linsolve)
     elseif method == :trust_region
-        trust_region(df, initial_x, xtol, ftol, iterations,
+        trust_region(df, initial_x, x_tol, f_tol, iterations,
                      store_trace, show_trace, extended_trace, factor,
                      autoscale)
     elseif method == :anderson
-        anderson(df, initial_x, xtol, ftol, iterations,
+        anderson(df, initial_x, x_tol, f_tol, iterations,
                  store_trace, show_trace, extended_trace, m, beta, aa_start, droptol)
     elseif method == :broyden
-        broyden(df, initial_x, xtol, ftol, iterations,
+        broyden(df, initial_x, x_tol, f_tol, iterations,
                 store_trace, show_trace, extended_trace, linesearch)
     else
         throw(ArgumentError("Unknown method $method"))
@@ -40,8 +40,8 @@ end
 function nlsolve(f,
                  initial_x::AbstractArray{T};
                  method::Symbol = :trust_region,
-                 xtol::Real = zero(T),
-                 ftol::Real = convert(T,1e-8),
+                 x_tol::Real = zero(T),
+                 f_tol::Real = convert(T,1e-8),
                  iterations::Integer = 1_000,
                  store_trace::Bool = false,
                  show_trace::Bool = false,
@@ -71,7 +71,7 @@ function nlsolve(f,
     end
 
     nlsolve(df,
-            initial_x, method = method, xtol = xtol, ftol = ftol,
+            initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
             iterations = iterations, store_trace = store_trace,
             show_trace = show_trace, extended_trace = extended_trace,
             linesearch = linesearch, factor = factor, autoscale = autoscale,
@@ -83,8 +83,8 @@ function nlsolve(f,
                 j,
                 initial_x::AbstractArray{T};
                 method::Symbol = :trust_region,
-                xtol::Real = zero(T),
-                ftol::Real = convert(T, 1e-8),
+                x_tol::Real = zero(T),
+                f_tol::Real = convert(T, 1e-8),
                 iterations::Integer = 1_000,
                 store_trace::Bool = false,
                 show_trace::Bool = false,
@@ -104,7 +104,7 @@ function nlsolve(f,
         df = OnceDifferentiable(not_in_place(f, j)..., initial_x, similar(initial_x))
     end
     nlsolve(df,
-    initial_x, method = method, xtol = xtol, ftol = ftol,
+    initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
     iterations = iterations, store_trace = store_trace,
     show_trace = show_trace, extended_trace = extended_trace,
     linesearch = linesearch, factor = factor, autoscale = autoscale,
@@ -116,8 +116,8 @@ function nlsolve(f,
                 fj,
                 initial_x::AbstractArray{T};
                 method::Symbol = :trust_region,
-                xtol::Real = zero(T),
-                ftol::Real = convert(T, 1e-8),
+                x_tol::Real = zero(T),
+                f_tol::Real = convert(T, 1e-8),
                 iterations::Integer = 1_000,
                 store_trace::Bool = false,
                 show_trace::Bool = false,
@@ -137,7 +137,7 @@ function nlsolve(f,
         df = OnceDifferentiable(not_in_place(f, j, fj)..., initial_x, similar(initial_x))
     end
     nlsolve(df,
-    initial_x, method = method, xtol = xtol, ftol = ftol,
+    initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
     iterations = iterations, store_trace = store_trace,
     show_trace = show_trace, extended_trace = extended_trace,
     linesearch = linesearch, factor = factor, autoscale = autoscale,

src/nlsolve/solver_state_results.jl

@@ -72,9 +72,9 @@ mutable struct SolverResults{T,I<:AbstractArray{T},Z<:AbstractArray{T}}
     residual_norm::T
     iterations::Int
     x_converged::Bool
-    xtol::T
+    x_tol::T
     f_converged::Bool
-    ftol::T
+    f_tol::T
     trace::SolverTrace
     f_calls::Int
     g_calls::Int
@@ -92,8 +92,8 @@ function Base.show(io::IO, r::SolverResults)
     @printf io " * Inf-norm of residuals: %f\n" r.residual_norm
     @printf io " * Iterations: %d\n" r.iterations
     @printf io " * Convergence: %s\n" converged(r)
-    @printf io "   * |x - x'| < %.1e: %s\n" r.xtol r.x_converged
-    @printf io "   * |f(x)| < %.1e: %s\n" r.ftol r.f_converged
+    @printf io "   * |x - x'| < %.1e: %s\n" r.x_tol r.x_converged
+    @printf io "   * |f(x)| < %.1e: %s\n" r.f_tol r.f_converged
     @printf io " * Function Calls (f): %d\n" r.f_calls
     @printf io " * Jacobian Calls (df/dx): %d" r.g_calls
     return

src/nlsolve/utils.jl

@@ -8,19 +8,19 @@ function wdot(wx::AbstractArray{T}, x::AbstractArray{T},
 end
 
 wnorm(w, x) = sqrt(wdot(w, x, w, x))
-assess_convergence(f, ftol) = assess_convergence(NaN, NaN, f, NaN, ftol)
+assess_convergence(f, f_tol) = assess_convergence(NaN, NaN, f, NaN, f_tol)
 function assess_convergence(x,
                             x_previous,
                             f,
-                            xtol,
-                            ftol)
+                            x_tol,
+                            f_tol)
     x_converged, f_converged = false, false
 
-    if !any(isnan, x_previous) && chebyshev(x, x_previous) <= xtol
+    if !any(isnan, x_previous) && chebyshev(x, x_previous) <= x_tol
         x_converged = true
     end
 
-    if maximum(abs, f) <= ftol
+    if maximum(abs, f) <= f_tol
         f_converged = true
     end
 

src/solvers/anderson.jl

@@ -42,8 +42,8 @@ AndersonCache(df, ::Anderson{0}) =
 
 @views function anderson_(df::Union{NonDifferentiable, OnceDifferentiable},
                              initial_x::AbstractArray{T},
-                             xtol::T,
-                             ftol::T,
+                             x_tol::T,
+                             f_tol::T,
                              iterations::Integer,
                              store_trace::Bool,
                              show_trace::Bool,
@@ -87,7 +87,7 @@ AndersonCache(df, ::Anderson{0}) =
         end
 
         # check convergence
-        x_converged, f_converged, converged = assess_convergence(cache.g, cache.x, fx, xtol, ftol)
+        x_converged, f_converged, converged = assess_convergence(cache.g, cache.x, fx, x_tol, f_tol)
         converged && break
 
         # define next iterate
@@ -156,14 +156,14 @@ AndersonCache(df, ::Anderson{0}) =
 
     return SolverResults("Anderson m=$m beta=$beta aa_start=$aa_start droptol=$droptol",
                          initial_x, copy(cache.x), norm(value(df), Inf),
-                         iter, x_converged, xtol, f_converged, ftol, tr,
+                         iter, x_converged, x_tol, f_converged, f_tol, tr,
                          first(df.f_calls), 0)
 end
 
 function anderson(df::Union{NonDifferentiable, OnceDifferentiable},
                      initial_x::AbstractArray,
-                     xtol::Real,
-                     ftol::Real,
+                     x_tol::Real,
+                     f_tol::Real,
                      iterations::Integer,
                      store_trace::Bool,
                      show_trace::Bool,
@@ -172,13 +172,13 @@ function anderson(df::Union{NonDifferentiable, OnceDifferentiable},
                      beta::Real,
                      aa_start::Integer,
                      droptol::Real)
-    anderson(df, initial_x, xtol, ftol, iterations, store_trace, show_trace, extended_trace, beta, aa_start, droptol, AndersonCache(df, Anderson{m}()))
+    anderson(df, initial_x, x_tol, f_tol, iterations, store_trace, show_trace, extended_trace, beta, aa_start, droptol, AndersonCache(df, Anderson{m}()))
 end
 
 function anderson(df::Union{NonDifferentiable, OnceDifferentiable},
                      initial_x::AbstractArray{T},
-                     xtol::Real,
-                     ftol::Real,
+                     x_tol::Real,
+                     f_tol::Real,
                      iterations::Integer,
                      store_trace::Bool,
                      show_trace::Bool,
@@ -187,5 +187,5 @@ function anderson(df::Union{NonDifferentiable, OnceDifferentiable},
                      aa_start::Integer,
                      droptol::Real,
                      cache::AndersonCache) where T
-    anderson_(df, initial_x, convert(T, xtol), convert(T, ftol), iterations, store_trace, show_trace, extended_trace, beta, aa_start, droptol, cache)
+    anderson_(df, initial_x, convert(T, x_tol), convert(T, f_tol), iterations, store_trace, show_trace, extended_trace, beta, aa_start, droptol, cache)
 end

src/solvers/broyden.jl

@@ -23,8 +23,8 @@ end
 
 function broyden_(df::Union{NonDifferentiable, OnceDifferentiable},
                     initial_x::AbstractArray{T},
-                    xtol::T,
-                    ftol::T,
+                    x_tol::T,
+                    f_tol::T,
                     iterations::Integer,
                     store_trace::Bool,
                     show_trace::Bool,
@@ -46,7 +46,7 @@ function broyden_(df::Union{NonDifferentiable, OnceDifferentiable},
     Jinv = Matrix{T}(I, n, n)
     check_isfinite(value(df))
     it = 0
-    x_converged, f_converged, converged = assess_convergence(value(df), ftol)
+    x_converged, f_converged, converged = assess_convergence(value(df), f_tol)
 
     # FIXME: How should this flag be set?
     mayterminate = false
@@ -99,28 +99,28 @@ function broyden_(df::Union{NonDifferentiable, OnceDifferentiable},
         end
 
         if !maybe_stuck
-            x_converged, f_converged, converged = assess_convergence(x, xold, value(df), xtol, ftol)
+            x_converged, f_converged, converged = assess_convergence(x, xold, value(df), x_tol, f_tol)
         end
 
         maybe_stuck = false
         @broydentrace sqeuclidean(x, xold)
     end
     return SolverResults("broyden without line-search",
                          initial_x, copyto!(similar(initial_x), x), norm(value(df), Inf),
-                         it, x_converged, xtol, f_converged, ftol, tr,
+                         it, x_converged, x_tol, f_converged, f_tol, tr,
                          first(df.f_calls), 0)
 end
 
 function broyden(df::Union{NonDifferentiable, OnceDifferentiable},
                    initial_x::AbstractArray{T},
-                   xtol::Real,
-                   ftol::Real,
+                   x_tol::Real,
+                   f_tol::Real,
                    iterations::Integer,
                    store_trace::Bool,
                    show_trace::Bool,
                    extended_trace::Bool,
                    linesearch) where T
-    broyden_(df, initial_x, convert(T, xtol), convert(T, ftol), iterations, store_trace, show_trace, extended_trace, linesearch)
+    broyden_(df, initial_x, convert(T, x_tol), convert(T, f_tol), iterations, store_trace, show_trace, extended_trace, linesearch)
 end
 
 # A derivative-free line search and global convergence

src/solvers/mcp_func_defs.jl

@@ -18,8 +18,8 @@ function mcpsolve(df::OnceDifferentiable,
                   initial_x::AbstractArray{T};
                   method::Symbol = :trust_region,
                   reformulation::Symbol = :smooth,
-                  xtol::Real = zero(T),
-                  ftol::Real = convert(T,1e-8),
+                  x_tol::Real = zero(T),
+                  f_tol::Real = convert(T,1e-8),
                   iterations::Integer = 1_000,
                   store_trace::Bool = false,
                   show_trace::Bool = false,
@@ -30,7 +30,7 @@ function mcpsolve(df::OnceDifferentiable,
 
     @reformulate df
     nlsolve(rf,
-            initial_x, method = method, xtol = xtol, ftol = ftol,
+            initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
             iterations = iterations, store_trace = store_trace,
             show_trace = show_trace, extended_trace = extended_trace,
             linesearch = linesearch, factor = factor, autoscale = autoscale)
@@ -43,8 +43,8 @@ function mcpsolve(f,
                   initial_x::AbstractArray{T};
                   method::Symbol = :trust_region,
                   reformulation::Symbol = :smooth,
-                  xtol::Real = zero(T),
-                  ftol::Real = convert(T,1e-8),
+                  x_tol::Real = zero(T),
+                  f_tol::Real = convert(T,1e-8),
                   iterations::Integer = 1_000,
                   store_trace::Bool = false,
                   show_trace::Bool = false,
@@ -60,7 +60,7 @@ function mcpsolve(f,
     end
     @reformulate df
     nlsolve(rf,
-            initial_x, method = method, xtol = xtol, ftol = ftol,
+            initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
             iterations = iterations, store_trace = store_trace,
             show_trace = show_trace, extended_trace = extended_trace,
             linesearch = linesearch, factor = factor, autoscale = autoscale)
@@ -72,8 +72,8 @@ function mcpsolve(f,
                   initial_x::AbstractArray{T};
                   method::Symbol = :trust_region,
                   reformulation::Symbol = :smooth,
-                  xtol::Real = zero(T),
-                  ftol::Real = convert(T,1e-8),
+                  x_tol::Real = zero(T),
+                  f_tol::Real = convert(T,1e-8),
                   iterations::Integer = 1_000,
                   store_trace::Bool = false,
                   show_trace::Bool = false,
@@ -91,7 +91,7 @@ function mcpsolve(f,
 
     @reformulate df
     nlsolve(rf,
-            initial_x, method = method, xtol = xtol, ftol = ftol,
+            initial_x, method = method, x_tol = x_tol, f_tol = f_tol,
             iterations = iterations, store_trace = store_trace,
             show_trace = show_trace, extended_trace = extended_trace,
             linesearch = linesearch, factor = factor, autoscale = autoscale)

src/solvers/newton.jl

@@ -41,8 +41,8 @@ end
 
 function newton_(df::OnceDifferentiable,
                     initial_x::AbstractArray{T},
-                    xtol::T,
-                    ftol::T,
+                    x_tol::T,
+                    f_tol::T,
                     iterations::Integer,
                     store_trace::Bool,
                     show_trace::Bool,
@@ -56,7 +56,7 @@ function newton_(df::OnceDifferentiable,
     check_isfinite(value(df))
     vecvalue = vec(value(df))
     it = 0
-    x_converged, f_converged, converged = assess_convergence(value(df), ftol)
+    x_converged, f_converged, converged = assess_convergence(value(df), f_tol)
     x_ls = copy(cache.x)
     tr = SolverTrace()
     tracing = store_trace || show_trace || extended_trace
@@ -117,26 +117,26 @@ function newton_(df::OnceDifferentiable,
         alpha, ϕalpha = linesearch(dfo, cache.x, cache.p, one(T), x_ls, value(dfo), dot(cache.g, cache.p))
         # fvec is here also updated in the linesearch so no need to call f again.
         copyto!(cache.x, x_ls)
-        x_converged, f_converged, converged = assess_convergence(cache.x, cache.xold, value(df), xtol, ftol)
+        x_converged, f_converged, converged = assess_convergence(cache.x, cache.xold, value(df), x_tol, f_tol)
 
         newtontrace(sqeuclidean(cache.x, cache.xold), tracing, extended_trace, cache, df, it, tr, store_trace, show_trace)
     end
     return SolverResults("Newton with line-search",
                          initial_x, copy(cache.x), norm(value(df), Inf),
-                         it, x_converged, xtol, f_converged, ftol, tr,
+                         it, x_converged, x_tol, f_converged, f_tol, tr,
                          first(df.f_calls), first(df.df_calls))
 end
 
 function newton(df::OnceDifferentiable,
                    initial_x::AbstractArray{T},
-                   xtol::Real,
-                   ftol::Real,
+                   x_tol::Real,
+                   f_tol::Real,
                    iterations::Integer,
                    store_trace::Bool,
                    show_trace::Bool,
                    extended_trace::Bool,
                    linesearch,
                    cache = NewtonCache(df);
                    linsolve=(x, A, b) -> copyto!(x, A\b)) where T
-    newton_(df, initial_x, convert(T, xtol), convert(T, ftol), iterations, store_trace, show_trace, extended_trace, linesearch, linsolve, cache)
+    newton_(df, initial_x, convert(T, x_tol), convert(T, f_tol), iterations, store_trace, show_trace, extended_trace, linesearch, linsolve, cache)
 end