Remove var=var keyword argument repetition in function calls

docs/make.jl

@@ -9,7 +9,7 @@ using Plots
 
 include("pages.jl")
 
-makedocs(
+makedocs(;
     sitename = "SciMLSensitivity.jl",
     authors = "Chris Rackauckas et al.",
     modules = [SciMLSensitivity],
@@ -19,7 +19,7 @@ makedocs(
         assets = ["assets/favicon.ico"],
         canonical = "https://docs.sciml.ai/SciMLSensitivity/stable/"
     ),
-    pages = pages
+    pages
 )
 
 deploydocs(

docs/src/Benchmark.md

@@ -70,7 +70,7 @@ for sensealg in (SMS.InterpolatingAdjoint(autojacvec = SMS.ZygoteVJP()),
     SMS.QuadratureAdjoint(autojacvec = SMS.ReverseDiffVJP(true)),
     SMS.TrackerAdjoint())
     prob_neuralode = SMS.NeuralODE(dudt2, tspan, ODE.Tsit5(); saveat = tsteps,
-        sensealg = sensealg)
+        sensealg)
     ps, st = Lux.setup(Random.default_rng(), prob_neuralode)
     ps = CA.ComponentArray(ps)
 

docs/src/examples/dde/delay_diffeq.md

@@ -34,8 +34,8 @@ prob_dde = DDE.DDEProblem(delay_lotka_volterra!, u0, h, (0.0, 10.0),
     constant_lags = [0.1])
 
 function predict_dde(p)
-    return Array(ODE.solve(prob_dde, DDE.MethodOfSteps(ODE.Tsit5()),
-        u0 = u0, p = p, saveat = 0.1, sensealg = SMS.ReverseDiffAdjoint()))
+    return Array(ODE.solve(prob_dde, DDE.MethodOfSteps(ODE.Tsit5());
+        u0, p, saveat = 0.1, sensealg = SMS.ReverseDiffAdjoint()))
 end
 
 loss_dde(p) = sum(abs2, x - 1 for x in predict_dde(p))
@@ -53,7 +53,7 @@ end
 adtype = OPT.AutoZygote()
 optf = OPT.OptimizationFunction((x, p) -> loss_dde(x), adtype)
 optprob = OPT.OptimizationProblem(optf, p)
-result_dde = OPT.solve(optprob, OPA.PolyOpt(), maxiters = 300, callback = callback)
+result_dde = OPT.solve(optprob, OPA.PolyOpt(); maxiters = 300, callback)
 ```
 
 Notice that we chose `sensealg = ReverseDiffAdjoint()` to utilize the ReverseDiff.jl
@@ -79,5 +79,5 @@ We use `Optimization.solve` to optimize the parameters for our loss function:
 adtype = OPT.AutoZygote()
 optf = OPT.OptimizationFunction((x, p) -> loss_dde(x), adtype)
 optprob = OPT.OptimizationProblem(optf, p)
-result_dde = OPT.solve(optprob, OPA.PolyOpt(), callback = callback)
+result_dde = OPT.solve(optprob, OPA.PolyOpt(); callback)
 ```

docs/src/examples/hybrid_jump/bouncing_ball.md

@@ -32,7 +32,7 @@ u0 = [50.0, 0.0]
 tspan = (0.0, 15.0)
 p = [9.8, 0.8]
 prob = ODE.ODEProblem(f, u0, tspan, p)
-sol = ODE.solve(prob, ODE.Tsit5(), callback = callback)
+sol = ODE.solve(prob, ODE.Tsit5(); callback)
 ```
 
 Here we have a friction coefficient of `0.8`. We want to refine this
@@ -42,7 +42,7 @@ the value 20:
 
 ```@example bouncing_ball
 function loss(θ)
-    sol = ODE.solve(prob, ODE.Tsit5(), p = [9.8, θ[1]], callback = callback)
+    sol = ODE.solve(prob, ODE.Tsit5(), p = [9.8, θ[1]]; callback)
     target = 20.0
     abs2(sol[end][1] - target)
 end

docs/src/examples/hybrid_jump/hybrid_diffeq.md

@@ -49,10 +49,10 @@ affect!(integrator) = integrator.u[1:2] .= integrator.u[3:end]
 cb = DEC.PresetTimeCallback(dosetimes, affect!, save_positions = (false, false))
 
 function predict_n_ode(p)
-    _prob = ODE.remake(prob, p = p)
-    Array(ODE.solve(_prob, ODE.Tsit5(), u0 = z0, p = p, callback = cb, saveat = t,
+    _prob = ODE.remake(prob; p)
+    Array(ODE.solve(_prob, ODE.Tsit5(); u0 = z0, p, callback = cb, saveat = t,
         sensealg = SMS.ReverseDiffAdjoint()))[1:2, :]
-    #Array(solve(prob,Tsit5(),u0=z0,p=p,saveat=t))[1:2,:]
+    #Array(solve(prob,Tsit5();u0=z0,p,saveat=t))[1:2,:]
 end
 
 function loss_n_ode(p, _)

docs/src/examples/neural_ode/simplechains.md

@@ -48,7 +48,7 @@ Now instead of the function `trueODE(u,p,t)` in the first code block, we pass th
 prob_nn = ODE.ODEProblem(f, u0, tspan)
 
 function predict_neuralode(p)
-    Array(ODE.solve(prob_nn, ODE.Tsit5(); p = p, saveat = tsteps,
+    Array(ODE.solve(prob_nn, ODE.Tsit5(); p, saveat = tsteps,
         sensealg = SMS.QuadratureAdjoint(autojacvec = SMS.ZygoteVJP())))
 end
 
@@ -77,9 +77,8 @@ callback = function (state, l; doplot = true)
     return false
 end
 
-optf = OPT.OptimizationFunction((x, p) -> loss_neuralode(x),
-    OPT.AutoZygote())
+optf = OPT.OptimizationFunction((x, p) -> loss_neuralode(x), OPT.AutoZygote())
 optprob = OPT.OptimizationProblem(optf, p_nn)
 
-res = OPT.solve(optprob, OPO.Adam(0.05), callback = callback, maxiters = 300)
+res = OPT.solve(optprob, OPO.Adam(0.05); callback, maxiters = 300)
 ```

docs/src/examples/ode/exogenous_input.md

@@ -83,7 +83,7 @@ end
 prob = ODE.ODEProblem(dudt, u0, tspan, nothing)
 
 function predict_neuralode(p)
-    _prob = ODE.remake(prob, p = p)
+    _prob = ODE.remake(prob; p)
     Array(ODE.solve(_prob, ODE.Tsit5(), saveat = tsteps, abstol = 1e-8, reltol = 1e-6))
 end
 

docs/src/examples/ode/prediction_error_method.md

@@ -57,7 +57,7 @@ We also define functions that simulate the system and calculate the loss, given
 
 ```@example PEM
 function simulate(p)
-    _prob = ODE.remake(prob, p = p)
+    _prob = ODE.remake(prob; p)
     ODE.solve(_prob, ODE.Tsit5(), saveat = tsteps, abstol = 1e-8, reltol = 1e-8)
 end
 

docs/src/examples/ode/second_order_adjoints.md

@@ -87,12 +87,10 @@ adtype = OPT.AutoZygote()
 optf = OPT.OptimizationFunction((x, p) -> loss_neuralode(x), adtype)
 
 optprob1 = OPT.OptimizationProblem(optf, ps)
-pstart = OPT.solve(
-    optprob1, OPO.Adam(0.01), callback = callback, maxiters = 100).u
+pstart = OPT.solve(optprob1, OPO.Adam(0.01); callback, maxiters = 100).u
 
 optprob2 = OPT.OptimizationProblem(optf, pstart)
-pmin = OPT.solve(optprob2, OOJ.NewtonTrustRegion(), callback = callback,
-    maxiters = 200)
+pmin = OPT.solve(optprob2, OOJ.NewtonTrustRegion(); callback, maxiters = 200)
 ```
 
 Note that we do not demonstrate `Newton()` because we have not found a single

docs/src/examples/ode/second_order_neural.md

@@ -44,7 +44,7 @@ ff(du, u, p, t) = model(u, p)
 prob = ODE.SecondOrderODEProblem{false}(ff, du0, u0, tspan, ps)
 
 function predict(p)
-    Array(ODE.solve(prob, ODE.Tsit5(), p = p, saveat = t))
+    Array(ODE.solve(prob, ODE.Tsit5(); p, saveat = t))
 end
 
 correct_pos = Float32.(transpose(hcat(collect(0:0.05:1)[2:end], collect(2:-0.05:1)[2:end])))
@@ -65,5 +65,5 @@ adtype = OPT.AutoZygote()
 optf = OPT.OptimizationFunction((x, p) -> loss_n_ode(x), adtype)
 optprob = OPT.OptimizationProblem(optf, ps)
 
-res = OPT.solve(optprob, OPO.Adam(0.01); callback = callback, maxiters = 1000)
+res = OPT.solve(optprob, OPO.Adam(0.01); callback, maxiters = 1000)
 ```

docs/src/examples/pde/brusselator.md

@@ -242,7 +242,7 @@ end
 Finally to run everything:
 
 ```@example bruss
-res = OPT.solve(optprob, OPO.Optimisers.Adam(0.01), callback = callback, maxiters = 100)
+res = OPT.solve(optprob, OPO.Optimisers.Adam(0.01); callback, maxiters = 100)
 ```
 
 ```@example bruss

docs/src/examples/pde/pde_constrained.md

@@ -53,15 +53,15 @@ heat_closure(u, p, t) = heat(u, p, t, xtrs)
 
 # Testing Solver on linear PDE
 prob = ODE.ODEProblem(heat_closure, u0, tspan, p)
-sol = ODE.solve(prob, ODE.Tsit5(), dt = dt, saveat = t);
+sol = ODE.solve(prob, ODE.Tsit5(); dt, saveat = t);
 arr_sol = Array(sol)
 
 Plots.plot(x, sol.u[1], lw = 3, label = "t0", size = (800, 500))
 Plots.plot!(x, sol.u[end], lw = 3, ls = :dash, label = "tMax")
 
 ps = [0.1, 0.2];   # Initial guess for model parameters
 function predict(θ)
-    Array(ODE.solve(prob, ODE.Tsit5(), p = θ, dt = dt, saveat = t))
+    Array(ODE.solve(prob, ODE.Tsit5(); p = θ, dt, saveat = t))
 end
 
 ## Defining Loss function
@@ -193,7 +193,7 @@ will compare to further on.
 ```@example pde2
 # Testing Solver on linear PDE
 prob = ODE.ODEProblem(heat_closure, u0, tspan, p)
-sol = ODE.solve(prob, ODE.Tsit5(), dt = dt, saveat = t);
+sol = ODE.solve(prob, ODE.Tsit5(); dt, saveat = t);
 arr_sol = Array(sol)
 
 Plots.plot(x, sol.u[1], lw = 3, label = "t0", size = (800, 500))
@@ -210,7 +210,7 @@ refer to [here](https://julialang.org/blog/2019/01/fluxdiffeq/).
 ```@example pde2
 ps = [0.1, 0.2];   # Initial guess for model parameters
 function predict(θ)
-    Array(ODE.solve(prob, ODE.Tsit5(), p = θ, dt = dt, saveat = t))
+    Array(ODE.solve(prob, ODE.Tsit5(); p = θ, dt, saveat = t))
 end
 ```
 

docs/src/examples/sde/SDE_control.md

@@ -161,13 +161,13 @@ W1 = cumsum([zero(myparameters.dt); W[1:(end - 1)]], dims = 1)
 NG = DNP.NoiseGrid(myparameters.ts, W1)
 
 # get control pulses
-p_all = CA.ComponentArray(p_nn = p_nn,
+p_all = CA.ComponentArray(; p_nn,
     myparameters = [myparameters.Δ, myparameters.Ωmax, myparameters.κ])
 # define SDE problem
 prob = SDE.SDEProblem{true}(
     qubit_drift!, qubit_diffusion!, vec(u0[:, 1]), myparameters.tspan,
-    p_all,
-    callback = callback, noise = NG)
+    p_all;
+    callback, noise = NG)
 
 #########################################
 # compute loss
@@ -181,7 +181,7 @@ function g(u, p, t)
 end
 
 function loss(p_nn; alg = SDE.EM(), sensealg = SMS.BacksolveAdjoint(autojacvec = SMS.ReverseDiffVJP()))
-    pars = CA.ComponentArray(p_nn = p_nn,
+    pars = CA.ComponentArray(; p_nn,
         myparameters = [myparameters.Δ, myparameters.Ωmax, myparameters.κ])
     u0 = prepare_initial(myparameters.dt, myparameters.numtraj)
 
@@ -191,21 +191,16 @@ function loss(p_nn; alg = SDE.EM(), sensealg = SMS.BacksolveAdjoint(autojacvec =
         W = sqrt(myparameters.dt) * randn(typeof(myparameters.dt), size(myparameters.ts)) #for 1 trajectory
         W1 = cumsum([zero(myparameters.dt); W[1:(end - 1)]], dims = 1)
         NG = DNP.NoiseGrid(myparameters.ts, W1)
-        SDE.remake(prob,
-            u0 = u0tmp,
-            callback = callback,
-            noise = NG)
+        SDE.remake(prob; u0 = u0tmp, callback, noise = NG)
     end
     _prob = SDE.remake(prob, p = pars)
 
-    ensembleprob = SDE.EnsembleProblem(_prob,
-        prob_func = prob_func,
-        safetycopy = true)
+    ensembleprob = SDE.EnsembleProblem(_prob; prob_func, safetycopy = true)
 
-    _sol = SDE.solve(ensembleprob, alg, SDE.EnsembleSerial(),
-        sensealg = sensealg,
+    _sol = SDE.solve(ensembleprob, alg, SDE.EnsembleSerial();
+        sensealg,
         saveat = myparameters.tinterval,
-        dt = myparameters.dt,
+        myparameters.dt,
         adaptive = false,
         trajectories = myparameters.numtraj, batch_size = myparameters.numtraj)
     A = convert(Array, _sol)
@@ -219,7 +214,7 @@ end
 # visualization -- run for new batch
 function visualize(p_nn; alg = SDE.EM())
     u0 = prepare_initial(myparameters.dt, myparameters.numtrajplot)
-    pars = CA.ComponentArray(p_nn = p_nn,
+    pars = CA.ComponentArray(; p_nn,
         myparameters = [myparameters.Δ, myparameters.Ωmax, myparameters.κ])
 
     function prob_func(prob, i, repeat)
@@ -229,20 +224,14 @@ function visualize(p_nn; alg = SDE.EM())
         W1 = cumsum([zero(myparameters.dt); W[1:(end - 1)]], dims = 1)
         NG = DNP.NoiseGrid(myparameters.ts, W1)
 
-        SDE.remake(prob,
-            p = pars,
-            u0 = u0tmp,
-            callback = callback,
-            noise = NG)
+        SDE.remake(prob; p = pars, u0 = u0tmp, callback, noise = NG)
     end
 
-    ensembleprob = SDE.EnsembleProblem(prob,
-        prob_func = prob_func,
-        safetycopy = true)
+    ensembleprob = SDE.EnsembleProblem(prob; prob_func, safetycopy = true)
 
-    u = SDE.solve(ensembleprob, alg, SDE.EnsembleThreads(),
+    u = SDE.solve(ensembleprob, alg, SDE.EnsembleThreads();
         saveat = myparameters.tinterval,
-        dt = myparameters.dt,
+        myparameters.dt,
         adaptive = false, #abstol=1e-6, reltol=1e-6,
         trajectories = myparameters.numtrajplot,
         batch_size = myparameters.numtrajplot)
@@ -501,13 +490,13 @@ W1 = cumsum([zero(myparameters.dt); W[1:(end - 1)]], dims = 1)
 NG = DNP.NoiseGrid(myparameters.ts, W1)
 
 # get control pulses
-p_all = CA.ComponentArray(p_nn = p_nn,
+p_all = CA.ComponentArray(; p_nn,
     myparameters = [myparameters.Δ; myparameters.Ωmax; myparameters.κ])
 # define SDE problem
 prob = SDE.SDEProblem{true}(
     qubit_drift!, qubit_diffusion!, vec(u0[:, 1]), myparameters.tspan,
-    p_all,
-    callback = callback, noise = NG)
+    p_all;
+    callback, noise = NG)
 ```
 
 ### Compute loss function
@@ -534,9 +523,8 @@ function g(u, p, t)
 end
 
 function loss(p_nn; alg = SDE.EM(), sensealg = SMS.BacksolveAdjoint(autojacvec = SMS.ReverseDiffVJP()))
-    pars = CA.ComponentArray(p_nn = p_nn,
-        myparameters = [myparameters.Δ, myparameters.Ωmax,
-            myparameters.κ])
+    pars = CA.ComponentArray(; p_nn,
+        myparameters = [myparameters.Δ, myparameters.Ωmax, myparameters.κ])
     u0 = prepare_initial(myparameters.dt, myparameters.numtraj)
 
     function prob_func(prob, i, repeat)
@@ -546,21 +534,15 @@ function loss(p_nn; alg = SDE.EM(), sensealg = SMS.BacksolveAdjoint(autojacvec =
         W1 = cumsum([zero(myparameters.dt); W[1:(end - 1)]], dims = 1)
         NG = DNP.NoiseGrid(myparameters.ts, W1)
 
-        SDE.remake(prob,
-            p = pars,
-            u0 = u0tmp,
-            callback = callback,
-            noise = NG)
+        SDE.remake(prob; p = pars, u0 = u0tmp, callback, noise = NG)
     end
 
-    ensembleprob = SDE.EnsembleProblem(prob,
-        prob_func = prob_func,
-        safetycopy = true)
+    ensembleprob = SDE.EnsembleProblem(prob; prob_func, safetycopy = true)
 
-    _sol = SDE.solve(ensembleprob, alg, SDE.EnsembleThreads(),
-        sensealg = sensealg,
+    _sol = SDE.solve(ensembleprob, alg, SDE.EnsembleThreads();
+        sensealg,
         saveat = myparameters.tinterval,
-        dt = myparameters.dt,
+        myparameters.dt,
         adaptive = false,
         trajectories = myparameters.numtraj, batch_size = myparameters.numtraj)
     A = convert(Array, _sol)
@@ -580,9 +562,8 @@ a function of the time steps at which loss values are computed.
 ```@example sdecontrol
 function visualize(p_nn; alg = SDE.EM())
     u0 = prepare_initial(myparameters.dt, myparameters.numtrajplot)
-    pars = CA.ComponentArray(p_nn = p_nn,
-        myparameters = [myparameters.Δ, myparameters.Ωmax,
-            myparameters.κ])
+    pars = CA.ComponentArray(; p_nn,
+        myparameters = [myparameters.Δ, myparameters.Ωmax, myparameters.κ])
 
     function prob_func(prob, i, repeat)
         # prepare initial state and applied control pulse
@@ -591,20 +572,14 @@ function visualize(p_nn; alg = SDE.EM())
         W1 = cumsum([zero(myparameters.dt); W[1:(end - 1)]], dims = 1)
         NG = DNP.NoiseGrid(myparameters.ts, W1)
 
-        SDE.remake(prob,
-            p = pars,
-            u0 = u0tmp,
-            callback = callback,
-            noise = NG)
+        SDE.remake(prob; p = pars, u0 = u0tmp, callback, noise = NG)
     end
 
-    ensembleprob = SDE.EnsembleProblem(prob,
-        prob_func = prob_func,
-        safetycopy = true)
+    ensembleprob = SDE.EnsembleProblem(prob; prob_func, safetycopy = true)
 
-    u = SDE.solve(ensembleprob, alg, SDE.EnsembleThreads(),
+    u = SDE.solve(ensembleprob, alg, SDE.EnsembleThreads();
         saveat = myparameters.tinterval,
-        dt = myparameters.dt,
+        myparameters.dt,
         adaptive = false, #abstol=1e-6, reltol=1e-6,
         trajectories = myparameters.numtrajplot,
         batch_size = myparameters.numtrajplot)