refactor: update from old generate_* syntax

AayushSabharwal · AayushSabharwal · commit 8ed2e02d93b5 · 2025-05-26T23:11:12.000+05:30
diff --git a/src/problems/daeproblem.jl b/src/problems/daeproblem.jl
@@ -7,9 +7,7 @@
     check_complete(sys, DAEFunction)
     check_compatibility && check_compatible_system(DAEFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         implicit_dae = true, eval_expression, eval_module, checkbounds = checkbounds, cse,
         kwargs...)
 
@@ -25,7 +23,7 @@
     end
 
     if jac
-        _jac = generate_dae_jacobian(sys, dvs, ps; expression,
+        _jac = generate_dae_jacobian(sys; expression,
             wrap_gfw = Val{true}, simplify, sparse, cse, eval_expression, eval_module,
             checkbounds, kwargs...)
     else
diff --git a/src/problems/ddeproblem.jl b/src/problems/ddeproblem.jl
@@ -6,10 +6,7 @@
     check_complete(sys, DDEFunction)
     check_compatibility && check_compatible_system(DDEFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         eval_expression, eval_module, checkbounds = checkbounds, cse,
         kwargs...)
 
diff --git a/src/problems/discreteproblem.jl b/src/problems/discreteproblem.jl
@@ -7,9 +7,7 @@
     check_complete(sys, DiscreteFunction)
     check_compatibility && check_compatible_system(DiscreteFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         eval_expression, eval_module, checkbounds = checkbounds, cse,
         kwargs...)
 
@@ -45,7 +43,7 @@ end
     check_compatibility && check_compatible_system(DiscreteProblem, sys)
 
     dvs = unknowns(sys)
-    u0map = to_varmap(u0map, dvs)
+    u0map = to_varmap(op, dvs)
     add_toterms!(u0map; replace = true)
     f, u0, p = process_SciMLProblem(DiscreteFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility, expression,
diff --git a/src/problems/implicitdiscreteproblem.jl b/src/problems/implicitdiscreteproblem.jl
@@ -9,8 +9,7 @@
 
     iv = get_iv(sys)
     dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         implicit_dae = true, eval_expression, eval_module, checkbounds = checkbounds, cse,
         override_discrete = true, kwargs...)
 
diff --git a/src/problems/intervalnonlinearproblem.jl b/src/problems/intervalnonlinearproblem.jl
@@ -6,9 +6,7 @@ function SciMLBase.IntervalNonlinearFunction(
     check_complete(sys, IntervalNonlinearFunction)
     check_compatibility && check_compatible_system(IntervalNonlinearFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         scalar = true, eval_expression, eval_module, checkbounds, cse, kwargs...)
 
     observedfun = ObservedFunctionCache(
diff --git a/src/problems/nonlinearproblem.jl b/src/problems/nonlinearproblem.jl
@@ -8,9 +8,7 @@
     check_complete(sys, NonlinearFunction)
     check_compatibility && check_compatible_system(NonlinearFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         eval_expression, eval_module, checkbounds = checkbounds, cse,
         kwargs...)
 
diff --git a/src/problems/odeproblem.jl b/src/problems/odeproblem.jl
@@ -7,9 +7,7 @@
     check_complete(sys, ODEFunction)
     check_compatibility && check_compatible_system(ODEFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         eval_expression, eval_module, checkbounds = checkbounds, cse,
         kwargs...)
 
@@ -26,7 +24,7 @@
 
     if tgrad
         _tgrad = generate_tgrad(
-            sys, dvs, ps; expression, wrap_gfw = Val{true},
+            sys; expression, wrap_gfw = Val{true},
             simplify, cse, eval_expression, eval_module, checkbounds, kwargs...)
     else
         _tgrad = nothing
diff --git a/src/problems/optimizationproblem.jl b/src/problems/optimizationproblem.jl
@@ -10,8 +10,7 @@ function SciMLBase.OptimizationFunction{iip}(sys::System;
         expression = Val{false}, kwargs...) where {iip}
     check_complete(sys, OptimizationFunction)
     check_compatibility && check_compatible_system(OptimizationFunction, sys)
-    dvs = unknowns(sys)
-    ps = parameters(sys)
+
     cstr = constraints(sys)
 
     f = generate_cost(sys; expression, wrap_gfw = Val{true}, eval_expression,
diff --git a/src/problems/sddeproblem.jl b/src/problems/sddeproblem.jl
@@ -6,12 +6,9 @@
     check_complete(sys, SDDEFunction)
     check_compatibility && check_compatible_system(SDDEFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         eval_expression, eval_module, checkbounds = checkbounds, cse, kwargs...)
-    g = generate_diffusion_function(sys, dvs, ps; expression,
+    g = generate_diffusion_function(sys; expression,
         wrap_gfw = Val{true}, eval_expression, eval_module, checkbounds, cse, kwargs...)
 
     if spec === SciMLBase.FunctionWrapperSpecialize && iip
diff --git a/src/problems/sdeproblem.jl b/src/problems/sdeproblem.jl
@@ -7,12 +7,10 @@
     check_complete(sys, SDEFunction)
     check_compatibility && check_compatible_system(SDEFunction, sys)
 
-    dvs = unknowns(sys)
-    ps = parameters(sys)
-    f = generate_rhs(sys, dvs, ps; expression, wrap_gfw = Val{true},
+    f = generate_rhs(sys; expression, wrap_gfw = Val{true},
         eval_expression, eval_module, checkbounds = checkbounds, cse,
         kwargs...)
-    g = generate_diffusion_function(sys, dvs, ps; expression,
+    g = generate_diffusion_function(sys; expression,
         wrap_gfw = Val{true}, eval_expression, eval_module, checkbounds, cse, kwargs...)
 
     if spec === SciMLBase.FunctionWrapperSpecialize && iip
@@ -27,7 +25,7 @@
     end
 
     if tgrad
-        _tgrad = generate_tgrad(sys, dvs, ps; expression,
+        _tgrad = generate_tgrad(sys; expression,
             wrap_gfw = Val{true}, simplify, cse, eval_expression, eval_module, checkbounds,
             kwargs...)
     else
diff --git a/test/nonlinearsystem.jl b/test/nonlinearsystem.jl
@@ -29,7 +29,7 @@ eqs = [0 ~ σ * (y - x) * h,
 @test eval(toexpr(ns)) == ns
 test_nlsys_inference("standard", ns, (x, y, z), (σ, ρ, β, h))
 @test begin
-    f = generate_rhs(ns, [x, y, z], [σ, ρ, β, h], expression = Val{false})[2]
+    f = generate_rhs(ns, expression = Val{false})[2]
     du = [0.0, 0.0, 0.0]
     f(du, [1, 2, 3], [1, 2, 3, 1])
     du ≈ [1, -3, -7]
@@ -65,7 +65,7 @@ eqs = [0 ~ σ * a * h,
     0 ~ x * y - β * z]
 @named ns = System(eqs, [x, y, z], [σ, ρ, β, h])
 ns = complete(ns)
-nlsys_func = generate_rhs(ns, [x, y, z], [σ, ρ, β, h])
+nlsys_func = generate_rhs(ns)
 nf = NonlinearFunction(ns)
 jac = calculate_jacobian(ns)
 
diff --git a/test/odesystem.jl b/test/odesystem.jl
@@ -148,7 +148,7 @@ f(du, [1.0, 2.0, 3.0], [x -> x + 7, 2, 3, 1], 5.0)
 eqs = [D(x) ~ x + 10σ(t - 1) + 100σ(t - 2) + 1000σ(t^2)]
 @named de = System(eqs, t)
 test_diffeq_inference("many internal iv-varying", de, t, (x,), (σ,))
-f = generate_rhs(de, [x], [σ], expression = Val{false}, wrap_gfw = Val{true})
+f = generate_rhs(de, expression = Val{false}, wrap_gfw = Val{true})
 du = [0.0]
 f(du, [1.0], [t -> t + 2], 5.0)
 @test du ≈ [27561]
@@ -173,7 +173,7 @@ eqs = [D(x) ~ -A * x,
 @named de = System(eqs, t)
 @test begin
     local f, du
-    f = generate_rhs(de, [x, y], [A, B, C], expression = Val{false}, wrap_gfw = Val{true})
+    f = generate_rhs(de, expression = Val{false}, wrap_gfw = Val{true})
     du = [0.0, 0.0]
     f(du, [1.0, 2.0], [1, 2, 3], 0.0)
     du ≈ [-1, -1 / 3]
