Merge pull request #371 from ChrisRackauckas/fix-formatting

Apply JuliaFormatter to fix code formatting

Author: ChrisRackauckas

README.md

@@ -12,7 +12,6 @@
 This library is a component package of the DifferentialEquations.jl ecosystem. It includes
 functionality for making use of GPUs in the differential equation solvers.
 
-
 ## The two ways to accelerate ODE solvers with GPUs
 
 There are two very different ways that one can

docs/src/tutorials/lower_level_api.md

@@ -39,18 +39,22 @@ probs = cu(probs)
 ## Finally use the lower API for faster solves! (Fixed time-stepping)
 
 # Run once for compilation
-@time CUDA.@sync ts, us = DiffEqGPU.vectorized_solve(probs, prob, GPUTsit5();
+@time CUDA.@sync ts,
+us = DiffEqGPU.vectorized_solve(probs, prob, GPUTsit5();
     save_everystep = false, dt = 0.1f0)
 
-@time CUDA.@sync ts, us = DiffEqGPU.vectorized_solve(probs, prob, GPUTsit5();
+@time CUDA.@sync ts,
+us = DiffEqGPU.vectorized_solve(probs, prob, GPUTsit5();
     save_everystep = false, dt = 0.1f0)
 
 ## Adaptive time-stepping
 # Run once for compilation
-@time CUDA.@sync ts, us = DiffEqGPU.vectorized_asolve(probs, prob, GPUTsit5();
+@time CUDA.@sync ts,
+us = DiffEqGPU.vectorized_asolve(probs, prob, GPUTsit5();
     save_everystep = false, dt = 0.1f0)
 
-@time CUDA.@sync ts, us = DiffEqGPU.vectorized_asolve(probs, prob, GPUTsit5();
+@time CUDA.@sync ts,
+us = DiffEqGPU.vectorized_asolve(probs, prob, GPUTsit5();
     save_everystep = false, dt = 0.1f0)
 ```
 

docs/src/tutorials/modelingtoolkit.md

@@ -8,6 +8,7 @@ by hand. Those exact features are also potentially useful for GPU computing, and
 tutorial showcases how to effectively use MTK with DiffEqGPU.jl.
 
 !!! warn
+    
     This tutorial currently only works for ODEs defined by ModelingToolkit. More work
     will be required to support DAEs in full. This is work that is ongoing and expected
     to be completed by the summer of 2025.
@@ -29,16 +30,16 @@ eqs = [D(D(x)) ~ σ * (y - x),
     D(z) ~ x * y - β * z]
 
 @mtkbuild sys = ODESystem(eqs, t)
-u0 = SA[D(x) => 2f0,
-    x => 1f0,
-    y => 0f0,
-    z => 0f0]
+u0 = SA[D(x) => 2.0f0,
+x => 1.0f0,
+y => 0.0f0,
+z => 0.0f0]
 
-p = SA[σ => 28f0,
-    ρ => 10f0,
-    β => 8f0 / 3f0]
+p = SA[σ => 28.0f0,
+ρ => 10.0f0,
+β => 8.0f0 / 3.0f0]
 
-tspan = (0f0, 100f0)
+tspan = (0.0f0, 100.0f0)
 prob = ODEProblem{false}(sys, u0, tspan, p)
 sol = solve(prob, Tsit5())
 ```
@@ -64,7 +65,7 @@ sym_setter = setsym_oop(sys, [σ, ρ, β])
 The return `sym_setter` is our optimized function, let's see it in action:
 
 ```@example mtk
-u0, p = sym_setter(prob,@SVector(rand(Float32,3)))
+u0, p = sym_setter(prob, @SVector(rand(Float32, 3)))
 ```
 
 Notice it takes in the vector of values for `[σ, ρ, β]` and spits out the new `u0, p`. So
@@ -73,7 +74,7 @@ we can build and solve an MTK generated ODE on the GPU using the following:
 ```@example mtk
 using DiffEqGPU, CUDA
 function prob_func2(prob, i, repeat)
-    u0, p = sym_setter(prob,@SVector(rand(Float32,3)))
+    u0, p = sym_setter(prob, @SVector(rand(Float32, 3)))
     remake(prob, u0 = u0, p = p)
 end
 

src/DiffEqGPU.jl

@@ -68,8 +68,6 @@ include("ensemblegpukernel/tableaus/verner_tableaus.jl")
 include("ensemblegpukernel/tableaus/rodas_tableaus.jl")
 include("ensemblegpukernel/tableaus/kvaerno_tableaus.jl")
 
-
-
 include("utils.jl")
 include("algorithms.jl")
 include("solve.jl")

src/ensemblegpuarray/kernels.jl

@@ -75,6 +75,7 @@ end
 
     @views @inbounds f(J[section, section], u[:, i + 1], p, t)
     @inbounds for j in section, k in section
+
         J[k, j] = J[k, j] * (tspan[2] - tspan[1])
     end
 end
@@ -94,6 +95,7 @@ end
     @views @inbounds x = f(u[:, i + 1], p, t)
 
     @inbounds for j in section, k in section
+
         J[k, j] = x[k, j] * (tspan[2] - tspan[1])
     end
 end
@@ -117,6 +119,7 @@ end
         @views @inbounds x = f(u[:, i + 1], p[i + 1], t)
     end
     @inbounds for j in section, k in section
+
         J[k, j] = x[k, j]
     end
 end

src/ensemblegpuarray/problem_generation.jl

@@ -58,7 +58,6 @@ function generate_problem(prob::SciMLBase.AbstractODEProblem,
         _tgrad = nothing
     end
 
-
     f_func = ODEFunction(_f, Wfact = _Wfact!,
         Wfact_t = _Wfact!_t,
         #colorvec=colorvec,

src/ensemblegpukernel/integrators/integrator_utils.jl

@@ -108,7 +108,8 @@ end
         saved_in_cb::Bool, callback::GPUDiscreteCallback,
         args...) where {AlgType <: GPUODEAlgorithm, IIP,
         S, T}
-    bool, saved_in_cb2 = apply_discrete_callback!(integrator, ts, us,
+    bool,
+    saved_in_cb2 = apply_discrete_callback!(integrator, ts, us,
         apply_discrete_callback!(integrator, ts,
             us, callback)...,
         args...)
@@ -243,14 +244,19 @@ end
     if !(continuous_callbacks isa Tuple{})
         event_occurred = false
 
-        time, upcrossing, event_occurred, event_idx, idx, counter = DiffEqBase.find_first_continuous_callback(
+        time, upcrossing,
+        event_occurred,
+        event_idx,
+        idx,
+        counter = DiffEqBase.find_first_continuous_callback(
             integrator,
             continuous_callbacks...)
 
         if event_occurred
             integrator.event_last_time = idx
             integrator.vector_event_last_time = event_idx
-            continuous_modified, saved_in_cb = apply_callback!(integrator,
+            continuous_modified,
+            saved_in_cb = apply_callback!(integrator,
                 continuous_callbacks[1],
                 time, upcrossing,
                 event_idx, ts, us)
@@ -260,7 +266,8 @@ end
         end
     end
     if !(discrete_callbacks isa Tuple{})
-        discrete_modified, saved_in_cb = apply_discrete_callback!(integrator, ts, us,
+        discrete_modified,
+        saved_in_cb = apply_discrete_callback!(integrator, ts, us,
             discrete_callbacks...)
         return discrete_modified, saved_in_cb
     end
@@ -278,7 +285,10 @@ end
         callback::DiffEqGPU.GPUContinuousCallback,
         counter) where {AlgType <: GPUODEAlgorithm,
         IIP, S, T}
-    event_occurred, interp_index, prev_sign, prev_sign_index, event_idx = DiffEqBase.determine_event_occurrence(
+    event_occurred, interp_index,
+    prev_sign,
+    prev_sign_index,
+    event_idx = DiffEqBase.determine_event_occurrence(
         integrator,
         callback,
         counter)

src/ensemblegpukernel/linalg/lu.jl

@@ -148,7 +148,7 @@ function __lu(A::StaticLUMatrix{M, N, T}, ::Val{Pivot}) where {M, N, T, Pivot}
         Lrest, Urest, prest = __lu(Arest, Val(Pivot))
         p = [SVector{1, Int}(kp); ps[prest]]
         L = [[SVector{1}(one(eltype(Ls))); Ls[prest]] [zeros(typeof(SMatrix{1}(Lrest[1,
-                                                           :])));
+                                                       :])));
                                                        Lrest]]
         U = [Ufirst; [zeros(typeof(Urest[:, 1])) Urest]]
     end

src/ensemblegpukernel/perform_step/gpu_kvaerno3_perform_step.jl

@@ -6,7 +6,8 @@
     f = integ.f
     integ.uprev = integ.u
     uprev = integ.u
-    @unpack γ, a31, a32, a41, a42, a43, btilde1, btilde2, btilde3, btilde4, c3, α31, α32 = integ.tab
+    @unpack γ, a31, a32, a41, a42, a43, btilde1, btilde2, btilde3, btilde4, c3, α31,
+    α32 = integ.tab
 
     integ.tprev = t
     saved_in_cb = false
@@ -86,7 +87,8 @@
 end
 
 @inline function step!(integ::GPUAKvaerno3I{false, S, T}, ts, us) where {T, S}
-    beta1, beta2, qmax, qmin, gamma, qoldinit, _ = build_adaptive_controller_cache(
+    beta1, beta2, qmax, qmin, gamma, qoldinit,
+    _ = build_adaptive_controller_cache(
         integ.alg,
         T)
 
@@ -104,7 +106,8 @@ end
     abstol = integ.abstol
     reltol = integ.reltol
 
-    @unpack γ, a31, a32, a41, a42, a43, btilde1, btilde2, btilde3, btilde4, c3, α31, α32 = integ.tab
+    @unpack γ, a31, a32, a41, a42, a43, btilde1, btilde2, btilde3, btilde4, c3, α31,
+    α32 = integ.tab
 
     if integ.u_modified
         k1 = f(uprev, p, t)

src/ensemblegpukernel/perform_step/gpu_kvaerno5_perform_step.jl

@@ -6,7 +6,8 @@
     f = integ.f
     integ.uprev = integ.u
     uprev = integ.u
-    @unpack γ, a31, a32, a41, a42, a43, a51, a52, a53, a54, a61, a63, a64, a65, a71, a73, a74, a75, a76, c3, c4, c5, c6 = integ.tab
+    @unpack γ, a31, a32, a41, a42, a43, a51, a52, a53, a54, a61, a63, a64,
+    a65, a71, a73, a74, a75, a76, c3, c4, c5, c6 = integ.tab
     @unpack btilde1, btilde3, btilde4, btilde5, btilde6, btilde7 = integ.tab
     @unpack α31, α32, α41, α42, α43, α51, α52, α53, α61, α62, α63 = integ.tab
 
@@ -117,7 +118,8 @@
 end
 
 @inline function step!(integ::GPUAKvaerno5I{false, S, T}, ts, us) where {T, S}
-    beta1, beta2, qmax, qmin, gamma, qoldinit, _ = build_adaptive_controller_cache(
+    beta1, beta2, qmax, qmin, gamma, qoldinit,
+    _ = build_adaptive_controller_cache(
         integ.alg,
         T)
 
@@ -135,7 +137,8 @@ end
     abstol = integ.abstol
     reltol = integ.reltol
 
-    @unpack γ, a31, a32, a41, a42, a43, a51, a52, a53, a54, a61, a63, a64, a65, a71, a73, a74, a75, a76, c3, c4, c5, c6 = integ.tab
+    @unpack γ, a31, a32, a41, a42, a43, a51, a52, a53, a54, a61, a63, a64,
+    a65, a71, a73, a74, a75, a76, c3, c4, c5, c6 = integ.tab
     @unpack btilde1, btilde3, btilde4, btilde5, btilde6, btilde7 = integ.tab
     @unpack α31, α32, α41, α42, α43, α51, α52, α53, α61, α62, α63 = integ.tab