Fix namespacing issues

Co-authored-by: Claude <noreply@anthropic.com>

Author: SebastianM-C

docs/make.jl

@@ -1,16 +1,15 @@
 using Documenter, Optimization
-using FiniteDiff, ForwardDiff, ModelingToolkit, ReverseDiff, Tracker, Zygote
-using ADTypes
+using OptimizationLBFGSB, OptimizationSophia
 
-cp("./docs/Manifest.toml", "./docs/src/assets/Manifest.toml", force = true)
-cp("./docs/Project.toml", "./docs/src/assets/Project.toml", force = true)
+cp(joinpath(@__DIR__, "Manifest.toml"), joinpath(@__DIR__, "src/assets/Manifest.toml"), force = true)
+cp(joinpath(@__DIR__, "Project.toml"), joinpath(@__DIR__, "src/assets/Project.toml"), force = true)
 
 include("pages.jl")
 
 makedocs(sitename = "Optimization.jl",
     authors = "Chris Rackauckas, Vaibhav Kumar Dixit et al.",
-    modules = [Optimization, Optimization.SciMLBase, Optimization.OptimizationBase,
-        FiniteDiff, ForwardDiff, ModelingToolkit, ReverseDiff, Tracker, Zygote, ADTypes],
+    modules = [Optimization, Optimization.SciMLBase, Optimization.OptimizationBase, Optimization.ADTypes,
+        OptimizationLBFGSB, OptimizationSophia],
     clean = true, doctest = false, linkcheck = true,
     warnonly = [:missing_docs, :cross_references],
     format = Documenter.HTML(assets = ["assets/favicon.ico"],

docs/src/API/ad.md

@@ -13,15 +13,15 @@ The choices for the auto-AD fill-ins with quick descriptions are:
 
 ## Automatic Differentiation Choice API
 
-The following sections describe the Auto-AD choices in detail.
+The following sections describe the Auto-AD choices in detail. These types are defined in the [ADTypes.jl](https://github.com/SciML/ADTypes.jl) package.
 
 ```@docs
-OptimizationBase.AutoForwardDiff
-OptimizationBase.AutoFiniteDiff
-OptimizationBase.AutoReverseDiff
-OptimizationBase.AutoZygote
-OptimizationBase.AutoTracker
-OptimizationBase.AutoSymbolics
-OptimizationBase.AutoEnzyme
+ADTypes.AutoForwardDiff
+ADTypes.AutoFiniteDiff
+ADTypes.AutoReverseDiff
+ADTypes.AutoZygote
+ADTypes.AutoTracker
+ADTypes.AutoSymbolics
+ADTypes.AutoEnzyme
 ADTypes.AutoMooncake
 ```

docs/src/API/optimization_state.md

@@ -1,5 +1,5 @@
 # [OptimizationState](@id optstate)
 
 ```@docs
-Optimization.OptimizationState
+OptimizationBase.OptimizationState
 ```

docs/src/examples/rosenbrock.md

@@ -41,15 +41,16 @@ An optimization problem can now be defined and solved to estimate the values for
 
 ```@example rosenbrock
 # Define the problem to solve
-using Optimization, ForwardDiff, Zygote
+using SciMLBase, OptimizationBase
+using ADTypes, ForwardDiff, Zygote
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 _p = [1.0, 100.0]
 
-f = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff())
+f = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
 l1 = rosenbrock(x0, _p)
-prob = OptimizationProblem(f, x0, _p)
+prob = SciMLBase.OptimizationProblem(f, x0, _p)
 ```
 
 ## Optim.jl Solvers
@@ -59,19 +60,19 @@ prob = OptimizationProblem(f, x0, _p)
 ```@example rosenbrock
 using OptimizationOptimJL
 sol = solve(prob, SimulatedAnnealing())
-prob = OptimizationProblem(f, x0, _p, lb = [-1.0, -1.0], ub = [0.8, 0.8])
+prob = SciMLBase.OptimizationProblem(f, x0, _p, lb = [-1.0, -1.0], ub = [0.8, 0.8])
 sol = solve(prob, SAMIN())
 
 l1 = rosenbrock(x0, _p)
-prob = OptimizationProblem(rosenbrock, x0, _p)
+prob = SciMLBase.OptimizationProblem(rosenbrock, x0, _p)
 sol = solve(prob, NelderMead())
 ```
 
 ### Now a gradient-based optimizer with forward-mode automatic differentiation
 
 ```@example rosenbrock
-optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff())
-prob = OptimizationProblem(optf, x0, _p)
+optf = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
+prob = SciMLBase.OptimizationProblem(optf, x0, _p)
 sol = solve(prob, BFGS())
 ```
 
@@ -91,19 +92,19 @@ sol = solve(prob, Optim.KrylovTrustRegion())
 
 ```@example rosenbrock
 cons = (res, x, p) -> res .= [x[1]^2 + x[2]^2]
-optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff(); cons = cons)
+optf = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff(); cons = cons)
 
-prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [Inf])
+prob = SciMLBase.OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [Inf])
 sol = solve(prob, IPNewton()) # Note that -Inf < x[1]^2 + x[2]^2 < Inf is always true
 
-prob = OptimizationProblem(optf, x0, _p, lcons = [-5.0], ucons = [10.0])
+prob = SciMLBase.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 = SciMLBase.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],
+prob = SciMLBase.OptimizationProblem(optf, x0, _p, lcons = [0.5], ucons = [0.5],
     lb = [-500.0, -500.0], ub = [50.0, 50.0])
 sol = solve(prob, IPNewton())
 
@@ -118,8 +119,8 @@ function con_c(res, x, p)
     res .= [x[1]^2 + x[2]^2]
 end
 
-optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff(); cons = con_c)
-prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [0.25^2])
+optf = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff(); cons = con_c)
+prob = SciMLBase.OptimizationProblem(optf, x0, _p, lcons = [-Inf], ucons = [0.25^2])
 sol = solve(prob, IPNewton()) # -Inf < cons_circ(sol.u, _p) = 0.25^2
 ```
 
@@ -139,17 +140,17 @@ 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.AutoZygote(); cons = con2_c)
-prob = OptimizationProblem(optf, x0, _p, lcons = [-Inf, -Inf], ucons = [100.0, 100.0])
+optf = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoZygote(); cons = con2_c)
+prob = SciMLBase.OptimizationProblem(optf, x0, _p, lcons = [-Inf, -Inf], ucons = [100.0, 100.0])
 sol = solve(prob, Ipopt.Optimizer())
 ```
 
 ## Now let's switch over to OptimizationOptimisers with reverse-mode AD
 
 ```@example rosenbrock
 import OptimizationOptimisers
-optf = OptimizationFunction(rosenbrock, Optimization.AutoZygote())
-prob = OptimizationProblem(optf, x0, _p)
+optf = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoZygote())
+prob = SciMLBase.OptimizationProblem(optf, x0, _p)
 sol = solve(prob, OptimizationOptimisers.Adam(0.05), maxiters = 1000, progress = false)
 ```
 
@@ -164,8 +165,8 @@ sol = solve(prob, CMAEvolutionStrategyOpt())
 
 ```@example rosenbrock
 using OptimizationNLopt, ModelingToolkit
-optf = OptimizationFunction(rosenbrock, Optimization.AutoSymbolics())
-prob = OptimizationProblem(optf, x0, _p)
+optf = SciMLBase.OptimizationFunction(rosenbrock, ADTypes.AutoSymbolics())
+prob = SciMLBase.OptimizationProblem(optf, x0, _p)
 
 sol = solve(prob, Opt(:LN_BOBYQA, 2))
 sol = solve(prob, Opt(:LD_LBFGS, 2))
@@ -174,7 +175,7 @@ sol = solve(prob, Opt(:LD_LBFGS, 2))
 ### Add some box constraints and solve with a few NLopt.jl methods
 
 ```@example rosenbrock
-prob = OptimizationProblem(optf, x0, _p, lb = [-1.0, -1.0], ub = [0.8, 0.8])
+prob = SciMLBase.OptimizationProblem(optf, x0, _p, lb = [-1.0, -1.0], ub = [0.8, 0.8])
 sol = solve(prob, Opt(:LD_LBFGS, 2))
 sol = solve(prob, Opt(:G_MLSL_LDS, 2), local_method = Opt(:LD_LBFGS, 2), maxiters = 10000) #a global optimizer with random starts of local optimization
 ```
@@ -183,7 +184,7 @@ sol = solve(prob, Opt(:G_MLSL_LDS, 2), local_method = Opt(:LD_LBFGS, 2), maxiter
 
 ```@example rosenbrock
 using OptimizationBBO
-prob = Optimization.OptimizationProblem(rosenbrock, [0.0, 0.3], _p, lb = [-1.0, 0.2],
+prob = SciMLBase.OptimizationProblem(rosenbrock, [0.0, 0.3], _p, lb = [-1.0, 0.2],
     ub = [0.8, 0.43])
 sol = solve(prob, BBO_adaptive_de_rand_1_bin()) # -1.0 ≤ x[1] ≤ 0.8, 0.2 ≤ x[2] ≤ 0.43
 ```

docs/src/getting_started.md

@@ -14,12 +14,12 @@ The simplest copy-pasteable code using a quasi-Newton method (LBFGS) to solve th
 
 ```@example intro
 # Import the package and define the problem to optimize
-using Optimization, OptimizationLBFGSB, Zygote
+using OptimizationBase, OptimizationLBFGSB, ADTypes, Zygote
 rosenbrock(u, p) = (p[1] - u[1])^2 + p[2] * (u[2] - u[1]^2)^2
 u0 = zeros(2)
 p = [1.0, 100.0]
 
-optf = OptimizationFunction(rosenbrock, AutoZygote())
+optf = OptimizationFunction(rosenbrock, ADTypes.AutoZygote())
 prob = OptimizationProblem(optf, u0, p)
 
 sol = solve(prob, OptimizationLBFGSB.LBFGSB())
@@ -131,8 +131,8 @@ automatically construct the derivative functions using ForwardDiff.jl. This
 looks like:
 
 ```@example intro
-using ForwardDiff
-optf = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff())
+using ForwardDiff, ADTypes
+optf = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
 prob = OptimizationProblem(optf, u0, p)
 sol = solve(prob, OptimizationOptimJL.BFGS())
 ```
@@ -155,7 +155,7 @@ We can demonstrate this via:
 
 ```@example intro
 using Zygote
-optf = OptimizationFunction(rosenbrock, Optimization.AutoZygote())
+optf = OptimizationFunction(rosenbrock, ADTypes.AutoZygote())
 prob = OptimizationProblem(optf, u0, p)
 sol = solve(prob, OptimizationOptimJL.BFGS())
 ```

docs/src/optimization_packages/blackboxoptim.md

@@ -63,7 +63,7 @@ rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 p = [1.0, 100.0]
 f = OptimizationFunction(rosenbrock)
-prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, BBO_adaptive_de_rand_1_bin_radiuslimited(), maxiters = 100000,
     maxtime = 1000.0)
 ```

docs/src/optimization_packages/cmaevolutionstrategy.md

@@ -30,6 +30,6 @@ rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 p = [1.0, 100.0]
 f = OptimizationFunction(rosenbrock)
-prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, CMAEvolutionStrategyOpt())
 ```

docs/src/optimization_packages/evolutionary.md

@@ -38,6 +38,6 @@ rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 p = [1.0, 100.0]
 f = OptimizationFunction(rosenbrock)
-prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, Evolutionary.CMAES(μ = 40, λ = 100))
 ```

docs/src/optimization_packages/gcmaes.md

@@ -30,14 +30,15 @@ rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 p = [1.0, 100.0]
 f = OptimizationFunction(rosenbrock)
-prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, GCMAESOpt())
 ```
 
 We can also utilize the gradient information of the optimization problem to aid the optimization as follows:
 
 ```@example GCMAES
-f = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff())
-prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+using ADTypes, ForwardDiff
+f = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
+prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, GCMAESOpt())
 ```

docs/src/optimization_packages/ipopt.md

@@ -45,7 +45,7 @@ The algorithm supports:
 ### Basic Usage
 
 ```julia
-using Optimization, OptimizationIpopt
+using OptimizationBase, OptimizationIpopt
 
 # Create optimizer with default settings
 opt = IpoptOptimizer()