fix: update InfiniteOpt extension to new semantics

Author: AayushSabharwal

ext/MTKInfiniteOptExt.jl

@@ -150,29 +150,28 @@ function set_jump_bounds!(model, sys, pmap)
     for (i, u) in enumerate(unknowns(sys))
         if MTK.hasbounds(u)
             lo, hi = MTK.getbounds(u)
-            set_lower_bound(U[i], Symbolics.fixpoint_sub(lo, pmap))
-            set_upper_bound(U[i], Symbolics.fixpoint_sub(hi, pmap))
+            set_lower_bound(U[i], Symbolics.fast_substitute(lo, pmap))
+            set_upper_bound(U[i], Symbolics.fast_substitute(hi, pmap))
         end
     end
 
     V = model[:V]
     for (i, v) in enumerate(MTK.unbound_inputs(sys))
         if MTK.hasbounds(v)
             lo, hi = MTK.getbounds(v)
-            set_lower_bound(V[i], Symbolics.fixpoint_sub(lo, pmap))
-            set_upper_bound(V[i], Symbolics.fixpoint_sub(hi, pmap))
+            set_lower_bound(V[i], Symbolics.fast_substitute(lo, pmap))
+            set_upper_bound(V[i], Symbolics.fast_substitute(hi, pmap))
         end
     end
 end
 
 function add_jump_cost_function!(model::InfiniteModel, sys, tspan, pmap; is_free_t = false)
-    jcosts = MTK.get_costs(sys)
-    consolidate = MTK.get_consolidate(sys)
-    if isnothing(jcosts) || isempty(jcosts)
+    jcosts = cost(sys)
+    if Symbolics._iszero(jcosts)
         @objective(model, Min, 0)
         return
     end
-    jcosts = substitute_jump_vars(model, sys, pmap, jcosts; is_free_t)
+    jcosts = substitute_jump_vars(model, sys, pmap, [jcosts]; is_free_t)[1]
     tₛ = is_free_t ? model[:tf] : 1
 
     # Substitute integral
@@ -187,17 +186,18 @@ function add_jump_cost_function!(model::InfiniteModel, sys, tspan, pmap; is_free
         hi = haskey(pmap, hi) ? 1 : MTK.value(hi)
         intmap[int] = tₛ * InfiniteOpt.∫(arg, model[:t], lo, hi)
     end
-    jcosts = map(c -> Symbolics.substitute(c, intmap), jcosts)
-    @objective(model, Min, consolidate(jcosts))
+    jcosts = Symbolics.substitute(jcosts, intmap)
+    @objective(model, Min, MTK.value(jcosts))
 end
 
 function add_user_constraints!(model::InfiniteModel, sys, pmap; is_free_t = false)
-    conssys = MTK.get_constraintsystem(sys)
-    jconstraints = isnothing(conssys) ? nothing : MTK.get_constraints(conssys)
+    jconstraints = MTK.get_constraints(sys)
     (isnothing(jconstraints) || isempty(jconstraints)) && return nothing
+    cons_dvs, cons_ps = MTK.process_constraint_system(
+        jconstraints, Set(unknowns(sys)), parameters(sys), MTK.get_iv(sys); validate = false)
 
     if is_free_t
-        for u in MTK.get_unknowns(conssys)
+        for u in cons_dvs
             x = MTK.operation(u)
             t = only(arguments(u))
             if (MTK.symbolic_type(t) === MTK.NotSymbolic())
@@ -206,7 +206,7 @@ function add_user_constraints!(model::InfiniteModel, sys, pmap; is_free_t = fals
         end
     end
 
-    auxmap = Dict([u => MTK.default_toterm(MTK.value(u)) for u in unknowns(conssys)])
+    auxmap = Dict([u => MTK.default_toterm(MTK.value(u)) for u in cons_dvs])
     jconstraints = substitute_jump_vars(model, sys, pmap, jconstraints; auxmap, is_free_t)
 
     # Substitute to-term'd variables
@@ -235,25 +235,25 @@ function substitute_jump_vars(model, sys, pmap, exprs; auxmap = Dict(), is_free_
     x_ops = [MTK.operation(MTK.unwrap(st)) for st in sts]
     c_ops = [MTK.operation(MTK.unwrap(ct)) for ct in cts]
 
-    exprs = map(c -> Symbolics.fixpoint_sub(c, auxmap), exprs)
-    exprs = map(c -> Symbolics.fixpoint_sub(c, Dict(pmap)), exprs)
+    exprs = map(c -> Symbolics.fast_substitute(c, auxmap), exprs)
+    exprs = map(c -> Symbolics.fast_substitute(c, Dict(pmap)), exprs)
     if is_free_t
         tf = model[:tf]
         free_t_map = Dict([[x(tf) => U[i](1) for (i, x) in enumerate(x_ops)];
                            [c(tf) => V[i](1) for (i, c) in enumerate(c_ops)]])
-        exprs = map(c -> Symbolics.fixpoint_sub(c, free_t_map), exprs)
+        exprs = map(c -> Symbolics.fast_substitute(c, free_t_map), exprs)
     end
 
     # for variables like x(t)
     whole_interval_map = Dict([[v => U[i] for (i, v) in enumerate(sts)];
                                [v => V[i] for (i, v) in enumerate(cts)]])
-    exprs = map(c -> Symbolics.fixpoint_sub(c, whole_interval_map), exprs)
+    exprs = map(c -> Symbolics.fast_substitute(c, whole_interval_map), exprs)
 
     # for variables like x(1.0)
     fixed_t_map = Dict([[x_ops[i] => U[i] for i in 1:length(U)];
                         [c_ops[i] => V[i] for i in 1:length(V)]])
 
-    exprs = map(c -> Symbolics.fixpoint_sub(c, fixed_t_map), exprs)
+    exprs = map(c -> Symbolics.fast_substitute(c, fixed_t_map), exprs)
     exprs
 end