fix deprecations

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

Author: SebastianM-C

docs/src/API/ad.md

@@ -7,7 +7,7 @@ The choices for the auto-AD fill-ins with quick descriptions are:
   - `AutoTracker()`: Like ReverseDiff but GPU-compatible
   - `AutoZygote()`: The fastest choice for non-mutating array-based (BLAS) functions
   - `AutoFiniteDiff()`: Finite differencing, not optimal but always applicable
-  - `AutoModelingToolkit()`: The fastest choice for large scalar optimizations
+  - `AutoSymbolics()`: The fastest choice for large scalar optimizations
   - `AutoEnzyme()`: Highly performant AD choice for type stable and optimized code
   - `AutoMooncake()`: Like Zygote and ReverseDiff, but supports GPU and mutating code
 
@@ -21,7 +21,7 @@ OptimizationBase.AutoFiniteDiff
 OptimizationBase.AutoReverseDiff
 OptimizationBase.AutoZygote
 OptimizationBase.AutoTracker
-OptimizationBase.AutoModelingToolkit
+OptimizationBase.AutoSymbolics
 OptimizationBase.AutoEnzyme
 ADTypes.AutoMooncake
 ```

docs/src/API/modelingtoolkit.md

@@ -7,7 +7,7 @@ optimization of code. Optimizers can better interface with the extra
 symbolic information provided by the system.
 
 There are two ways that the user interacts with ModelingToolkit.jl.
-One can use `OptimizationFunction` with `AutoModelingToolkit` for
+One can use `OptimizationFunction` with `AutoSymbolics` for
 automatically transforming numerical codes into symbolic codes. See
 the [OptimizationFunction documentation](@ref optfunction) for more
 details.

docs/src/examples/rosenbrock.md

@@ -5,7 +5,7 @@ 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
@@ -14,12 +14,12 @@ for common workflows of the package and give copy-pastable starting points.
 The objective of this exercise is to determine the $(x, y)$ value pair that minimizes the result of a Rosenbrock function $f$ with some parameter values $a$ and $b$. The Rosenbrock function is useful for testing because it is known *a priori* to have a global minimum at $(a, a^2)$.
 ```math
 f(x,\,y;\,a,\,b) = \left(a - x\right)^2 + b \left(y - x^2\right)^2
-``` 
+```
 
 The Optimization.jl interface expects functions to be defined with a vector of optimization arguments $\bar{x}$ and a vector of parameters $\bar{p}$, i.e.:
 ```math
 f(\bar{x},\,\bar{p}) = \left(p_1 - x_1\right)^2 + p_2 \left(x_2 - x_1^2\right)^2
-``` 
+```
 
 Parameters $a$ and $b$ are captured in a vector $\bar{p}$ and assigned some arbitrary values to produce a particular Rosenbrock function to be minimized.
 ```math
@@ -164,7 +164,7 @@ sol = solve(prob, CMAEvolutionStrategyOpt())
 
 ```@example rosenbrock
 using OptimizationNLopt, ModelingToolkit
-optf = OptimizationFunction(rosenbrock, Optimization.AutoModelingToolkit())
+optf = OptimizationFunction(rosenbrock, Optimization.AutoSymbolics())
 prob = OptimizationProblem(optf, x0, _p)
 
 sol = solve(prob, Opt(:LN_BOBYQA, 2))

docs/src/optimization_packages/mathoptinterface.md

@@ -20,7 +20,7 @@ the `maxtime` common keyword argument.
 `OptimizationMOI` supports an argument `mtkize` which takes a boolean (default to `false`)
 that allows automatic symbolic expression generation, this allows using any AD backend with
 solvers or interfaces such as AmplNLWriter that require the expression graph of the objective
-and constraints. This always happens automatically in the case of the `AutoModelingToolkit`
+and constraints. This always happens automatically in the case of the `AutoSymbolics`
 `adtype`.
 
 An optimizer which supports the `MathOptInterface` API can be called
@@ -94,7 +94,7 @@ The following shows how to use integer linear programming within `Optimization`.
     [Juniper documentation](https://github.com/lanl-ansi/Juniper.jl) for more
     detail.
   - The integer domain is inferred based on the bounds of the variable:
-    
+
       + Setting the lower bound to zero and the upper bound to one corresponds to `MOI.ZeroOne()` or a binary decision variable
       + Providing other or no bounds corresponds to `MOI.Integer()`
 

docs/src/optimization_packages/optim.md

@@ -340,7 +340,7 @@ using Optimization, OptimizationOptimJL, ModelingToolkit
 rosenbrock(x, p) = (1 - x[1])^2 + 100 * (x[2] - x[1]^2)^2
 x0 = zeros(2)
 p = [1.0, 100.0]
-f = OptimizationFunction(rosenbrock, Optimization.AutoModelingToolkit())
+f = OptimizationFunction(rosenbrock, Optimization.AutoSymbolics())
 prob = Optimization.OptimizationProblem(f, x0, p)
 sol = solve(prob, Optim.Newton())
 ```

docs/src/tutorials/constraints.md

@@ -81,7 +81,7 @@ x_1 * x_2 = 0.5
 ```
 
 ```@example constraints
-optprob = OptimizationFunction(rosenbrock, Optimization.AutoModelingToolkit(), cons = cons)
+optprob = OptimizationFunction(rosenbrock, Optimization.AutoSymbolics(), cons = cons)
 prob = OptimizationProblem(optprob, x0, _p, lcons = [1.0, 0.5], ucons = [1.0, 0.5])
 ```
 

docs/src/tutorials/linearandinteger.md

@@ -91,7 +91,7 @@ objective = (u, p) -> (v = p[1:5]; dot(v, u))
 
 cons = (res, u, p) -> (w = p[6:10]; res .= [sum(w[i] * u[i]^2 for i in 1:5)])
 
-optf = OptimizationFunction(objective, Optimization.AutoModelingToolkit(), cons = cons)
+optf = OptimizationFunction(objective, Optimization.AutoSymbolics(), cons = cons)
 optprob = OptimizationProblem(optf,
     zeros(5),
     vcat(v, w);

lib/OptimizationBase/ext/OptimizationMTKExt.jl

@@ -3,7 +3,7 @@ module OptimizationMTKExt
 import OptimizationBase, OptimizationBase.ArrayInterface
 import SciMLBase
 import SciMLBase: OptimizationFunction
-import OptimizationBase.ADTypes: AutoModelingToolkit, AutoSymbolics, AutoSparse
+import OptimizationBase.ADTypes: AutoSymbolics, AutoSparse
 using ModelingToolkit
 
 function OptimizationBase.instantiate_function(

lib/OptimizationMOI/src/moi.jl

@@ -16,14 +16,14 @@ function MOIOptimizationCache(prob::OptimizationProblem, opt; kwargs...)
     f = prob.f
     reinit_cache = OptimizationBase.ReInitCache(prob.u0, prob.p)
     if isnothing(f.sys)
-        if f.adtype isa OptimizationBase.AutoModelingToolkit
+        if f.adtype isa OptimizationBase.AutoSymbolics
             num_cons = prob.ucons === nothing ? 0 : length(prob.ucons)
             f = OptimizationBase.instantiate_function(prob.f,
                 reinit_cache,
                 prob.f.adtype,
                 num_cons)
         else
-            throw(ArgumentError("Expected an `OptimizationProblem` that was setup via an `OptimizationSystem`, or AutoModelingToolkit ad choice"))
+            throw(ArgumentError("Expected an `OptimizationProblem` that was setup via an `OptimizationSystem`, or AutoSymbolics ad choice"))
         end
     end
 
@@ -35,16 +35,16 @@ function MOIOptimizationCache(prob::OptimizationProblem, opt; kwargs...)
     cons_expr = Vector{Expr}(undef, length(cons))
     Threads.@sync for i in eachindex(cons)
         Threads.@spawn if prob.lcons[i] == prob.ucons[i] == 0
-            cons_expr[i] = Expr(:call, :(==), 
+            cons_expr[i] = Expr(:call, :(==),
             repl_getindex!(convert_to_expr(f.cons_expr[i],
             expr_map;
-            expand_expr = false)), 0) 
+            expand_expr = false)), 0)
         else
             # MTK canonicalizes the expression form
-            cons_expr[i] = Expr(:call, :(<=), 
+            cons_expr[i] = Expr(:call, :(<=),
             repl_getindex!(convert_to_expr(f.cons_expr[i],
             expr_map;
-            expand_expr = false)), 0) 
+            expand_expr = false)), 0)
         end
     end
 

lib/OptimizationMOI/test/runtests.jl

@@ -37,7 +37,7 @@ end
     _p = [1.0, 100.0]
     cons_circ = (res, x, p) -> res .= [x[1]^2 + x[2]^2]
     optprob = OptimizationFunction(
-        rosenbrock, OptimizationBase.AutoZygote();
+        rosenbrock, AutoZygote();
         cons = cons_circ)
     prob = OptimizationProblem(optprob, x0, _p, ucons = [Inf], lcons = [0.0])
     evaluator = init(prob, Ipopt.Optimizer()).evaluator
@@ -63,7 +63,7 @@ end
     _p = [1.0, 100.0]
     l1 = rosenbrock(x0, _p)
 
-    optprob = OptimizationFunction((x, p) -> -rosenbrock(x, p), OptimizationBase.AutoZygote())
+    optprob = OptimizationFunction((x, p) -> -rosenbrock(x, p), AutoZygote())
     prob = OptimizationProblem(optprob, x0, _p; sense = OptimizationBase.MaxSense)
 
     callback = function (state, l)
@@ -79,7 +79,7 @@ end
     sol = solve!(cache)
     @test 10 * sol.objective < l1
 
-    optprob = OptimizationFunction(rosenbrock, OptimizationBase.AutoZygote())
+    optprob = OptimizationFunction(rosenbrock, AutoZygote())
     prob = OptimizationProblem(optprob, x0, _p; sense = OptimizationBase.MinSense)
 
     opt = Ipopt.Optimizer()
@@ -126,7 +126,7 @@ end
 
     cons_circ = (res, x, p) -> res .= [x[1]^2 + x[2]^2]
     optprob = OptimizationFunction(
-        rosenbrock, OptimizationBase.AutoModelingToolkit(true, true);
+        rosenbrock, AutoSparse(AutoSymbolics());
         cons = cons_circ)
     prob = OptimizationProblem(optprob, x0, _p, ucons = [Inf], lcons = [0.0])
 
@@ -141,10 +141,8 @@ end
 
 @testset "backends" begin
     backends = (
-        OptimizationBase.AutoModelingToolkit(false, false),
-        OptimizationBase.AutoModelingToolkit(true, false),
-        OptimizationBase.AutoModelingToolkit(false, true),
-        OptimizationBase.AutoModelingToolkit(true, true))
+        AutoSymbolics(),
+        AutoSparse(AutoSymbolics()))
     for backend in backends
         @testset "$backend" begin
             _test_sparse_derivatives_hs071(backend, Ipopt.Optimizer())
@@ -167,7 +165,7 @@ end
         u0 = [0.0, 0.0, 0.0, 1.0]
 
         optfun = OptimizationFunction((u, p) -> -v'u, cons = (res, u, p) -> res .= w'u,
-            OptimizationBase.AutoForwardDiff())
+            AutoForwardDiff())
 
         optprob = OptimizationProblem(optfun, u0; lb = zero.(u0), ub = one.(u0),
             int = ones(Bool, length(u0)),
@@ -185,7 +183,7 @@ end
         u0 = [1.0]
 
         optfun = OptimizationFunction((u, p) -> sum(abs2, x * u[1] .- y),
-            OptimizationBase.AutoForwardDiff())
+            AutoForwardDiff())
 
         optprob = OptimizationProblem(optfun, u0; lb = one.(u0), ub = 6.0 .* u0,
             int = ones(Bool, length(u0)))
@@ -264,7 +262,7 @@ end
 
     cons(res, x, p) = (res .= [x[1]^2 + x[2]^2, x[1] * x[2]])
 
-    optprob = OptimizationFunction(rosenbrock, OptimizationBase.AutoModelingToolkit();
+    optprob = OptimizationFunction(rosenbrock, AutoSymbolics();
         cons = cons)
     prob = OptimizationProblem(optprob, x0, _p, lcons = [1.0, 0.5], ucons = [1.0, 0.5])
     sol = solve(prob, AmplNLWriter.Optimizer(Ipopt_jll.amplexe))
@@ -285,7 +283,7 @@ end
     end
     lag_hess_prototype = sparse([1 1; 0 1])
 
-    optprob = OptimizationFunction(rosenbrock, OptimizationBase.AutoForwardDiff();
+    optprob = OptimizationFunction(rosenbrock, AutoForwardDiff();
         cons = cons, lag_h = lagh, lag_hess_prototype)
     prob = OptimizationProblem(optprob, x0, _p, lcons = [1.0, 0.5], ucons = [1.0, 0.5])
     sol = solve(prob, Ipopt.Optimizer())