Merge pull request #1315 from abhro/semicolons

Remove var=var keyword argument repetition in function calls

Author: ChrisRackauckas

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

@@ -56,7 +56,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)
 ```