More JET (#1197)

Author: pkofod

src/maximize.jl

@@ -79,12 +79,7 @@ function maximize(
     MaximizationWrapper(optimize(fmax, gmax, hmax, x0, method, options))
 end
 
-minimum(r::MaximizationWrapper) = throw(MethodError())
-maximizer(r::Union{UnivariateOptimizationResults,MultivariateOptimizationResults}) =
-    throw(MethodError())
 maximizer(r::MaximizationWrapper) = minimizer(res(r))
-maximum(r::Union{UnivariateOptimizationResults,MultivariateOptimizationResults}) =
-    throw(MethodError())
 maximum(r::MaximizationWrapper) = -minimum(res(r))
 Base.summary(io::IO, r::MaximizationWrapper) = summary(io, res(r))
 
@@ -102,6 +97,7 @@ for api_method in (
     :x_converged,
     :x_abschange,
     :g_tol,
+    :g_abstol,
     :g_converged,
     :g_residual,
     :f_tol,
@@ -134,47 +130,5 @@ function Base.show(io::IO, r::MaximizationWrapper{<:UnivariateOptimizationResult
     return
 end
 
-function Base.show(io::IO, r::MaximizationWrapper{<:MultivariateOptimizationResults})
-    take = Iterators.take
 
-    println(io, "Results of Optimization Algorithm")
-    print(io, " * Algorithm: ")
-    summary(io, r.res)
-    println(io)
-
-    if length(join(initial_state(r), ",")) < 40
-        @printf io " * Starting Point: [%s]\n" join(initial_state(r), ",")
-    else
-        @printf io " * Starting Point: [%s, ...]\n" join(take(initial_state(r), 2), ",")
-    end
-    if length(join(maximizer(r), ",")) < 40
-        @printf io " * Maximizer: [%s]\n" join(maximizer(r), ",")
-    else
-        @printf io " * Maximizer: [%s, ...]\n" join(take(maximizer(r), 2), ",")
-    end
-    @printf io " * Maximum: %e\n" maximum(r)
-    @printf io " * Iterations: %d\n" iterations(r)
-    @printf io " * Convergence: %s\n" converged(r)
-    if isa(r.res.method, NelderMead)
-        @printf io "   *  √(Σ(yᵢ-ȳ)²)/n < %.1e: %s\n" g_abstol(r) g_converged(r)
-    else
-        @printf io "   * |x - x'| ≤ %.1e: %s \n" x_reltol(r) x_converged(r)
-        @printf io "     |x - x'| = %.2e \n" x_abschange(r)
-        @printf io "   * |f(x) - f(x')| ≤ %.1e |f(x)|: %s\n" f_reltol(r) f_converged(r)
-        @printf io "     |f(x) - f(x')| = %.2e |f(x)|\n" f_relchange(r)
-        @printf io "   * |g(x)| ≤ %.1e: %s \n" g_abstol(r) g_converged(r)
-        @printf io "     |g(x)| = %.2e \n" g_residual(r)
-        @printf io "   * Stopped by an decreasing objective: %s\n" (
-            f_increased(r) && !iteration_limit_reached(r)
-        )
-    end
-    @printf io "   * Reached Maximum Number of Iterations: %s\n" iteration_limit_reached(r)
-    @printf io " * Objective Calls: %d" f_calls(r)
-    if !(isa(r.res.method, NelderMead) || isa(r.res.method, SimulatedAnnealing))
-        @printf io "\n * Gradient Calls: %d" g_calls(r)
-    end
-    if isa(r.res.method, Newton) || isa(r.res.method, NewtonTrustRegion)
-        @printf io "\n * Hessian Calls: %d" h_calls(r)
-    end
-    return
-end
+Base.show(io::IO, r::MaximizationWrapper{<:MultivariateOptimizationResults}) = show(io, r.res)

src/multivariate/solvers/constrained/ipnewton/interior.jl

@@ -576,6 +576,18 @@ end
 
 # TODO: do we need lagrangian_vec? Maybe for automatic differentiation?
 ## Computation of Lagrangian and derivatives when passing all parameters as a single vector
+# FIXME: Seems unused
+
+#=
+function unpack_vec!(x, b::BarrierStateVars, vec::Vector)
+    k = unpack_vec!(x, vec, 0)
+    for fn in fieldnames(b)
+        k = unpack_vec!(getfield(b, fn), vec, k)
+    end
+    k == length(vec) ||
+        throw(DimensionMismatch("vec should have length $k, got $(length(vec))"))
+    x, b
+end
 function lagrangian_vec(
     p,
     d,
@@ -589,6 +601,7 @@ function lagrangian_vec(
     f_x, L_xsλ, ev = lagrangian(d, bounds, x, c, bstate, μ)
     L_xsλ
 end
+ #FIXME: Seems unused
 function lagrangian_vec(
     p,
     d,
@@ -603,6 +616,7 @@ function lagrangian_vec(
     f_x, L_xsλ, ev = lagrangian(d, bounds, x, c(x), bstate, μ)
     L_xsλ
 end
+ #FIXME: Seems unused
 function lagrangian_fgvec!(
     p,
     storage,
@@ -621,6 +635,7 @@ function lagrangian_fgvec!(
     pack_vec!(storage, gx, bgrad)
     L_xsλ
 end
+=#
 
 ## for line searches that don't use the gradient along the line
 function lagrangian_linefunc(αs, d, constraints, state)
@@ -1043,41 +1058,6 @@ isinterior(constraints::AbstractConstraints, x, c) = isinterior(constraints.boun
 isinterior(constraints::Nothing, state::AbstractBarrierState) = true
 isinterior(constraints::Nothing, x) = true
 
-## Utilities for representing total state as single vector
-# TODO: Most of these seem to be unused (IPNewton)?
-function pack_vec(x, b::BarrierStateVars)
-    n = length(x)
-    for fn in fieldnames(b)
-        n += length(getfield(b, fn))
-    end
-    vec = Array{eltype(x)}(undef, n)
-    pack_vec!(vec, x, b)
-end
-
-function pack_vec!(vec, x, b::BarrierStateVars)
-    k = pack_vec!(vec, x, 0)
-    for fn in fieldnames(b)
-        k = pack_vec!(vec, getfield(b, fn), k)
-    end
-    k == length(vec) ||
-        throw(DimensionMismatch("vec should have length $k, got $(length(vec))"))
-    vec
-end
-function pack_vec!(vec, x, k::Int)
-    for i = 1:length(x)
-        vec[k+=1] = x[i]
-    end
-    k
-end
-function unpack_vec!(x, b::BarrierStateVars, vec::Vector)
-    k = unpack_vec!(x, vec, 0)
-    for fn in fieldnames(b)
-        k = unpack_vec!(getfield(b, fn), vec, k)
-    end
-    k == length(vec) ||
-        throw(DimensionMismatch("vec should have length $k, got $(length(vec))"))
-    x, b
-end
 function unpack_vec!(x, vec::Vector, k::Int)
     for i = 1:length(x)
         x[i] = vec[k+=1]

test/multivariate/solvers/constrained/ipnewton/constraints.jl

@@ -51,6 +51,24 @@
     end
 
     @testset "IPNewton computations" begin
+
+        ## Utilities for representing total state as single vector
+        # TODO: Most of these seem to be unused (IPNewton)?
+        function pack_vec(x, b::Optim.BarrierStateVars)
+            n = length(x)
+            for fn in propertynames(b)
+                n += length(getfield(b, fn))
+            end
+            vec = Array{eltype(x)}(undef, n)
+            pack_vec!(vec, x, b)
+        end
+
+        function pack_vec!(vec, x, k::Int)
+            for i = 1:length(x)
+                vec[k+=1] = x[i]
+            end
+            k
+        end
         # Compare hand-computed gradient against that from automatic differentiation
         function check_autodiff(d, bounds, x, cfun::Function, bstate, μ)
             c = cfun(x)