Merge pull request #201 from LilithHafner/lh/format

Run JuliaFormatter.format()

Author: ChrisRackauckas

docs/make.jl

@@ -14,7 +14,7 @@ makedocs(sitename = "DiffEqCallbacks.jl",
     modules = [DiffEqCallbacks],
     clean = true, doctest = false, linkcheck = true,
     linkcheck_ignore = [
-        "https://www.sciencedirect.com/science/article/pii/S0096300304009683",
+        "https://www.sciencedirect.com/science/article/pii/S0096300304009683"
     ],
     warnonly = [:missing_docs],
     format = Documenter.HTML(assets = ["assets/favicon.ico"],

docs/pages.jl

@@ -8,5 +8,5 @@ pages = [
     "steady_state.md",
     "step_control.md",
     "projection.md",
-    "uncertainty_quantification.md",
+    "uncertainty_quantification.md"
 ]

src/DiffEqCallbacks.jl

@@ -1,7 +1,7 @@
 module DiffEqCallbacks
 
 using DiffEqBase, RecursiveArrayTools, DataStructures, RecipesBase, LinearAlgebra,
-    StaticArraysCore, NLsolve, ForwardDiff, Functors
+      StaticArraysCore, NLsolve, ForwardDiff, Functors
 
 import Base.Iterators
 

src/domain.jl

@@ -16,7 +16,7 @@ struct GeneralDomainAffect{autonomous, F, T, S, uType} <: AbstractDomainAffect{T
     resid::uType
 
     function GeneralDomainAffect{autonomous}(g::F, abstol::T, scalefactor::S, u::uType,
-        resid::uType) where {autonomous, F, T, S, uType
+            resid::uType) where {autonomous, F, T, S, uType
     }
         new{autonomous, F, T, S, uType}(g, abstol, scalefactor, u, resid)
     end
@@ -94,7 +94,7 @@ function affect!(integrator, f::AbstractDomainAffect{T, S, uType}) where {T, S,
         if dtcache == dt
             if integrator.opts.verbose
                 @warn("Could not restrict values to domain. Iteration was canceled since ",
-                    "proposed time step dt = ", dt, " could not be reduced.")
+                    "proposed time step dt = ", dt," could not be reduced.")
             end
             break
         end
@@ -190,7 +190,7 @@ function setup(f::GeneralDomainAffect, integrator)
 end
 
 function isaccepted(u, p, t, abstol, f::GeneralDomainAffect{autonomous, F, T, S, uType},
-    resid) where {autonomous, F, T, S, uType}
+        resid) where {autonomous, F, T, S, uType}
     # calculate residuals
     if autonomous
         f.g(resid, u, p)
@@ -264,17 +264,18 @@ Non-negative solutions of ODEs. Applied Mathematics and Computation 170
 (2005): 556-569.
 """
 function GeneralDomain(g, u = nothing; nlsolve = NLSOLVEJL_SETUP(), save = true,
-    abstol = nothing, scalefactor = nothing,
-    autonomous = maximum(SciMLBase.numargs(g)) == 3,
-    nlopts = Dict(:ftol => 10 * eps()))
+        abstol = nothing, scalefactor = nothing,
+        autonomous = maximum(SciMLBase.numargs(g)) == 3,
+        nlopts = Dict(:ftol => 10 * eps()))
     if u isa Nothing
         affect! = GeneralDomainAffect{autonomous}(g, abstol, scalefactor, nothing, nothing)
     else
         affect! = GeneralDomainAffect{autonomous}(g, abstol, scalefactor, deepcopy(u),
             deepcopy(u))
     end
     condition = (u, t, integrator) -> true
-    CallbackSet(ManifoldProjection(g; nlsolve = nlsolve, save = false,
+    CallbackSet(
+        ManifoldProjection(g; nlsolve = nlsolve, save = false,
             autonomous = autonomous, nlopts = nlopts),
         DiscreteCallback(condition, affect!; save_positions = (false, save)))
 end

src/function_caller.jl

@@ -82,10 +82,10 @@ which gets calls at the time points of interest. The constructor is:
     be adapted if `tspan[1] > tspan[end]`.
 """
 function FunctionCallingCallback(func;
-    funcat = Vector{Float64}(),
-    func_everystep = isempty(funcat),
-    func_start = true,
-    tdir = 1)
+        funcat = Vector{Float64}(),
+        func_everystep = isempty(funcat),
+        func_start = true,
+        tdir = 1)
     # funcat conversions, see OrdinaryDiffEq.jl -> integrators/type.jl
     if funcat isa Number
         # expand to range using tspan in functioncalling_initialize

src/independentlylinearizedutils.jl

@@ -18,13 +18,14 @@ mutable struct IndependentlyLinearizedSolutionChunks{T, S}
     u_offsets::Vector{Int}
     t_offset::Int
 
-    function IndependentlyLinearizedSolutionChunks{T, S}(num_us::Int, num_derivatives::Int = 0,
+    function IndependentlyLinearizedSolutionChunks{T, S}(
+            num_us::Int, num_derivatives::Int = 0,
             chunk_size::Int = 100) where {T, S}
         return new([Vector{T}(undef, chunk_size)],
-            [[Matrix{S}(undef, num_derivatives+1, chunk_size)] for _ in 1:num_us],
+            [[Matrix{S}(undef, num_derivatives + 1, chunk_size)] for _ in 1:num_us],
             [BitMatrix(undef, num_us, chunk_size)],
             [1 for _ in 1:num_us],
-            1,
+            1
         )
     end
 end
@@ -69,7 +70,7 @@ function get_chunks(ilsc::IndependentlyLinearizedSolutionChunks{T, S}) where {T,
     # Check if we need to allocate any new `u` chunks (but only for those with `u_mask`)
     for (u_idx, u_chunks) in enumerate(ilsc.u_chunks)
         if ilsc.u_offsets[u_idx] > chunksize
-            push!(u_chunks, Matrix{S}(undef, num_derivatives(ilsc)+1, chunksize))
+            push!(u_chunks, Matrix{S}(undef, num_derivatives(ilsc) + 1, chunksize))
             ilsc.u_offsets[u_idx] = 1
         end
     end
@@ -78,7 +79,7 @@ function get_chunks(ilsc::IndependentlyLinearizedSolutionChunks{T, S}) where {T,
     return (
         ilsc.t_chunks[end],
         ilsc.time_masks[end],
-        [u_chunks[end] for u_chunks in ilsc.u_chunks],
+        [u_chunks[end] for u_chunks in ilsc.u_chunks]
     )
 end
 
@@ -91,24 +92,25 @@ function get_prev_t(ilsc::IndependentlyLinearizedSolutionChunks)
             return -Inf
         end
         # Otherwise, return the last element of the previous chunk
-        return ilsc.t_chunks[end-1][end]
+        return ilsc.t_chunks[end - 1][end]
     end
     # Otherwise return the previous element of the current chunk
-    return ilsc.t_chunks[end][ilsc.t_offset-1]
+    return ilsc.t_chunks[end][ilsc.t_offset - 1]
 end
 
-function get_prev_u(ilsc::IndependentlyLinearizedSolutionChunks{T,S}, u_out::Vector{S}) where {T,S}
+function get_prev_u(
+        ilsc::IndependentlyLinearizedSolutionChunks{T, S}, u_out::Vector{S}) where {T, S}
     for u_idx in 1:length(ilsc.u_offsets)
         if ilsc.u_offsets[u_idx] == 1
             if length(ilsc.u_chunks[u_idx]) == 1
                 # If we have never stored anything for this `u`, just return `0.0`
                 u_out[u_idx] = S(0)
             end
             # Otherwise, get the last element of the previous chunk
-            u_out[u_idx] = ilsc.u_chunks[u_idx][end-1][end]
+            u_out[u_idx] = ilsc.u_chunks[u_idx][end - 1][end]
         else
             # Otherwise, return the previous element of the current chunk
-            u_out[u_idx] = ilsc.u_chunks[u_idx][end][ilsc.u_offsets[u_idx]-1]
+            u_out[u_idx] = ilsc.u_chunks[u_idx][end][ilsc.u_offsets[u_idx] - 1]
         end
     end
     return u_out
@@ -122,9 +124,9 @@ but only the values identified by the given `u_mask`.  The `us` matrix
 should be of the size `(num_us(ilsc), num_derivatives(ilsc))`.
 """
 function store!(ilsc::IndependentlyLinearizedSolutionChunks{T, S},
-                t::T,
-                u::AbstractMatrix{S},
-                u_mask::BitVector) where {T, S}
+        t::T,
+        u::AbstractMatrix{S},
+        u_mask::BitVector) where {T, S}
     # If `t` has been stored before, drop it.
     # We don't store duplicate timepoints, even though the solver sometimes does.
     if get_prev_t(ilsc) == t
@@ -148,8 +150,6 @@ function store!(ilsc::IndependentlyLinearizedSolutionChunks{T, S},
     ilsc.t_offset += 1
 end
 
-
-
 """
     IndependentlyLinearizedSolution
 
@@ -171,35 +171,39 @@ mutable struct IndependentlyLinearizedSolution{T, S}
 
     # Bitmatrix denoting which time indices are used for which us.
     time_mask::BitMatrix
-    
+
     # Temporary object used during construction, will be set to `nothing` at the end.
-    ilsc::Union{Nothing,IndependentlyLinearizedSolutionChunks{T,S}}
+    ilsc::Union{Nothing, IndependentlyLinearizedSolutionChunks{T, S}}
 end
 # Helper function to create an ILS wrapped around an in-progress ILSC
-function IndependentlyLinearizedSolution(ilsc::IndependentlyLinearizedSolutionChunks{T,S}) where {T,S}
+function IndependentlyLinearizedSolution(ilsc::IndependentlyLinearizedSolutionChunks{
+        T, S}) where {T, S}
     ils = IndependentlyLinearizedSolution(
         T[],
         Matrix{S}[],
-        BitMatrix(undef, 0,0),
-        ilsc,
+        BitMatrix(undef, 0, 0),
+        ilsc
     )
     return ils
 end
 # Automatically create an ILS wrapped around an ILSC from a `prob`
-function IndependentlyLinearizedSolution(prob::SciMLBase.AbstractDEProblem, num_derivatives = 0)
+function IndependentlyLinearizedSolution(
+        prob::SciMLBase.AbstractDEProblem, num_derivatives = 0)
     T = eltype(prob.tspan)
     U = isnothing(prob.u0) ? Float64 : eltype(prob.u0)
     N = isnothing(prob.u0) ? 0 : length(prob.u0)
-    chunks = IndependentlyLinearizedSolutionChunks{T,U}(N, num_derivatives)
+    chunks = IndependentlyLinearizedSolutionChunks{T, U}(N, num_derivatives)
     return IndependentlyLinearizedSolution(chunks)
 end
 
-num_derivatives(ils::IndependentlyLinearizedSolution) = !isempty(ils.us) ? size(first(ils.us), 1) : 0
+function num_derivatives(ils::IndependentlyLinearizedSolution)
+    !isempty(ils.us) ? size(first(ils.us), 1) : 0
+end
 num_us(ils::IndependentlyLinearizedSolution) = length(ils.us)
 Base.size(ils::IndependentlyLinearizedSolution) = size(ils.time_mask)
 Base.length(ils::IndependentlyLinearizedSolution) = length(ils.ts)
 
-function finish!(ils::IndependentlyLinearizedSolution{T, S}, return_code) where {T,S}
+function finish!(ils::IndependentlyLinearizedSolution{T, S}, return_code) where {T, S}
     function trim_chunk(chunks::Vector, offset)
         chunks = [chunk for chunk in chunks]
         if eltype(chunks) <: AbstractVector
@@ -225,7 +229,7 @@ function finish!(ils::IndependentlyLinearizedSolution{T, S}, return_code) where
         ts = vcat(trim_chunk(ilsc.t_chunks, ilsc.t_offset)...)
         time_mask = hcat(trim_chunk(ilsc.time_masks, ilsc.t_offset)...)
         us = [hcat(trim_chunk(ilsc.u_chunks[u_idx], ilsc.u_offsets[u_idx])...)
-            for u_idx in 1:length(ilsc.u_chunks)]
+              for u_idx in 1:length(ilsc.u_chunks)]
     end
 
     # Sanity-check lengths
@@ -317,7 +321,7 @@ end
 function Base.seek(ils::IndependentlyLinearizedSolution, t_idx = 1)
     return [ILSStateCursor(ils, u_idx, t_idx) for u_idx in 1:length(ils.us)]
 end
-function iteration_state(ils::IndependentlyLinearizedSolution{T, S}, t_idx=1) where {T, S}
+function iteration_state(ils::IndependentlyLinearizedSolution{T, S}, t_idx = 1) where {T, S}
     # Nice little hack so we don't have to allocate `u` over and over again
     u = zeros(S, (num_us(ils), num_derivatives(ils)))
     cursors = seek(ils, t_idx)
@@ -334,7 +338,7 @@ function Base.iterate(ils::IndependentlyLinearizedSolution{T, S},
     for deriv_idx in 0:(size(u, 2) - 1)
         for u_idx in 1:size(u, 1)
             cursors[u_idx] = seek_forward(ils, cursors[u_idx], t)
-            u[u_idx, deriv_idx+1] = interpolate(ils, cursors[u_idx], t, deriv_idx)
+            u[u_idx, deriv_idx + 1] = interpolate(ils, cursors[u_idx], t, deriv_idx)
         end
     end
 
@@ -347,9 +351,9 @@ end
 Batch-sample `ils` at the given timepoints for the given derivative level, storing into `out`.
 """
 function sample!(out::Matrix{S},
-                 ils::IndependentlyLinearizedSolution{T, S},
-                 ts::AbstractVector{T},
-                 deriv_idx::Int = 0) where {T, S}
+        ils::IndependentlyLinearizedSolution{T, S},
+        ts::AbstractVector{T},
+        deriv_idx::Int = 0) where {T, S}
     sampled_size = (length(ts), length(ils.us))
     if size(out) != sampled_size
         throw(ArgumentError("Output size ($(size(out))) != sampled size ($(sampled_size))"))
@@ -366,8 +370,8 @@ function sample!(out::Matrix{S},
     return out
 end
 function sample(ils::IndependentlyLinearizedSolution{T, S},
-                ts::AbstractVector{T},
-                deriv_idx::Int = 0) where {T, S}
+        ts::AbstractVector{T},
+        deriv_idx::Int = 0) where {T, S}
     out = Matrix{S}(undef, length(ts), length(ils.us))
     return sample!(out, ils, ts, deriv_idx)
 end

src/integrating.jl

@@ -41,7 +41,7 @@ gauss_points = [[0.0],
         -0.2386191860831969,
         0.2386191860831969,
         0.6612093864662645,
-        0.932469514203152,
+        0.932469514203152
     ],
     [
         -0.9491079123427586,
@@ -50,7 +50,7 @@ gauss_points = [[0.0],
         0.0,
         0.4058451513773972,
         0.7415311855993945,
-        0.9491079123427586,
+        0.9491079123427586
     ],
     [
         -0.9602898564975363,
@@ -60,7 +60,7 @@ gauss_points = [[0.0],
         0.1834346424956498,
         0.525532409916329,
         0.7966664774136267,
-        0.9602898564975363,
+        0.9602898564975363
     ],
     [
         -0.9681602395076261,
@@ -71,7 +71,7 @@ gauss_points = [[0.0],
         0.3242534234038089,
         0.6133714327005904,
         0.8360311073266358,
-        0.9681602395076261,
+        0.9681602395076261
     ],
     [
         -0.9739065285171717,
@@ -83,7 +83,7 @@ gauss_points = [[0.0],
         0.4333953941292472,
         0.6794095682990244,
         0.8650633666889845,
-        0.9739065285171717,
+        0.9739065285171717
     ]]
 """
     gauss_weights::Vector{Vector{Float64}}
@@ -100,15 +100,15 @@ gauss_weights = [[2.0],
         0.47862867049936647,
         0.5688888888888889,
         0.47862867049936647,
-        0.23692688505618908,
+        0.23692688505618908
     ],
     [
         0.17132449237917025,
         0.3607615730481385,
         0.46791393457269126,
         0.46791393457269126,
         0.3607615730481385,
-        0.17132449237917025,
+        0.17132449237917025
     ],
     [
         0.1294849661688702,
@@ -117,7 +117,7 @@ gauss_weights = [[2.0],
         0.4179591836734694,
         0.3818300505051189,
         0.2797053914892766,
-        0.1294849661688702,
+        0.1294849661688702
     ],
     [
         0.10122853629037676,
@@ -127,7 +127,7 @@ gauss_weights = [[2.0],
         0.36268378337836193,
         0.31370664587788744,
         0.22238103445337445,
-        0.10122853629037676,
+        0.10122853629037676
     ],
     [
         0.08127438836157437,
@@ -138,7 +138,7 @@ gauss_weights = [[2.0],
         0.31234707704000275,
         0.2606106964029354,
         0.18064816069485742,
-        0.08127438836157437,
+        0.08127438836157437
     ],
     [
         0.06667134430868821,
@@ -150,7 +150,7 @@ gauss_weights = [[2.0],
         0.2692667193099965,
         0.21908636251598207,
         0.14945134915058056,
-        0.06667134430868821,
+        0.06667134430868821
     ]]
 
 """
@@ -182,7 +182,7 @@ mutable struct SavingIntegrandAffect{
     IntegrandFunc,
     tType,
     integrandType,
-    integrandCacheType,
+    integrandCacheType
 }
     integrand_func::IntegrandFunc
     integrand_values::IntegrandValues{tType, integrandType}
@@ -255,7 +255,7 @@ via `integrand_values.integrand`.
     If `integrand_func` is in-place, you must use `cache` to store the output of `integrand_func`.
 """
 function IntegratingCallback(integrand_func, integrand_values::IntegrandValues,
-    cache = nothing)
+        cache = nothing)
     affect! = SavingIntegrandAffect(integrand_func, integrand_values, cache)
     condition = (u, t, integrator) -> true
     DiscreteCallback(condition, affect!, save_positions = (false, false))