Merge pull request #37 from SciML/dw/discontinuity

Remove `Discontinuity`

Author: ChrisRackauckas

Project.toml

@@ -1,7 +1,7 @@
 name = "StochasticDelayDiffEq"
 uuid = "29a0d76e-afc8-11e9-03a4-eda52ae4b960"
 authors = ["Henrik Sykora <[email protected]>"]
-version = "0.2.7"
+version = "0.2.8"
 
 [deps]
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
@@ -21,7 +21,7 @@ UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 
 [compat]
 DataStructures = "0.18"
-DelayDiffEq = "5.28.2"
+DelayDiffEq = "5.28.3"
 DiffEqBase = "6.29"
 DiffEqNoiseProcess = "5"
 RandomNumbers = "1"

src/StochasticDelayDiffEq.jl

@@ -16,7 +16,7 @@ using DiffEqBase: AbstractSDDEProblem, AbstractSDDEAlgorithm, AbstractRODESoluti
 import DelayDiffEq: constant_extrapolant!, constant_extrapolant, AbstractMethodOfStepsAlgorithm, iscomposite, MethodOfSteps
 using DiffEqNoiseProcess
 
-using DelayDiffEq: HistoryFunction
+using DelayDiffEq: Discontinuity, HistoryFunction
 
 import RandomNumbers: Xorshifts
 using Random
@@ -27,7 +27,6 @@ import Base: convert
 # #########################################################
 # #########################################################
 
-include("discontinuity_type.jl")
 include("integrators/type.jl")
 include("integrators/interface.jl")
 include("integrators/utils.jl")

src/discontinuity_type.jl

@@ -175,7 +175,7 @@ function DiffEqBase.reinit!(integrator::SDDEIntegrator,u0 = integrator.sol.prob.
 
     if order_discontinuity_t0 ≤ maximum_order
       resize!(integrator.tracked_discontinuities, 1)
-      integrator.tracked_discontinuities[1] = Discontinuity(integrator.tdir * integrator.t, order_discontinuity_t0)
+      integrator.tracked_discontinuities[1] = Discontinuity(integrator.tdir * integrator.t, Rational{Int}(order_discontinuity_t0))
     else
       resize!(integrator.tracked_discontinuities, 0)
     end
@@ -237,7 +237,7 @@ function StochasticDiffEq.handle_callback_modifiers!(integrator::SDDEIntegrator)
 
     # update heap of discontinuities
     # discontinuity is assumed to be of order 0, i.e. solution x is discontinuous
-    push!(integrator.opts.d_discontinuities, Discontinuity(integrator.tdir * integrator.t, 0))
+    push!(integrator.opts.d_discontinuities, Discontinuity(integrator.tdir * integrator.t, 0//1))
 end
 
 function DiffEqBase.u_modified!(integrator::SDDEIntegrator, bool::Bool)

src/integrators/interface.jl

@@ -33,7 +33,7 @@ mutable struct SDDEIntegrator{algType,IIP,uType,uEltype,tType,P,eigenType,tTypeN
     # prev2_idx::Int - from DDEIntegrator TODO
     # fpsolver::FP - from DDEIntegrator TODO
     order_discontinuity_t0::Int  #- from DDEIntegrator TODO
-    tracked_discontinuities::Vector{Discontinuity{tType}}
+    tracked_discontinuities::Vector{Discontinuity{tType,Rational{Int}}}
     # discontinuity_interp_points::Int #- from DDEIntegrator TODO
     # discontinuity_abstol::dAbsType #- from DDEIntegrator TODO
     # discontinuity_reltol::dRelType #- from DDEIntegrator TODO

src/integrators/type.jl

@@ -84,13 +84,14 @@ than the order of the applied method or the problem is neutral.
 Discontinuities caused by constant delays are immediately calculated, and
 discontinuities caused by dependent delays are tracked by a callback.
 """
-function add_next_discontinuities!(integrator, order, t = integrator.t)
+function add_next_discontinuities!(integrator, _order, t = integrator.t)
     neutral = integrator.sol.prob.neutral
-    next_order = neutral ? order : order + oftype(order,1//2)
+    order = Rational{Int}(_order)
+    next_order = neutral ? order : order + 1//2
 
   # only track discontinuities up to order of the applied method
     alg_order = StochasticDiffEq.alg_order(getalg(integrator.alg))
-    next_order <= alg_order + oftype(alg_order,1//2) || return
+    next_order <= alg_order + 1//2 || return
 
   # discontinuities caused by constant lags
     if has_constant_lags(integrator)

src/integrators/utils.jl

@@ -14,7 +14,7 @@ function DiffEqBase.__init(prob::AbstractSDDEProblem,# TODO DiffEqBasee.Abstract
     recompile::Type{Val{recompile_flag}} = Val{true};
     saveat = eltype(prob.tspan)[],
     tstops = eltype(prob.tspan)[],
-    d_discontinuities = Discontinuity{eltype(prob.tspan)}[],
+    d_discontinuities = Discontinuity{eltype(prob.tspan),Rational{Int}}[],
     save_idxs = nothing,
     save_everystep = isempty(saveat),
     save_noise = save_everystep && (typeof(prob.f) <: Tuple ?
@@ -215,9 +215,9 @@ function DiffEqBase.__init(prob::AbstractSDDEProblem,# TODO DiffEqBasee.Abstract
                                                 order_discontinuity_t0, maximum_order,
                                                 constant_lags, neutral)
 
-    tracked_discontinuities = Discontinuity{tType}[]
+    tracked_discontinuities = Discontinuity{tType,Rational{Int}}[]
     if order_discontinuity_t0 ≤ maximum_order
-        push!(tracked_discontinuities, Discontinuity(tdir * t, order_discontinuity_t0))
+        push!(tracked_discontinuities, Discontinuity(tdir * t, Rational{Int}(order_discontinuity_t0)))
     end
 
     callbacks_internal = CallbackSet(callback)
@@ -529,7 +529,7 @@ function tstop_saveat_disc_handling(tstops, saveat, d_discontinuities, tspan, or
     end
 
   # discontinuities
-    d_discontinuities_internal = BinaryMinHeap{Discontinuity{tType}}()
+    d_discontinuities_internal = BinaryMinHeap{Discontinuity{tType,Rational{Int}}}()
     if add_propagated_constant_lags
         sizehint!(d_discontinuities_internal.valtree, length(d_discontinuities) + length(constant_lags))
     else
@@ -540,14 +540,14 @@ function tstop_saveat_disc_handling(tstops, saveat, d_discontinuities, tspan, or
         tdir_t = tdir * d.t
 
         if tdir_t0 < tdir_t < tdir_tf && d.order ≤ alg_maximum_order + 1
-            push!(d_discontinuities_internal, Discontinuity{tType}(tdir_t, d.order))
+            push!(d_discontinuities_internal, Discontinuity{tType,Rational{Int}}(tdir_t, d.order))
         end
     end
 
     if add_propagated_constant_lags
         for lag in constant_lags
             if tdir * lag < maxlag
-                push!(d_discontinuities_internal, Discontinuity{tType}(tdir * (t0 + lag), next_order))
+                push!(d_discontinuities_internal, Discontinuity{tType,Rational{Int}}(tdir * (t0 + lag), next_order))
             end
         end
     end