Update constraints in docs to be inplace

Author: Vaibhavdixit02

docs/src/optimization_packages/optim.md

@@ -46,7 +46,7 @@ The following special keyword arguments which are not covered by the common `sol
 * `show_every`: Trace output is printed every `show_every`th iteration.
 
 
-For a more extensive documentation of all the algorithms and options please consult the 
+For a more extensive documentation of all the algorithms and options please consult the
 [`Documentation`](https://julianlsolvers.github.io/Optim.jl/stable/#)
 
 ## Local Optimizer
@@ -73,7 +73,7 @@ The Rosenbrock function can optimized using the `Optim.IPNewton()` as follows:
 
 ```julia
 rosenbrock(x, p) =  (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
-cons= (x,p) -> [x[1]^2 + x[2]^2]
+cons= (res,x,p) -> res .= [x[1]^2 + x[2]^2]
 x0 = zeros(2)
 p  = [1.0,100.0]
 prob = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff();cons= cons)
@@ -345,7 +345,7 @@ The Rosenbrock function can optimized using the `Optim.KrylovTrustRegion()` as f
 
 ```julia
 rosenbrock(x, p) =  (1 - x[1])^2 + 100 * (x[2] - x[1]^2)^2
-cons= (x,p) -> [x[1]^2 + x[2]^2]
+cons= (res,x,p) -> res .= [x[1]^2 + x[2]^2]
 x0 = zeros(2)
 p  = [1.0,100.0]
 optprob = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff();cons= cons)

docs/src/tutorials/rosenbrock.md

@@ -1,14 +1,14 @@
 # Solving the Rosenbrock Problem in >10 Ways
- 
+
 This tutorial is a demonstration of many different solvers to demonstrate the
 flexibility of Optimization.jl. This is a gauntlet of many solvers to get a feel
 for common workflows of the package and give copy-pastable starting points.
 
 !!! note
 
     This example uses many different solvers of Optimization.jl. Each solver
-    subpackage needs to be installed separate. For example, for the details on 
-    the installation and usage of OptimizationOptimJL.jl package, see the 
+    subpackage needs to be installed separate. For example, for the details on
+    the installation and usage of OptimizationOptimJL.jl package, see the
     [Optim.jl page](@ref optim).
 
 ```@example rosenbrock
@@ -39,8 +39,8 @@ sol = solve(prob, NelderMead())
 
 # Now a gradient-based optimizer with forward-mode automatic differentiation
 
-optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff()) 
-prob = OptimizationProblem(optf, x0, _p) 
+optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff())
+prob = OptimizationProblem(optf, x0, _p)
 sol = solve(prob, BFGS())
 
 # Now a second order optimizer using Hessians generated by forward-mode automatic differentiation
@@ -53,7 +53,7 @@ sol = solve(prob, Optim.KrylovTrustRegion())
 
 # Now derivative-based optimizers with various constraints
 
-    cons = (x,p) -> [x[1]^2 + x[2]^2]
+    cons = (res,x,p) -> res .= [x[1]^2 + x[2]^2]
     optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff();cons= cons)
     #prob = OptimizationProblem(optf, x0, _p)
     #sol = solve(prob, IPNewton()) # No lcons or rcons, so constraints not satisfied
@@ -64,24 +64,24 @@ sol = solve(prob, IPNewton()) # Note that -Inf < x[1]^2 + x[2]^2 < Inf is always
 prob = OptimizationProblem(optf, x0, _p, lcons = [-5.0], ucons = [10.0])
 sol = solve(prob, IPNewton()) # Again, -5.0 < x[1]^2 + x[2]^2 < 10.0
 
-prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [Inf], 
+prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [Inf],
                            lb = [-500.0,-500.0], ub=[50.0,50.0])
 sol = solve(prob, IPNewton())
 
-prob = OptimizationProblem(optf, x0, _p, lcons = [0.5], ucons = [0.5], 
-                           lb = [-500.0,-500.0], ub=[50.0,50.0]) 
+prob = OptimizationProblem(optf, x0, _p, lcons = [0.5], ucons = [0.5],
+                           lb = [-500.0,-500.0], ub=[50.0,50.0])
 sol = solve(prob, IPNewton()) # Notice now that x[1]^2 + x[2]^2 ≈ 0.5:
                               # cons(sol.minimizer, _p) = 0.49999999999999994
 
-function con2_c(x,p)
-    [x[1]^2 + x[2]^2, x[2]*sin(x[1])-x[1]]
+function con2_c(res,x,p)
+    res .= [x[1]^2 + x[2]^2, x[2]*sin(x[1])-x[1]]
 end
 
 optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff();cons= con2_c)
 prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf,-Inf], ucons = [Inf,Inf])
 sol = solve(prob, IPNewton())
 
-cons_circ = (x,p) -> [x[1]^2 + x[2]^2]
+cons_circ = (x,p) -> res .= [x[1]^2 + x[2]^2]
 optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff();cons= cons_circ)
 prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [0.25^2])
 sol = solve(prob, IPNewton()) # -Inf < cons_circ(sol.minimizer, _p) = 0.25^2
@@ -116,7 +116,7 @@ sol = solve(prob, Opt(:LD_LBFGS, 2))
 ## Evolutionary.jl Solvers
 
 using OptimizationEvolutionary
-sol = solve(prob, CMAES(μ =40 , λ = 100),abstol=1e-15) # -1.0 ≤ x[1], x[2] ≤ 0.8 
+sol = solve(prob, CMAES(μ =40 , λ = 100),abstol=1e-15) # -1.0 ≤ x[1], x[2] ≤ 0.8
 
 ## BlackBoxOptim.jl Solvers
 

src/function/finitediff.jl

@@ -123,8 +123,10 @@ function instantiate_function(f, x, adtype::AutoFiniteDiff, p, num_cons = 0)
         cons_h = (res, θ) -> f.cons_h(res, θ, p)
     end
 
-    return OptimizationFunction{true}(f, adtype; grad=grad, hess=hess, hv=hv,
-        cons=cons, cons_j=cons_j, cons_h=cons_h,
-        cons_jac_colorvec = cons_jac_colorvec,
-        hess_prototype=f.hess_prototype, cons_jac_prototype=f.cons_jac_prototype, cons_hess_prototype=f.cons_hess_prototype)
+    return OptimizationFunction{true}(f, adtype; grad = grad, hess = hess, hv = hv,
+                                      cons = cons, cons_j = cons_j, cons_h = cons_h,
+                                      cons_jac_colorvec = cons_jac_colorvec,
+                                      hess_prototype = f.hess_prototype,
+                                      cons_jac_prototype = f.cons_jac_prototype,
+                                      cons_hess_prototype = f.cons_hess_prototype)
 end

src/function/forwarddiff.jl

@@ -102,7 +102,9 @@ function instantiate_function(f::OptimizationFunction{true}, x,
         cons_h = (res, θ) -> f.cons_h(res, θ, p)
     end
 
-    return OptimizationFunction{true}(f.f, adtype; grad=grad, hess=hess, hv=hv,
-        cons=cons, cons_j=cons_j, cons_h=cons_h,
-        hess_prototype=f.hess_prototype, cons_jac_prototype=f.cons_jac_prototype, cons_hess_prototype=f.cons_hess_prototype)
+    return OptimizationFunction{true}(f.f, adtype; grad = grad, hess = hess, hv = hv,
+                                      cons = cons, cons_j = cons_j, cons_h = cons_h,
+                                      hess_prototype = f.hess_prototype,
+                                      cons_jac_prototype = f.cons_jac_prototype,
+                                      cons_hess_prototype = f.cons_hess_prototype)
 end

src/function/function.jl

@@ -44,15 +44,19 @@ For more information on the use of automatic differentiation, see the
 documentation of the `AbstractADType` types.
 """
 function instantiate_function(f, x, ::AbstractADType, p, num_cons = 0)
-    grad   = f.grad   === nothing ? nothing : (G,x)->f.grad(G,x,p)
-    hess   = f.hess   === nothing ? nothing : (H,x)->f.hess(H,x,p)
-    hv     = f.hv     === nothing ? nothing : (H,x,v)->f.hv(H,x,v,p)
-    cons   = f.cons   === nothing ? nothing : (res,x)->f.cons(res,x,p)
-    cons_j = f.cons_j === nothing ? nothing : (res,x)->f.cons_j(res,x,p)
-    cons_h = f.cons_h === nothing ? nothing : (res,x)->f.cons_h(res,x,p)
-    hess_prototype = f.hess_prototype === nothing ? nothing : convert.(eltype(x), f.hess_prototype)
-    cons_jac_prototype = f.cons_jac_prototype === nothing ? nothing : convert.(eltype(x), f.cons_jac_prototype)
-    cons_hess_prototype = f.cons_hess_prototype === nothing ? nothing : [convert.(eltype(x), f.cons_hess_prototype[i]) for i in 1:num_cons]
+    grad = f.grad === nothing ? nothing : (G, x) -> f.grad(G, x, p)
+    hess = f.hess === nothing ? nothing : (H, x) -> f.hess(H, x, p)
+    hv = f.hv === nothing ? nothing : (H, x, v) -> f.hv(H, x, v, p)
+    cons = f.cons === nothing ? nothing : (res, x) -> f.cons(res, x, p)
+    cons_j = f.cons_j === nothing ? nothing : (res, x) -> f.cons_j(res, x, p)
+    cons_h = f.cons_h === nothing ? nothing : (res, x) -> f.cons_h(res, x, p)
+    hess_prototype = f.hess_prototype === nothing ? nothing :
+                     convert.(eltype(x), f.hess_prototype)
+    cons_jac_prototype = f.cons_jac_prototype === nothing ? nothing :
+                         convert.(eltype(x), f.cons_jac_prototype)
+    cons_hess_prototype = f.cons_hess_prototype === nothing ? nothing :
+                          [convert.(eltype(x), f.cons_hess_prototype[i])
+                           for i in 1:num_cons]
     expr = symbolify(f.expr)
     cons_expr = symbolify.(f.cons_expr)
 

src/function/reversediff.jl

@@ -84,7 +84,9 @@ function instantiate_function(f, x, adtype::AutoReverseDiff, p = SciMLBase.NullP
         hv = f.hv
     end
 
-    return OptimizationFunction{false}(f, adtype; grad=grad, hess=hess, hv=hv,
-        cons=nothing, cons_j=nothing, cons_h=nothing,
-        hess_prototype=f.hess_prototype, cons_jac_prototype=nothing, cons_hess_prototype=nothing)
+    return OptimizationFunction{false}(f, adtype; grad = grad, hess = hess, hv = hv,
+                                       cons = nothing, cons_j = nothing, cons_h = nothing,
+                                       hess_prototype = f.hess_prototype,
+                                       cons_jac_prototype = nothing,
+                                       cons_hess_prototype = nothing)
 end

src/function/tracker.jl

@@ -51,8 +51,9 @@ function instantiate_function(f, x, adtype::AutoTracker, p, num_cons = 0)
         hv = f.hv
     end
 
-
-    return OptimizationFunction{false}(f, adtype; grad=grad, hess=hess, hv=hv,
-        cons=nothing, cons_j=nothing, cons_h=nothing,
-        hess_prototype=f.hess_prototype, cons_jac_prototype=nothing, cons_hess_prototype=nothing)
+    return OptimizationFunction{false}(f, adtype; grad = grad, hess = hess, hv = hv,
+                                       cons = nothing, cons_j = nothing, cons_h = nothing,
+                                       hess_prototype = f.hess_prototype,
+                                       cons_jac_prototype = nothing,
+                                       cons_hess_prototype = nothing)
 end

src/function/zygote.jl

@@ -66,7 +66,9 @@ function instantiate_function(f, x, adtype::AutoZygote, p, num_cons = 0)
         hv = f.hv
     end
 
-    return OptimizationFunction{false}(f, adtype; grad=grad, hess=hess, hv=hv,
-        cons=nothing, cons_j=nothing, cons_h=nothing,
-        hess_prototype=f.hess_prototype, cons_jac_prototype=nothing, cons_hess_prototype=nothing)
+    return OptimizationFunction{false}(f, adtype; grad = grad, hess = hess, hv = hv,
+                                       cons = nothing, cons_j = nothing, cons_h = nothing,
+                                       hess_prototype = f.hess_prototype,
+                                       cons_jac_prototype = nothing,
+                                       cons_hess_prototype = nothing)
 end

test/ADtests.jl

@@ -148,7 +148,6 @@ optprob.grad(G2, x0)
 @test G1 == G2
 @test_throws ErrorException optprob.hess(H2, x0)
 
-
 prob = OptimizationProblem(optf, x0)
 
 sol = solve(prob, Optim.BFGS())
@@ -253,14 +252,17 @@ cons_j = (J, θ, p) -> optprob.cons_j(J, θ)
 hess = (H, θ, p) -> optprob.hess(H, θ)
 sH = sparse([1, 1, 2, 2], [1, 2, 1, 2], zeros(4))
 sJ = sparse([1, 1, 2, 2], [1, 2, 1, 2], zeros(4))
-optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff(), hess=hess, hess_prototype=copy(sH), cons=con2_c, cons_j=cons_j, cons_jac_prototype=copy(sJ))
-optprob1 = Optimization.instantiate_function(optf, x0, Optimization.AutoForwardDiff(), nothing, 2)
+optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff(), hess = hess,
+                            hess_prototype = copy(sH), cons = con2_c, cons_j = cons_j,
+                            cons_jac_prototype = copy(sJ))
+optprob1 = Optimization.instantiate_function(optf, x0, Optimization.AutoForwardDiff(),
+                                             nothing, 2)
 @test optprob1.hess_prototype == sparse([0.0 0.0; 0.0 0.0]) # make sure it's still using it
 optprob1.hess(sH, [5.0, 3.0])
-@test all(isapprox(sH, [28802.0 -2000.0; -2000.0 200.0]; rtol=1e-3))
+@test all(isapprox(sH, [28802.0 -2000.0; -2000.0 200.0]; rtol = 1e-3))
 @test optprob1.cons_jac_prototype == sparse([0.0 0.0; 0.0 0.0]) # make sure it's still using it
 optprob1.cons_j(sJ, [5.0, 3.0])
-@test all(isapprox(sJ, [10.0 6.0; -0.149013 -0.958924]; rtol=1e-3))
+@test all(isapprox(sJ, [10.0 6.0; -0.149013 -0.958924]; rtol = 1e-3))
 
 grad = (G, θ, p) -> optprob.grad(G, θ)
 hess = (H, θ, p) -> optprob.hess(H, θ)
@@ -269,14 +271,20 @@ cons_h = (res, θ, p) -> optprob.cons_h(res, θ)
 sH = sparse([1, 1, 2, 2], [1, 2, 1, 2], zeros(4))
 sJ = sparse([1, 1, 2, 2], [1, 2, 1, 2], zeros(4))
 sH3 = [sparse([1, 2], [1, 2], zeros(2)), sparse([1, 1, 2], [1, 2, 1], zeros(3))]
-optf = OptimizationFunction(rosenbrock, SciMLBase.NoAD(), grad=grad, hess=hess, cons=con2_c, cons_j=cons_j, cons_h=cons_h, hess_prototype=sH, cons_jac_prototype=sJ, cons_hess_prototype=sH3)
+optf = OptimizationFunction(rosenbrock, SciMLBase.NoAD(), grad = grad, hess = hess,
+                            cons = con2_c, cons_j = cons_j, cons_h = cons_h,
+                            hess_prototype = sH, cons_jac_prototype = sJ,
+                            cons_hess_prototype = sH3)
 optprob2 = Optimization.instantiate_function(optf, x0, SciMLBase.NoAD(), nothing, 2)
 optprob2.hess(sH, [5.0, 3.0])
-@test all(isapprox(sH, [28802.0 -2000.0; -2000.0 200.0]; rtol=1e-3))
+@test all(isapprox(sH, [28802.0 -2000.0; -2000.0 200.0]; rtol = 1e-3))
 optprob2.cons_j(sJ, [5.0, 3.0])
-@test all(isapprox(sJ, [10.0 6.0; -0.149013 -0.958924]; rtol=1e-3))
+@test all(isapprox(sJ, [10.0 6.0; -0.149013 -0.958924]; rtol = 1e-3))
 optprob2.cons_h(sH3, [5.0, 3.0])
-@test sH3 ≈ [[2.0 0.0; 0.0 2.0], [2.8767727327346804 0.2836621681849162; 0.2836621681849162 -6.622738308376736e-9]]
+@test sH3 ≈ [
+    [2.0 0.0; 0.0 2.0],
+    [2.8767727327346804 0.2836621681849162; 0.2836621681849162 -6.622738308376736e-9],
+]
 
 # Can we solve problems? Using AutoForwardDiff to test since we know that works
 for consf in [cons, con2_c]