format the doc

Author: xiaoming

src/DelaySSAToolkit.jl

@@ -14,7 +14,8 @@ import JumpProcesses: AbstractJumpAggregator, AbstractJump, JumpProblem, Constan
 # Dependency graph functions
 import JumpProcesses: make_dependency_graph, add_self_dependencies!, var_to_jumps_map
 # other functions
-import JumpProcesses: using_params, get_jump_info_fwrappers, isinplace_jump, extend_problem, build_variable_callback, get_num_majumps, num_crjs
+import JumpProcesses: using_params, get_jump_info_fwrappers, isinplace_jump, extend_problem,
+                      build_variable_callback, get_num_majumps, num_crjs
 
 # VariableRateJump
 import JumpProcesses: isbounded, num_bndvrjs, supports_variablerates, haslrate, nullrate

src/delayaggregator/aggregators.jl

@@ -5,6 +5,7 @@ An abstract type that contains delay stochastic simulation algorithms:
 - DelayRejection
 - DelayMNRM
 - DelayDirectCR
+- DelayCoevolve
 """
 abstract type AbstractDelayAggregatorAlgorithm end
 """
@@ -57,4 +58,4 @@ needs_vartojumps_map(aggregator::DelayDirectCR) = true
 needs_depgraph(aggregator::DelayCoevolve) = true
 needs_vartojumps_map(aggregator::DelayCoevolve) = true
 supports_variablerates(aggregator::AbstractDelayAggregatorAlgorithm) = false
-supports_variablerates(aggregator::DelayCoevolve) = true
+supports_variablerates(aggregator::DelayCoevolve) = true

src/delayaggregator/delayssajump.jl

@@ -352,7 +352,8 @@ input::Vector{Int} species indices
 output::Vector{Int} reactions need to be updated
 """
 
-function vars_to_jumps_delay(vartojumps_map::Vector{Vector{Int}}, vars::Vector{Int})::Vector{Int}
+function vars_to_jumps_delay(vartojumps_map::Vector{Vector{Int}},
+                             vars::Vector{Int})::Vector{Int}
     jumps = Vector{Int}[]
     for var in vars
         push!(jumps, vartojumps_map[var])
@@ -398,7 +399,7 @@ julia> find_next_delay_vec(A, x)
 ([1, 2, 3], [2, 1, 1])
 ```
 """
-function find_next_delay_vec(de_chan::Vector{Vector{T}}, ttnj::T) where {T<:Real}
+function find_next_delay_vec(de_chan::Vector{Vector{T}}, ttnj::T) where {T <: Real}
     position_indices = Vector{Int64}()
     num_in_vec = Vector{Int64}()
     for idx in eachindex(de_chan)

src/delayproblem.jl

@@ -122,9 +122,11 @@ function DelayJumpProblem(p::P, a::A, dj::J, jc::C, vj::J2, rj::J3, mj::J4, djs:
         error("To solve DelayJumpProblem, one has to use one of the delay aggregators.")
     end
     iip = isinplace_jump(p, rj)
-    DelayJumpProblem{iip, P, A, C, J, J2, J3, J4, J5, deType, R, K}(p, a, dj, jc, vj, rj, mj,
-                                                                 djs, de_chan0,
-                                                                 save_delay_channel, rng, kwargs)
+    DelayJumpProblem{iip, P, A, C, J, J2, J3, J4, J5, deType, R, K}(p, a, dj, jc, vj, rj,
+                                                                    mj,
+                                                                    djs, de_chan0,
+                                                                    save_delay_channel, rng,
+                                                                    kwargs)
 end
 
 """
@@ -182,7 +184,6 @@ function DelayJumpProblem(prob, aggregator::AbstractDelayAggregatorAlgorithm,
         bvrjs = nothing
         cvrjs = jumps.variable_jumps
     end
-    
 
     ## Constant Rate Handling
     t, end_time, u = prob.tspan[1], prob.tspan[2], prob.u0
@@ -219,12 +220,16 @@ function DelayJumpProblem(prob, aggregator::AbstractDelayAggregatorAlgorithm,
     DelayJumpProblem{iip, typeof(new_prob), typeof(aggregator), typeof(callbacks),
                      typeof(disc_agg), typeof(cont_agg),
                      typeof(jumps.regular_jump), typeof(maj), typeof(delayjumpsets),
-                     typeof(de_chan0), typeof(rng), typeof(solkwargs)}(new_prob, aggregator, disc_agg,
-                                                          callbacks,
-                                                          cont_agg,
-                                                          jumps.regular_jump, maj,
-                                                          delayjumpsets, de_chan0,
-                                                          save_delay_channel, rng, solkwargs)
+                     typeof(de_chan0), typeof(rng), typeof(solkwargs)}(new_prob, aggregator,
+                                                                       disc_agg,
+                                                                       callbacks,
+                                                                       cont_agg,
+                                                                       jumps.regular_jump,
+                                                                       maj,
+                                                                       delayjumpsets,
+                                                                       de_chan0,
+                                                                       save_delay_channel,
+                                                                       rng, solkwargs)
 end
 
 make_kwarg(; kwargs...) = kwargs
@@ -264,7 +269,7 @@ function DelayJumpProblem(js::JumpSystem, prob, aggregator, delayjumpset, de_cha
     crjs = ConstantRateJump[assemble_crj(js, j, statetoid) for j in eqs.x[2]]
     vrjs = VariableRateJump[assemble_vrj(js, j, statetoid) for j in eqs.x[3]]
     # ((prob isa DiscreteProblem) && !isempty(vrjs)) &&
-        # error("Use continuous problems such as an ODEProblem or a SDEProblem with VariableRateJumps")
+    # error("Use continuous problems such as an ODEProblem or a SDEProblem with VariableRateJumps")
     jset = JumpSet(Tuple(vrjs), Tuple(crjs), nothing, majs)
 
     if needs_vartojumps_map(aggregator) || needs_depgraph(aggregator)
@@ -326,7 +331,8 @@ function DiffEqBase.remake(thing::DelayJumpProblem; kwargs...)
     DelayJumpProblem(dprob, thing.aggregator, thing.discrete_jump_aggregation,
                      thing.jump_callback,
                      thing.variable_jumps, thing.regular_jump, thing.massaction_jump,
-                     delayjumpsets, de_chan0, thing.save_delay_channel, thing.rng, thing.kwargs)
+                     delayjumpsets, de_chan0, thing.save_delay_channel, thing.rng,
+                     thing.kwargs)
 end
 
 function update_delayjumpsets(delayjumpsets::DelayJumpSet; kwargs...)

test/hawkes_delay_test.jl

@@ -54,12 +54,12 @@ function hawkes_jump(i::Int, g, h, agg; uselrate = true)
         end
     end
     if typeof(agg) <: DelayCoevolve
-        affect! = (integrator) -> begin 
+        affect! = (integrator) -> begin
             push!(h[i], integrator.t)
             integrator.u[i] += 0
         end
     else
-        affect! = (integrator) -> begin 
+        affect! = (integrator) -> begin
             push!(h[i], integrator.t)
             integrator.u[i] += 1
         end
@@ -77,11 +77,12 @@ function hawkes_problem(p, agg::DelayCoevolve; u = [0.0], tspan = (0.0, 50.0),
     dprob = DiscreteProblem(u, tspan, p)
     jumps = JumpSet(hawkes_jump(u, g, h, agg; uselrate)...)
     de_chan0 = [[]]
-    delay_trigger = Dict(1=>[1=>delay]) # add a delay of 1.0 to the first jump
-    delay_complete = Dict(1=>[1=>1]) # complete the delay will duplicate 1 product
+    delay_trigger = Dict(1 => [1 => delay]) # add a delay of 1.0 to the first jump
+    delay_complete = Dict(1 => [1 => 1]) # complete the delay will duplicate 1 product
     delay_interrupt = Dict()
     delayjumpset = DelayJumpSet(delay_trigger, delay_complete, delay_interrupt)
-    jprob = DelayJumpProblem(dprob, agg, jumps, delayjumpset, de_chan0; dep_graph = g, save_positions, rng)
+    jprob = DelayJumpProblem(dprob, agg, jumps, delayjumpset, de_chan0; dep_graph = g,
+                             save_positions, rng)
     return jprob
 end
 
@@ -109,7 +110,7 @@ function expected_stats_hawkes_problem(p, tspan, agg)
     λ, α, β = p
     γ = β - α
     κ = β / γ
-    Eλ = λ * κ 
+    Eλ = λ * κ
     # Equation 21
     # J. Da Fonseca and R. Zaatour,
     # “Hawkes Process: Fast Calibration, Application to Trade Clustering and Diffusive Limit.”
@@ -124,8 +125,6 @@ tspan = (0.0, 250.0)
 g = [[1]]
 h = [Float64[]]
 
-
-
 aggs = (Direct(), DelayCoevolve(), DelayCoevolve())
 uselrate = zeros(Bool, length(aggs))
 uselrate[3] = true
@@ -148,7 +147,8 @@ for (i, agg) in enumerate(aggs)
         λs = permutedims(mapreduce((sol) -> empirical_rate(sol, agg), hcat, sols))
     else
         cols = length(sols[1].u[1].u)
-        λs = permutedims(mapreduce((sol) -> empirical_rate(sol, agg), hcat, sols))[:, 1:cols]
+        λs = permutedims(mapreduce((sol) -> empirical_rate(sol, agg), hcat, sols))[:,
+                                                                                   1:cols]
     end
     Eλ, Varλ = expected_stats_hawkes_problem(p, tspan, agg)
     @test isapprox(mean(λs), Eλ; atol = 0.01)