[AI] Curate the public API instead of blanket-reexporting dependencies

Project.toml

@@ -1,6 +1,6 @@
 name = "Optimization"
 uuid = "7f7a1694-90dd-40f0-9382-eb1efda571ba"
-version = "5.6.6"
+version = "6.0.0"
 
 [deps]
 ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
@@ -47,9 +47,9 @@ MLUtils = "0.4"
 ModelingToolkit = "11"
 Optim = "2"
 Optimisers = ">= 0.2.5"
-OptimizationBase = "5"
-OptimizationOptimJL = "0.4.10"
-OptimizationOptimisers = "0.3.16"
+OptimizationBase = "6"
+OptimizationOptimJL = "0.5"
+OptimizationOptimisers = "0.4"
 OrdinaryDiffEqTsit5 = "1, 2"
 Pkg = "1"
 Printf = "1.10"

README.md

@@ -22,11 +22,11 @@ unified interface.
 ## Installation
 
 Assuming that you already have Julia correctly installed, it suffices to import
-Optimization.jl in the standard way:
+OptimizationBase in the standard way:
 
 ```julia
 using Pkg
-Pkg.add("Optimization")
+Pkg.add("OptimizationBase")
 ```
 
 The packages relevant to the core functionality of Optimization.jl will be imported
@@ -71,7 +71,7 @@ the documentation, which contains the unreleased features.
 ## Examples
 
 ```julia
-using Optimization
+using OptimizationBase
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 p = [1.0, 100.0]

docs/Project.toml

@@ -165,40 +165,40 @@ ModelingToolkit = "10.23, 11"
 NLPModels = "0.21, 0.22"
 NLPModelsTest = "0.10"
 NLopt = "0.6, 1"
-Optimization = "5.5"
-OptimizationAuglag = "1.3, 2"
-OptimizationBBO = "0.4.6"
-OptimizationBase = "5"
-OptimizationCMAEvolutionStrategy = "0.3.6"
-OptimizationEvolutionary = "0.4.7"
-OptimizationGCMAES = "0.3.5"
-OptimizationIpopt = "1.1"
-OptimizationLBFGSB = "1.4"
-OptimizationMOI = "1.2"
-OptimizationMadNLP = "2, 1"
-OptimizationManopt = "1.2"
-OptimizationMetaheuristics = "0.3.5"
-OptimizationMultistartOptimization = "0.3.4"
-OptimizationNLPModels = "1.2"
-OptimizationNLopt = "0.3.9"
-OptimizationNOMAD = "0.3.5"
-OptimizationODE = "0.1.4"
-OptimizationOptimJL = "0.4.10"
-OptimizationOptimisers = "0.3.16"
-OptimizationPRIMA = "0.3.5"
-OptimizationPolyalgorithms = "0.3.5"
-OptimizationPyCMA = "1.3"
-OptimizationQuadDIRECT = "0.3.4"
-OptimizationSciPy = "0.4.6"
-OptimizationSophia = "1.3"
-OptimizationSpeedMapping = "0.2.3"
+Optimization = "6"
+OptimizationAuglag = "3"
+OptimizationBBO = "0.5"
+OptimizationBase = "6"
+OptimizationCMAEvolutionStrategy = "0.4"
+OptimizationEvolutionary = "0.5"
+OptimizationGCMAES = "0.4"
+OptimizationIpopt = "2"
+OptimizationLBFGSB = "2"
+OptimizationMOI = "2"
+OptimizationMadNLP = "3"
+OptimizationManopt = "2"
+OptimizationMetaheuristics = "0.4"
+OptimizationMultistartOptimization = "0.4"
+OptimizationNLPModels = "2"
+OptimizationNLopt = "0.4"
+OptimizationNOMAD = "0.4"
+OptimizationODE = "0.2"
+OptimizationOptimJL = "0.5"
+OptimizationOptimisers = "0.4"
+OptimizationPRIMA = "0.4"
+OptimizationPolyalgorithms = "0.4"
+OptimizationPyCMA = "2"
+OptimizationQuadDIRECT = "0.4"
+OptimizationSciPy = "0.5"
+OptimizationSophia = "2"
+OptimizationSpeedMapping = "0.3"
 OrdinaryDiffEq = "6, 7"
 Plots = "1"
 Random = "1"
 ReverseDiff = ">= 1.9.0"
 SciMLBase = "2.122.1, 3"
 SciMLSensitivity = "7"
-SimpleOptimization = "1"
+SimpleOptimization = "2"
 Symbolics = "7"
 Tracker = ">= 0.2"
 Zygote = ">= 0.5"

docs/make.jl

@@ -1,4 +1,7 @@
 using Documenter, Optimization
+# The `@docs` entries under API/ name SciMLBase types directly; nothing re-exports
+# the module binding any more, so bind it here rather than relying on that leak.
+using SciMLBase
 using OptimizationAuglag, OptimizationBBO, OptimizationBase
 using OptimizationCMAEvolutionStrategy, OptimizationGCMAES, OptimizationIpopt
 using OptimizationLBFGSB, OptimizationMadNLP, OptimizationManopt

docs/src/index.md

@@ -36,6 +36,20 @@ Optimization.jl is simply a bundle/interface over many of these dependencies.
 It may add some optional higher level behavior in the future but at this time
 the top level package does not add any extra behavior.
 
+### `Optimization` or `OptimizationBase`?
+
+`OptimizationBase` defines the interface — `OptimizationProblem`,
+`OptimizationFunction`, `solve` — and is what every solver package depends on,
+so it is what the examples throughout this documentation load:
+
+```julia
+Pkg.add("OptimizationBase")
+```
+
+`Optimization` re-exports that same interface and nothing else, so the two are
+interchangeable for everything shown here. Install whichever you prefer; you
+need only one of them, alongside a solver package.
+
 ## Contributing
 
   - Please refer to the

docs/src/optimization_packages/auglag.md

@@ -20,7 +20,7 @@ OptimizationAuglag.AugLag
 ## Example
 
 ```julia
-using Optimization, OptimizationAuglag, OptimizationOptimJL, ADTypes
+using OptimizationBase, OptimizationAuglag, OptimizationOptimJL, ADTypes
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 cons(res, x, p) = (res .= [x[1]^2 + x[2]^2])

docs/src/optimization_packages/blackboxoptim.md

@@ -77,12 +77,12 @@ OptimizationBBO.BBO_borg_moea
 The Rosenbrock function can be optimized using the `BBO_adaptive_de_rand_1_bin_radiuslimited()` as follows:
 
 ```@example BBO
-using Optimization, OptimizationBBO
+using OptimizationBase, OptimizationBBO
 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 = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = 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

@@ -29,11 +29,11 @@ OptimizationCMAEvolutionStrategy.CMAEvolutionStrategyOpt
 The Rosenbrock function can be optimized using the `CMAEvolutionStrategyOpt()` as follows:
 
 ```@example CMAEvolutionStrategy
-using Optimization, OptimizationCMAEvolutionStrategy
+using OptimizationBase, OptimizationCMAEvolutionStrategy
 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 = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, CMAEvolutionStrategyOpt())
 ```

docs/src/optimization_packages/evolutionary.md

@@ -33,11 +33,11 @@ Algorithm-specific options are defined as `kwargs`. See the respective documenta
 The Rosenbrock function can be optimized using the `Evolutionary.CMAES()` as follows:
 
 ```@example Evolutionary
-using Optimization, OptimizationEvolutionary
+using OptimizationBase, OptimizationEvolutionary
 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 = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = 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

@@ -29,12 +29,12 @@ OptimizationGCMAES.GCMAESOpt
 The Rosenbrock function can be optimized using the `GCMAESOpt()` without utilizing the gradient information as follows:
 
 ```@example GCMAES
-using Optimization, OptimizationGCMAES
+using OptimizationBase, OptimizationGCMAES
 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 = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, GCMAESOpt())
 ```
 
@@ -43,6 +43,6 @@ We can also utilize the gradient information of the optimization problem to aid
 ```@example GCMAES
 using ADTypes, ForwardDiff
 f = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
-prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, GCMAESOpt())
 ```

docs/src/optimization_packages/ipopt.md

@@ -180,7 +180,7 @@ sol = solve(prob, opt;
 The Rosenbrock function can be minimized using `IpoptOptimizer`:
 
 ```@example Ipopt1
-using Optimization, OptimizationIpopt
+using OptimizationBase, OptimizationIpopt
 using Zygote
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
@@ -198,7 +198,7 @@ sol = solve(prob, IpoptOptimizer())
 Adding box constraints to limit the search space:
 
 ```@example Ipopt2
-using Optimization, OptimizationIpopt
+using OptimizationBase, OptimizationIpopt
 using Zygote
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
@@ -217,7 +217,7 @@ sol = solve(prob, IpoptOptimizer())
 Solving problems with nonlinear equality and inequality constraints:
 
 ```@example Ipopt3
-using Optimization, OptimizationIpopt
+using OptimizationBase, OptimizationIpopt
 using Zygote
 
 # Objective: minimize x[1]^2 + x[2]^2
@@ -247,7 +247,7 @@ sol = solve(prob, IpoptOptimizer())
 For large-scale problems where computing the exact Hessian is expensive:
 
 ```@example Ipopt4
-using Optimization, OptimizationIpopt
+using OptimizationBase, OptimizationIpopt
 using Zygote
 
 # Large-scale problem
@@ -273,7 +273,7 @@ sol = solve(prob, IpoptOptimizer(
 A practical example of portfolio optimization with constraints:
 
 ```@example Ipopt5
-using Optimization, OptimizationIpopt
+using OptimizationBase, OptimizationIpopt
 using Zygote
 using LinearAlgebra
 

docs/src/optimization_packages/madnlp.md

@@ -20,7 +20,7 @@ OptimizationMadNLP.MadNLPOptimizer
 ## Example
 
 ```julia
-using Optimization, OptimizationMadNLP, ADTypes
+using OptimizationBase, OptimizationMadNLP, ADTypes
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 optf = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())

docs/src/optimization_packages/manopt.md

@@ -50,7 +50,7 @@ function or `OptimizationProblem`.
 The Rosenbrock function on the Euclidean manifold can be optimized using the `GradientDescentOptimizer` as follows:
 
 ```@example Manopt
-using Optimization, OptimizationManopt, Manifolds, LinearAlgebra, ADTypes, Zygote
+using OptimizationBase, OptimizationManopt, Manifolds, LinearAlgebra, ADTypes, 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]
@@ -65,7 +65,7 @@ optf = OptimizationFunction(rosenbrock, ADTypes.AutoZygote())
 prob = OptimizationProblem(
     optf, x0, p; manifold = R2, stepsize = stepsize)
 
-sol = Optimization.solve(prob, opt)
+sol = OptimizationBase.solve(prob, opt)
 ```
 
 The box-constrained Karcher mean problem on the SPD manifold with the Frank-Wolfe algorithm can be solved as follows:
@@ -103,7 +103,7 @@ L = inv(sum(1 / N * inv(matrix) for matrix in data2))
 optf = OptimizationFunction(f, ADTypes.AutoZygote())
 prob = OptimizationProblem(optf, U; manifold = M, maxiters = 1000)
 
-sol = Optimization.solve(
+sol = OptimizationBase.solve(
     prob, opt, sub_problem = (M, q, p, X) -> closed_form_solution!(M, q, L, U, p, X))
 ```
 
@@ -113,7 +113,7 @@ The following example is adapted from the Rayleigh Quotient example in ManoptExa
 We solve the Rayleigh quotient problem on the Sphere manifold:
 
 ```@example Manopt
-using Optimization, OptimizationManopt
+using OptimizationBase, OptimizationManopt
 using Manifolds, LinearAlgebra
 using Manopt
 

docs/src/optimization_packages/mathoptinterface.md

@@ -69,13 +69,13 @@ sol = solve(prob, Ipopt.Optimizer(); option_name = option_value, ...)
     detail.
 
 ```@example MOI
-using Optimization, OptimizationMOI, Juniper, Ipopt, ADTypes, ForwardDiff
+using OptimizationBase, OptimizationMOI, Juniper, Ipopt, ADTypes, ForwardDiff
 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, ADTypes.AutoForwardDiff())
-prob = SciMLBase.OptimizationProblem(f, x0, _p)
+prob = OptimizationProblem(f, x0, _p)
 
 opt = OptimizationMOI.MOI.OptimizerWithAttributes(Juniper.Optimizer,
     "nl_solver" => OptimizationMOI.MOI.OptimizerWithAttributes(Ipopt.Optimizer,

docs/src/optimization_packages/metaheuristics.md

@@ -52,12 +52,12 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 The Rosenbrock function can be optimized using the Evolutionary Centers Algorithm `ECA()` as follows:
 
 ```@example Metaheuristics
-using Optimization, OptimizationMetaheuristics
+using OptimizationBase, OptimizationMetaheuristics
 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 = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, ECA(), maxiters = 100000, maxtime = 1000.0)
 ```
 

docs/src/optimization_packages/multistartoptimization.md

@@ -32,12 +32,12 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 The Rosenbrock function can be optimized using `MultistartOptimization.TikTak()` with 100 initial points and the local method `NLopt.LD_LBFGS()` as follows:
 
 ```julia
-using Optimization, OptimizationMultistartOptimization, OptimizationNLopt, ADTypes, ForwardDiff
+using OptimizationBase, OptimizationMultistartOptimization, OptimizationNLopt, ADTypes, ForwardDiff
 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, ADTypes.AutoForwardDiff())
-prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, MultistartOptimization.TikTak(100), NLopt.LD_LBFGS())
 ```
 
@@ -46,6 +46,6 @@ You can use any `Optimization` optimizers you like. The global method of the `Mu
 ```julia
 using OptimizationOptimJL
 f = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
-prob = SciMLBase.OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
+prob = OptimizationProblem(f, x0, p, lb = [-1.0, -1.0], ub = [1.0, 1.0])
 sol = solve(prob, MultistartOptimization.TikTak(100), LBFGS(), maxiters = 5)
 ```