From 7f785408f8cc691ba7dfa36473d2f9893cd78131 Mon Sep 17 00:00:00 2001 From: Orjan Ameye Date: Wed, 22 Jan 2025 12:45:35 +0100 Subject: [PATCH] =?UTF-8?q?build:=20replace=20OrdinaryDiffEq=20with=20Ordi?= =?UTF-8?q?naryDiffEq,=20OrdinaryDiffEqNonlinearSolve=E2=80=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Project.toml | 6 ++-- src/StochasticDiffEq.jl | 21 +++++++------ src/alg_utils.jl | 34 ++++++++++----------- src/algorithms.jl | 36 +++++++++++----------- src/caches/implicit_split_step_caches.jl | 8 ++--- src/caches/kencarp_caches.jl | 4 +-- src/caches/sdirk_caches.jl | 12 ++++---- src/dense.jl | 16 +++++----- src/integrators/integrator_interface.jl | 6 ++-- src/integrators/integrator_utils.jl | 4 +-- src/perform_step/implicit_split_step.jl | 18 +++++------ src/perform_step/kencarp.jl | 38 ++++++++++++------------ src/perform_step/sdirk.jl | 18 +++++------ src/solve.jl | 10 +++---- test/complex_tests.jl | 2 +- test/utility_tests.jl | 8 ++--- 16 files changed, 123 insertions(+), 118 deletions(-) diff --git a/Project.toml b/Project.toml index e7f73d15d..169946452 100644 --- a/Project.toml +++ b/Project.toml @@ -20,8 +20,9 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" Logging = "56ddb016-857b-54e1-b83d-db4d58db5568" MuladdMacro = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" NLsolve = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" -OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" OrdinaryDiffEqCore = "bbf590c4-e513-4bbe-9b18-05decba2e5d8" +OrdinaryDiffEqDifferentiation = "4302a76b-040a-498a-8c04-15b101fed76b" +OrdinaryDiffEqNonlinearSolve = "127b3ac7-2247-4354-8eb6-78cf4e7c58e8" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" RandomNumbers = "e6cf234a-135c-5ec9-84dd-332b85af5143" RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" @@ -68,6 +69,7 @@ julia = "1.10" DiffEqCallbacks = "459566f4-90b8-5000-8ac3-15dfb0a30def" DiffEqDevTools = "f3b72e0c-5b89-59e1-b016-84e28bfd966d" LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" +OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" SDEProblemLibrary = "c72e72a9-a271-4b2b-8966-303ed956772e" @@ -77,4 +79,4 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] -test = ["DiffEqCallbacks", "DiffEqDevTools", "SDEProblemLibrary", "LinearSolve", "ModelingToolkit", "Pkg", "SafeTestsets", "SparseArrays", "Statistics", "Test"] +test = ["DiffEqCallbacks", "DiffEqDevTools", "SDEProblemLibrary", "LinearSolve", "ModelingToolkit", "Pkg", "SafeTestsets", "SparseArrays", "Statistics", "OrdinaryDiffEq", "Test"] diff --git a/src/StochasticDiffEq.jl b/src/StochasticDiffEq.jl index b1da7e579..4cd9d6b01 100644 --- a/src/StochasticDiffEq.jl +++ b/src/StochasticDiffEq.jl @@ -11,8 +11,8 @@ using DocStringExtensions import ADTypes - import OrdinaryDiffEq - import OrdinaryDiffEq: default_controller, isstandard, ispredictive, + import OrdinaryDiffEqCore + import OrdinaryDiffEqCore: default_controller, isstandard, ispredictive, beta2_default, beta1_default, gamma_default, qmin_default, qmax_default, qsteady_min_default, qsteady_max_default, stepsize_controller!, accept_step_controller, step_accept_controller!, @@ -37,7 +37,7 @@ using DocStringExtensions using LinearAlgebra, Random import ForwardDiff.Dual - + import FastPower import DiffEqBase: step!, initialize!, DEAlgorithm, @@ -56,20 +56,23 @@ using DocStringExtensions using DiffEqBase: check_error!, is_diagonal_noise, @.. -using OrdinaryDiffEq: nlsolvefail, isnewton, set_new_W!, get_W, _vec, _reshape +using OrdinaryDiffEqNonlinearSolve: nlsolvefail, isnewton +using OrdinaryDiffEqCore: set_new_W!, get_W, _vec, _reshape -using OrdinaryDiffEq: NLSolver +using OrdinaryDiffEqNonlinearSolve: NLSolver import OrdinaryDiffEqCore +import OrdinaryDiffEqDifferentiation +import OrdinaryDiffEqNonlinearSolve -if isdefined(OrdinaryDiffEq,:FastConvergence) - using OrdinaryDiffEq: +if isdefined(OrdinaryDiffEqCore,:FastConvergence) + using OrdinaryDiffEqCore: FastConvergence, Convergence, SlowConvergence, VerySlowConvergence, Divergence - import OrdinaryDiffEq: + import OrdinaryDiffEqCore: calculate_residuals, calculate_residuals!, nlsolve_f, unwrap_cache, islinear - using OrdinaryDiffEq: NLFunctional, NLAnderson, NLNewton + using OrdinaryDiffEqNonlinearSolve: NLFunctional, NLAnderson, NLNewton else using DiffEqBase: FastConvergence, Convergence, SlowConvergence, VerySlowConvergence, Divergence diff --git a/src/alg_utils.jl b/src/alg_utils.jl index ee4b86a53..efe38ae18 100644 --- a/src/alg_utils.jl +++ b/src/alg_utils.jl @@ -7,7 +7,7 @@ SciMLBase.isdiscrete(alg::StochasticDiffEqJumpAlgorithm) = true SciMLBase.forwarddiffs_model(alg::Union{StochasticDiffEqNewtonAlgorithm, StochasticDiffEqNewtonAdaptiveAlgorithm,StochasticDiffEqJumpNewtonAdaptiveAlgorithm, - StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm}) = OrdinaryDiffEq.alg_autodiff(alg) + StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm}) = OrdinaryDiffEqCore.alg_autodiff(alg) # Required for initialization, because ODECore._initialize_dae! calls it during # OverrideInit @@ -288,31 +288,31 @@ alg_needs_extra_process(alg::PL1WM) = true alg_needs_extra_process(alg::NON) = true alg_needs_extra_process(alg::NON2) = true -OrdinaryDiffEq._alg_autodiff(alg::StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() -OrdinaryDiffEq._alg_autodiff(alg::StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() -OrdinaryDiffEq._alg_autodiff(alg::StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() -OrdinaryDiffEq._alg_autodiff(alg::StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() +OrdinaryDiffEqDifferentiation._alg_autodiff(alg::StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() +OrdinaryDiffEqDifferentiation._alg_autodiff(alg::StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() +OrdinaryDiffEqDifferentiation._alg_autodiff(alg::StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() +OrdinaryDiffEqDifferentiation._alg_autodiff(alg::StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val{AD}() -OrdinaryDiffEq.get_current_alg_autodiff(alg::StochasticDiffEqCompositeAlgorithm, cache) = OrdinaryDiffEq.alg_autodiff(alg.algs[cache.current]) +OrdinaryDiffEqCore.get_current_alg_autodiff(alg::StochasticDiffEqCompositeAlgorithm, cache) = OrdinaryDiffEqCore.alg_autodiff(alg.algs[cache.current]) -OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) -OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) -OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) -OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) +OrdinaryDiffEqCore.get_chunksize(alg::StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) +OrdinaryDiffEqCore.get_chunksize(alg::StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) +OrdinaryDiffEqCore.get_chunksize(alg::StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) +OrdinaryDiffEqCore.get_chunksize(alg::StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}) where {CS,AD,FDT,ST,CJ,Controller} = Val(CS) -@static if isdefined(OrdinaryDiffEq, :standardtag) - OrdinaryDiffEq.standardtag(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}, +@static if isdefined(OrdinaryDiffEqCore, :standardtag) + OrdinaryDiffEqCore.standardtag(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}, StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}} ) where {CS,AD,FDT,ST,CJ,Controller} = ST end -@static if isdefined(OrdinaryDiffEq, :alg_difftype) - OrdinaryDiffEq.alg_difftype(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}, +@static if isdefined(OrdinaryDiffEqCore, :alg_difftype) + OrdinaryDiffEqCore.alg_difftype(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}, StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}}) where {CS,AD,FDT,ST,CJ,Controller} = FDT end -@static if isdefined(OrdinaryDiffEq, :concrete_jac) - OrdinaryDiffEq.concrete_jac(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}, +@static if isdefined(OrdinaryDiffEqCore, :concrete_jac) + OrdinaryDiffEqCore.concrete_jac(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,CJ,Controller}, StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,CJ,Controller}}) where {CS,AD,FDT,ST,CJ,Controller} = CJ end @@ -366,7 +366,7 @@ end issplit(::StochasticDiffEqAlgorithm) = false issplit(::SplitSDEAlgorithms) = true -function OrdinaryDiffEq.unwrap_alg(integrator::SDEIntegrator, is_stiff) +function OrdinaryDiffEqCore.unwrap_alg(integrator::SDEIntegrator, is_stiff) alg = integrator.alg if !is_composite(alg) return alg diff --git a/src/algorithms.jl b/src/algorithms.jl index eef301386..a02e90f21 100644 --- a/src/algorithms.jl +++ b/src/algorithms.jl @@ -93,7 +93,7 @@ Defaults to solving the Ito problem, but RKMilCommute(interpretation=SciMLBase.A Uses a 1.5/2.0 error estimate for adaptive time stepping. Default: ii_approx=IICommutative() does not approximate the Levy area. """ -struct RKMilCommute{T} <: StochasticDiffEqAdaptiveAlgorithm +struct RKMilCommute{T} <: StochasticDiffEqAdaptiveAlgorithm interpretation::SciMLBase.AlgorithmInterpretation.T ii_approx::T end @@ -658,7 +658,7 @@ struct ImplicitEM{CS,AD,F,F2,P,FDT,ST,CJ,T2,Controller} <: StochasticDiffEqNewto end ImplicitEM(;chunk_size=0,autodiff=true,diff_type=Val{:central}, standardtag = Val{true}(),concrete_jac = nothing, - precs = OrdinaryDiffEq.DEFAULT_PRECS, + precs = OrdinaryDiffEqCore.DEFAULT_PRECS, linsolve=nothing,nlsolve=NLNewton(), extrapolant=:constant, theta = 1,symplectic=false, @@ -666,8 +666,8 @@ ImplicitEM(;chunk_size=0,autodiff=true,diff_type=Val{:central}, controller = :Predictive) = ImplicitEM{chunk_size,autodiff, typeof(linsolve),typeof(nlsolve),typeof(precs),diff_type, - OrdinaryDiffEq._unwrap_val(standardtag), - OrdinaryDiffEq._unwrap_val(concrete_jac), + SciMLBase._unwrap_val(standardtag), + SciMLBase._unwrap_val(concrete_jac), typeof(new_jac_conv_bound),controller}( linsolve,nlsolve,precs, symplectic ? 1/2 : theta, @@ -693,7 +693,7 @@ struct ImplicitEulerHeun{CS,AD,F,P,FDT,ST,CJ,N,T2,Controller} <: StochasticDiffE end ImplicitEulerHeun(;chunk_size=0,autodiff=true,diff_type=Val{:central}, standardtag = Val{true}(),concrete_jac = nothing, - precs = OrdinaryDiffEq.DEFAULT_PRECS, + precs = OrdinaryDiffEqCore.DEFAULT_PRECS, linsolve=nothing,nlsolve=NLNewton(), extrapolant=:constant, theta = 1,symplectic = false, @@ -701,8 +701,8 @@ ImplicitEulerHeun(;chunk_size=0,autodiff=true,diff_type=Val{:central}, controller = :Predictive) = ImplicitEulerHeun{chunk_size,autodiff, typeof(linsolve),typeof(precs),diff_type, - OrdinaryDiffEq._unwrap_val(standardtag), - OrdinaryDiffEq._unwrap_val(concrete_jac), + SciMLBase._unwrap_val(standardtag), + SciMLBase._unwrap_val(concrete_jac), typeof(nlsolve), typeof(new_jac_conv_bound),controller}( linsolve,nlsolve,precs, @@ -729,7 +729,7 @@ struct ImplicitRKMil{CS,AD,F,P,FDT,ST,CJ,N,T2,Controller,interpretation} <: Stoc end ImplicitRKMil(;chunk_size=0,autodiff=true,diff_type=Val{:central}, standardtag = Val{true}(),concrete_jac = nothing, - precs = OrdinaryDiffEq.DEFAULT_PRECS, + precs = OrdinaryDiffEqCore.DEFAULT_PRECS, linsolve=nothing,nlsolve=NLNewton(), extrapolant=:constant, theta = 1,symplectic = false, @@ -737,8 +737,8 @@ ImplicitRKMil(;chunk_size=0,autodiff=true,diff_type=Val{:central}, controller = :Predictive,interpretation=SciMLBase.AlgorithmInterpretation.Ito) = ImplicitRKMil{chunk_size,autodiff, typeof(linsolve),typeof(precs),diff_type, - OrdinaryDiffEq._unwrap_val(standardtag), - OrdinaryDiffEq._unwrap_val(concrete_jac), + SciMLBase._unwrap_val(standardtag), + SciMLBase._unwrap_val(concrete_jac), typeof(nlsolve),typeof(new_jac_conv_bound), controller,interpretation}( linsolve,nlsolve,precs, @@ -764,7 +764,7 @@ struct ISSEM{CS,AD,F,P,FDT,ST,CJ,N,T2,Controller} <: StochasticDiffEqNewtonAdapt end ISSEM(;chunk_size=0,autodiff=true,diff_type=Val{:central}, standardtag = Val{true}(),concrete_jac = nothing, - precs = OrdinaryDiffEq.DEFAULT_PRECS, + precs = OrdinaryDiffEqCore.DEFAULT_PRECS, linsolve=nothing,nlsolve=NLNewton(), extrapolant=:constant, theta = 1,symplectic=false, @@ -772,8 +772,8 @@ ISSEM(;chunk_size=0,autodiff=true,diff_type=Val{:central}, controller = :Predictive) = ISSEM{chunk_size,autodiff, typeof(linsolve),typeof(precs),diff_type, - OrdinaryDiffEq._unwrap_val(standardtag), - OrdinaryDiffEq._unwrap_val(concrete_jac), + SciMLBase._unwrap_val(standardtag), + SciMLBase._unwrap_val(concrete_jac), typeof(nlsolve), typeof(new_jac_conv_bound),controller}( linsolve,nlsolve,precs, @@ -799,7 +799,7 @@ struct ISSEulerHeun{CS,AD,F,P,FDT,ST,CJ,N,T2,Controller} <: StochasticDiffEqNewt end ISSEulerHeun(;chunk_size=0,autodiff=true,diff_type=Val{:central}, standardtag = Val{true}(),concrete_jac = nothing, - precs = OrdinaryDiffEq.DEFAULT_PRECS, + precs = OrdinaryDiffEqCore.DEFAULT_PRECS, linsolve=nothing,nlsolve=NLNewton(), extrapolant=:constant, theta = 1,symplectic=false, @@ -807,8 +807,8 @@ ISSEulerHeun(;chunk_size=0,autodiff=true,diff_type=Val{:central}, controller = :Predictive) = ISSEulerHeun{chunk_size,autodiff, typeof(linsolve),typeof(precs),diff_type, - OrdinaryDiffEq._unwrap_val(standardtag), - OrdinaryDiffEq._unwrap_val(concrete_jac), + SciMLBase._unwrap_val(standardtag), + SciMLBase._unwrap_val(concrete_jac), typeof(nlsolve),typeof(new_jac_conv_bound),controller}( linsolve,nlsolve,precs, symplectic ? 1/2 : theta, @@ -831,13 +831,13 @@ end SKenCarp(;chunk_size=0,autodiff=true,diff_type=Val{:central}, standardtag = Val{true}(),concrete_jac = nothing, - precs = OrdinaryDiffEq.DEFAULT_PRECS, + precs = OrdinaryDiffEqCore.DEFAULT_PRECS, linsolve=nothing,nlsolve=NLNewton(), smooth_est=true,extrapolant=:min_correct, new_jac_conv_bound = 1e-3,controller = :Predictive, ode_error_est = true) = SKenCarp{chunk_size,autodiff,typeof(linsolve),typeof(precs),diff_type, - OrdinaryDiffEq._unwrap_val(standardtag),OrdinaryDiffEq._unwrap_val(concrete_jac), + SciMLBase._unwrap_val(standardtag),SciMLBase._unwrap_val(concrete_jac), typeof(nlsolve),typeof(new_jac_conv_bound),controller}( linsolve,nlsolve,precs,smooth_est,extrapolant,new_jac_conv_bound, ode_error_est) diff --git a/src/caches/implicit_split_step_caches.jl b/src/caches/implicit_split_step_caches.jl index 48e62c3cf..5927002ec 100644 --- a/src/caches/implicit_split_step_caches.jl +++ b/src/caches/implicit_split_step_caches.jl @@ -13,7 +13,7 @@ end function alg_cache(alg::ISSEM, prob, u, ΔW, ΔZ, p, rate_prototype, noise_rate_prototype, jump_rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, f, t, dt, ::Type{Val{true}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta, zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(true)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(true)) fsalfirst = zero(rate_prototype) gtmp = zero(noise_rate_prototype) if is_diagonal_noise(prob) @@ -37,7 +37,7 @@ end function alg_cache(alg::ISSEM, prob, u, ΔW, ΔZ, p, rate_prototype, noise_rate_prototype, jump_rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, f, t, dt, ::Type{Val{false}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta, zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(false)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(false)) ISSEMConstantCache(nlsolver) end @@ -57,7 +57,7 @@ end function alg_cache(alg::ISSEulerHeun, prob, u, ΔW, ΔZ, p, rate_prototype, noise_rate_prototype, jump_rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, f, t, dt, ::Type{Val{true}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta, zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(true)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(true)) fsalfirst = zero(rate_prototype) gtmp = zero(noise_rate_prototype) @@ -84,6 +84,6 @@ end function alg_cache(alg::ISSEulerHeun, prob, u, ΔW, ΔZ, p, rate_prototype, noise_rate_prototype, jump_rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, f, t, dt, ::Type{Val{false}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta, zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(false)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg, u, uprev, p, t, dt, f, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, Val(false)) ISSEulerHeunConstantCache(nlsolver) end diff --git a/src/caches/kencarp_caches.jl b/src/caches/kencarp_caches.jl index eb7f3bbf3..51a86cdc2 100644 --- a/src/caches/kencarp_caches.jl +++ b/src/caches/kencarp_caches.jl @@ -6,7 +6,7 @@ end function alg_cache(alg::SKenCarp,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate_prototype,jump_rate_prototype,::Type{uEltypeNoUnits},::Type{uBottomEltypeNoUnits},::Type{tTypeNoUnits},uprev,f,t,dt,::Type{Val{false}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} tab = SKenCarpTableau(real(uBottomEltypeNoUnits),real(tTypeNoUnits)) γ, c = tab.γ,tab.c3 - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) SKenCarpConstantCache(nlsolver,tab) end @@ -36,7 +36,7 @@ du_cache(c::SKenCarpCache) = (c.nlsolver.k,c.fsalfirst) function alg_cache(alg::SKenCarp,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate_prototype,jump_rate_prototype,::Type{uEltypeNoUnits},::Type{uBottomEltypeNoUnits},::Type{tTypeNoUnits},uprev,f,t,dt,::Type{Val{true}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} tab = SKenCarpTableau(real(uBottomEltypeNoUnits),real(tTypeNoUnits)) γ, c = tab.γ,tab.c3 - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) fsalfirst = zero(rate_prototype) atmp = fill!(similar(u,uEltypeNoUnits),0) diff --git a/src/caches/sdirk_caches.jl b/src/caches/sdirk_caches.jl index 50b3f701d..450b139b8 100644 --- a/src/caches/sdirk_caches.jl +++ b/src/caches/sdirk_caches.jl @@ -20,7 +20,7 @@ function alg_cache(alg::ImplicitEM,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate_pr end γ, c = alg.theta,zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) fsalfirst = zero(rate_prototype) ImplicitEMCache(u,uprev,fsalfirst,gtmp,gtmp2,dW_cache,nlsolver) end @@ -32,7 +32,7 @@ end function alg_cache(alg::ImplicitEM,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate_prototype,jump_rate_prototype, ::Type{uEltypeNoUnits},::Type{uBottomEltypeNoUnits},::Type{tTypeNoUnits},uprev,f,t,dt,::Type{Val{false}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta,zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) ImplicitEMConstantCache(nlsolver) end @@ -64,7 +64,7 @@ function alg_cache(alg::ImplicitEulerHeun,prob,u,ΔW,ΔZ,p,rate_prototype,noise_ end γ, c = alg.theta,zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) fsalfirst = zero(rate_prototype) ImplicitEulerHeunCache(u,uprev,fsalfirst,gtmp,gtmp2,gtmp3,nlsolver,dW_cache) end @@ -76,7 +76,7 @@ end function alg_cache(alg::ImplicitEulerHeun,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate_prototype,jump_rate_prototype, ::Type{uEltypeNoUnits},::Type{uBottomEltypeNoUnits},::Type{tTypeNoUnits},uprev,f,t,dt,::Type{Val{false}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta,zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) ImplicitEulerHeunConstantCache(nlsolver) end @@ -97,7 +97,7 @@ function alg_cache(alg::ImplicitRKMil,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate gtmp3 = zero(rate_prototype) γ, c = alg.theta,zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(true)) fsalfirst = zero(rate_prototype) ImplicitRKMilCache(u,uprev,fsalfirst,gtmp,gtmp2,gtmp3,nlsolver) end @@ -109,6 +109,6 @@ end function alg_cache(alg::ImplicitRKMil,prob,u,ΔW,ΔZ,p,rate_prototype,noise_rate_prototype,jump_rate_prototype, ::Type{uEltypeNoUnits},::Type{uBottomEltypeNoUnits},::Type{tTypeNoUnits},uprev,f,t,dt,::Type{Val{false}}) where {uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits} γ, c = alg.theta,zero(t) - nlsolver = OrdinaryDiffEq.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) + nlsolver = OrdinaryDiffEqNonlinearSolve.build_nlsolver(alg,u,uprev,p,t,dt,f,rate_prototype,uEltypeNoUnits,uBottomEltypeNoUnits,tTypeNoUnits,γ,c,Val(false)) ImplicitRKMilConstantCache(nlsolver) end diff --git a/src/dense.jl b/src/dense.jl index 43bb1211e..aa5d8a61d 100644 --- a/src/dense.jl +++ b/src/dense.jl @@ -118,12 +118,12 @@ function sde_interpolation(tvals,id,idxs,deriv,p,continuity::Symbol=:left) if continuity === :left # we have i₋ = i₊ = 1 if t = ts[1], i₊ = i₋ + 1 = lastindex(ts) if t > ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] < t ≤ ts[i₊] - i₊ = min(lastindex(ts), OrdinaryDiffEq._searchsortedfirst(ts,t,i₊,tdir > 0)) + i₊ = min(lastindex(ts), OrdinaryDiffEqCore._searchsortedfirst(ts,t,i₊,tdir > 0)) i₋ = i₊ > 1 ? i₊ - 1 : i₊ else # we have i₋ = i₊ - 1 = 1 if t < ts[1], i₊ = i₋ = lastindex(ts) if t = ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] ≤ t < ts[i₊] - i₋ = max(1, OrdinaryDiffEq._searchsortedlast(ts,t,i₋,tdir > 0)) + i₋ = max(1, OrdinaryDiffEqCore._searchsortedlast(ts,t,i₋,tdir > 0)) i₊ = i₋ < lastindex(ts) ? i₋ + 1 : i₋ end @@ -154,12 +154,12 @@ function sde_interpolation(tval::Number,id,idxs,deriv,p,continuity::Symbol=:left if continuity === :left # we have i₋ = i₊ = 1 if tval = ts[1], i₊ = i₋ + 1 = lastindex(ts) if tval > ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] < tval ≤ ts[i₊] - i₊ = min(lastindex(ts), OrdinaryDiffEq._searchsortedfirst(ts,tval,2,tdir > 0)) + i₊ = min(lastindex(ts), OrdinaryDiffEqCore._searchsortedfirst(ts,tval,2,tdir > 0)) i₋ = i₊ > 1 ? i₊ - 1 : i₊ else # we have i₋ = i₊ - 1 = 1 if tval < ts[1], i₊ = i₋ = lastindex(ts) if tval = ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] ≤ tval < ts[i₊] - i₋ = max(1, OrdinaryDiffEq._searchsortedlast(ts,tval,1,tdir > 0)) + i₋ = max(1, OrdinaryDiffEqCore._searchsortedlast(ts,tval,1,tdir > 0)) i₊ = i₋ < lastindex(ts) ? i₋ + 1 : i₋ end @@ -179,12 +179,12 @@ function sde_interpolation!(out,tval::Number,id,idxs,deriv,p,continuity::Symbol= if continuity === :left # we have i₋ = i₊ = 1 if tval = ts[1], i₊ = i₋ + 1 = lastindex(ts) if tval > ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] < tval ≤ ts[i₊] - i₊ = min(lastindex(ts), OrdinaryDiffEq._searchsortedfirst(ts,tval,2,tdir > 0)) + i₊ = min(lastindex(ts), OrdinaryDiffEqCore._searchsortedfirst(ts,tval,2,tdir > 0)) i₋ = i₊ > 1 ? i₊ - 1 : i₊ else # we have i₋ = i₊ - 1 = 1 if tval < ts[1], i₊ = i₋ = lastindex(ts) if tval = ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] ≤ tval < ts[i₊] - i₋ = max(1, OrdinaryDiffEq._searchsortedlast(ts,tval,1,tdir > 0)) + i₋ = max(1, OrdinaryDiffEqCore._searchsortedlast(ts,tval,1,tdir > 0)) i₊ = i₋ < lastindex(ts) ? i₋ + 1 : i₋ end @@ -211,12 +211,12 @@ function sde_interpolation!(vals,tvals,id,idxs,deriv,p,continuity::Symbol=:left) if continuity === :left # we have i₋ = i₊ = 1 if t = ts[1], i₊ = i₋ + 1 = lastindex(ts) if t > ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] < t ≤ ts[i₊] - i₊ = min(lastindex(ts), OrdinaryDiffEq._searchsortedfirst(ts,t,i₊,tdir > 0)) + i₊ = min(lastindex(ts), OrdinaryDiffEqCore._searchsortedfirst(ts,t,i₊,tdir > 0)) i₋ = i₊ > 1 ? i₊ - 1 : i₊ else # we have i₋ = i₊ - 1 = 1 if t < ts[1], i₊ = i₋ = lastindex(ts) if t = ts[end], # and otherwise i₋ and i₊ satisfy ts[i₋] ≤ t < ts[i₊] - i₋ = max(1, OrdinaryDiffEq._searchsortedlast(ts,t,i₋,tdir > 0)) + i₋ = max(1, OrdinaryDiffEqCore._searchsortedlast(ts,t,i₋,tdir > 0)) i₊ = i₋ < lastindex(ts) ? i₋ + 1 : i₋ end diff --git a/src/integrators/integrator_interface.jl b/src/integrators/integrator_interface.jl index 930200e9b..6cb3c0695 100644 --- a/src/integrators/integrator_interface.jl +++ b/src/integrators/integrator_interface.jl @@ -309,9 +309,9 @@ function DiffEqBase.reinit!(integrator::SDEIntegrator,u0 = integrator.sol.prob.u tType = typeof(integrator.t) tspan = (tType(t0), tType(tf)) - integrator.opts.tstops = OrdinaryDiffEq.initialize_tstops(tType, tstops, d_discontinuities, tspan) - integrator.opts.saveat = OrdinaryDiffEq.initialize_saveat(tType, saveat, tspan) - integrator.opts.d_discontinuities = OrdinaryDiffEq.initialize_d_discontinuities(tType, d_discontinuities, tspan) + integrator.opts.tstops = OrdinaryDiffEqCore.initialize_tstops(tType, tstops, d_discontinuities, tspan) + integrator.opts.saveat = OrdinaryDiffEqCore.initialize_saveat(tType, saveat, tspan) + integrator.opts.d_discontinuities = OrdinaryDiffEqCore.initialize_d_discontinuities(tType, d_discontinuities, tspan) if erase_sol if integrator.opts.save_start diff --git a/src/integrators/integrator_utils.jl b/src/integrators/integrator_utils.jl index 6fa0e7860..12fc50b01 100644 --- a/src/integrators/integrator_utils.jl +++ b/src/integrators/integrator_utils.jl @@ -382,8 +382,8 @@ end nlsolve!(integrator, cache) = DiffEqBase.nlsolve!(cache.nlsolver, cache.nlsolver.cache, integrator) -OrdinaryDiffEq.nlsolve_f(f, alg::StochasticDiffEqAlgorithm) = f isa SplitSDEFunction && issplit(alg) ? f.f1 : f -OrdinaryDiffEq.nlsolve_f(integrator::SDEIntegrator) = +OrdinaryDiffEqCore.nlsolve_f(f, alg::StochasticDiffEqAlgorithm) = f isa SplitSDEFunction && issplit(alg) ? f.f1 : f +OrdinaryDiffEqCore.nlsolve_f(integrator::SDEIntegrator) = nlsolve_f(integrator.f, unwrap_alg(integrator, true)) function iip_generate_W(alg,u,uprev,p,t,dt,f,uEltypeNoUnits) diff --git a/src/perform_step/implicit_split_step.jl b/src/perform_step/implicit_split_step.jl index fb6c2e22d..c2b0cb2dc 100644 --- a/src/perform_step/implicit_split_step.jl +++ b/src/perform_step/implicit_split_step.jl @@ -5,7 +5,7 @@ alg = unwrap_alg(integrator, true) theta = alg.theta alg.symplectic ? a = dt / 2 : a = theta * dt - OrdinaryDiffEq.markfirststage!(nlsolver) + OrdinaryDiffEqNonlinearSolve.markfirststage!(nlsolver) # TODO: Stochastic extrapolants? u = uprev @@ -32,8 +32,8 @@ end nlsolver.tmp = tmp - z = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return nothing + z = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) + OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return nothing if alg.symplectic u = tmp + z @@ -63,7 +63,7 @@ # This means the Jacobian was never computed! J = f.jac(uprev, p, t) else - J = OrdinaryDiffEq.calc_J(integrator, nlsolver.cache) + J = OrdinaryDiffEqDifferentiation.calc_J(integrator, nlsolver.cache) end Ed = dt * (dt * J * ftmp) / 2 @@ -114,13 +114,13 @@ end @unpack gtmp, gtmp2, dW_cache, nlsolver, k, dz = cache @unpack z, tmp = nlsolver - J = (OrdinaryDiffEq.isnewton(nlsolver) ? nlsolver.cache.J : nothing) + J = (OrdinaryDiffEqCore.isnewton(nlsolver) ? nlsolver.cache.J : nothing) alg = unwrap_alg(integrator, true) alg.symplectic ? a = dt / 2 : a = alg.theta * dt dW = integrator.W.dW mass_matrix = integrator.f.mass_matrix theta = alg.theta - OrdinaryDiffEq.markfirststage!(nlsolver) + OrdinaryDiffEqNonlinearSolve.markfirststage!(nlsolver) repeat_step = false @@ -157,7 +157,7 @@ end # This means the Jacobian was never computed! f.jac(J, uprev, p, t) else - OrdinaryDiffEq.calc_J!(J, integrator, nlsolver.cache) + OrdinaryDiffEqDifferentiation.calc_J!(J, integrator, nlsolver.cache) end mul!(vec(z), J, vec(tmp)) @@ -216,8 +216,8 @@ end @.. tmp = uprev + dt * (1 - theta) * tmp end nlsolver.c = a - z = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return if alg.symplectic @.. u = uprev + z diff --git a/src/perform_step/kencarp.jl b/src/perform_step/kencarp.jl index 5cb4431ce..315d63f73 100644 --- a/src/perform_step/kencarp.jl +++ b/src/perform_step/kencarp.jl @@ -5,7 +5,7 @@ @unpack ea21,ea31,ea32,ea41,ea42,ea43,eb1,eb2,eb3,eb4,ebtilde1,ebtilde2,ebtilde3,ebtilde4 = cache.tab @unpack nb021,nb043 = cache.tab alg = unwrap_alg(integrator, true) - OrdinaryDiffEq.markfirststage!(nlsolver) + OrdinaryDiffEqNonlinearSolve.markfirststage!(nlsolver) sqrt3 = sqrt(3one(eltype(integrator.W.dW))) chi2 = (integrator.W.dW + integrator.W.dZ/sqrt3)/2 #I_(1,0)/h @@ -42,8 +42,8 @@ end nlsolver.z = z₂ - z₂ = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z₂ = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return ################################## Solve Step 3 @@ -64,8 +64,8 @@ end nlsolver.z = z₃ - z₃ = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z₃ = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return ################################## Solve Step 4 @@ -89,8 +89,8 @@ end nlsolver.z = z₄ - z₄ = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z₄ = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return u = tmp + γ*z₄ g4 = g(uprev,p,t+dt) @@ -115,7 +115,7 @@ tmp = btilde1*z₁ + btilde2*z₂ + btilde3*z₃ + btilde4*z₄ + chi2*(g1-g4) end if alg.smooth_est # From Shampine - E₁ = OrdinaryDiffEq._reshape(OrdinaryDiffEq.get_W(nlsolver) \OrdinaryDiffEq._vec(tmp), axes(tmp)) + E₁ = DiffEqBase._reshape(OrdinaryDiffEqDifferentiation.get_W(nlsolver) \DiffEqBase._vec(tmp), axes(tmp)) else E₁ = tmp end @@ -143,7 +143,7 @@ end @unpack ebtilde1,ebtilde2,ebtilde3,ebtilde4 = cache.tab @unpack nb021,nb043 = cache.tab alg = unwrap_alg(integrator, true) - OrdinaryDiffEq.markfirststage!(nlsolver) + OrdinaryDiffEqNonlinearSolve.markfirststage!(nlsolver) repeat_step = false @@ -206,9 +206,9 @@ end nlsolver.z = z₂ nlsolver.c = 2γ - z₂ = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return - OrdinaryDiffEq.isnewton(nlsolver) && OrdinaryDiffEq.set_new_W!(nlsolver, false) + z₂ = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return + OrdinaryDiffEqCore.isnewton(nlsolver) && OrdinaryDiffEqCore.set_new_W!(nlsolver, false) ################################## Solve Step 3 @@ -227,8 +227,8 @@ end end nlsolver.z = z₃ nlsolver.c = c3 - z₃ = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z₃ = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return ################################## Solve Step 4 @@ -251,8 +251,8 @@ end nlsolver.z = z₄ nlsolver.c = one(nlsolver.c) - z₄ = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z₄ = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return g(g4,u,p,t+dt) @@ -291,9 +291,9 @@ end @.. g1 = btilde1*z₁ + btilde2*z₂ + btilde3*z₃ + btilde4*z₄ end if alg.smooth_est # From Shampine - linres = OrdinaryDiffEq.dolinsolve(integrator, nlsolver.cache.linsolve; - b = OrdinaryDiffEq._vec(g1), - linu = OrdinaryDiffEq._vec(E₁)) + linres = OrdinaryDiffEqDifferentiation.dolinsolve(integrator, nlsolver.cache.linsolve; + b = DiffEqBase._vec(g1), + linu = DiffEqBase._vec(E₁)) else E₁ .= dz end diff --git a/src/perform_step/sdirk.jl b/src/perform_step/sdirk.jl index d475a0096..cd98bcdbb 100644 --- a/src/perform_step/sdirk.jl +++ b/src/perform_step/sdirk.jl @@ -5,7 +5,7 @@ @unpack t,dt,uprev,u,p,P,c,f = integrator @unpack nlsolver = cache alg = unwrap_alg(integrator, true) - OrdinaryDiffEq.markfirststage!(nlsolver) + OrdinaryDiffEqNonlinearSolve.markfirststage!(nlsolver) theta = alg.theta alg.symplectic ? a = dt/2 : a = theta*dt @@ -65,8 +65,8 @@ end nlsolver.tmp = tmp - z = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return nothing + z = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return nothing if alg.symplectic u = uprev + z + gtmp @@ -77,9 +77,9 @@ if integrator.opts.adaptive - if !OrdinaryDiffEq.isnewton(nlsolver) + if !OrdinaryDiffEqCore.isnewton(nlsolver) is_compos = isa(integrator.alg, StochasticDiffEqCompositeAlgorithm) - J = OrdinaryDiffEq.calc_J(integrator, nlsolver.cache) + J = OrdinaryDiffEqDifferentiation.calc_J(integrator, nlsolver.cache) end Ed = _reshape(dt*(nlsolver.cache.J*_vec(ftmp))/2, axes(ftmp)) @@ -108,14 +108,14 @@ end @unpack gtmp,gtmp2,nlsolver = cache @unpack z,tmp = nlsolver @unpack k,dz = nlsolver.cache # alias to reduce memory - J = (OrdinaryDiffEq.isnewton(nlsolver) ? nlsolver.cache.J : nothing) + J = (OrdinaryDiffEqCore.isnewton(nlsolver) ? nlsolver.cache.J : nothing) alg = unwrap_alg(integrator, true) alg.symplectic ? a = dt/2 : a = alg.theta*dt dW = integrator.W.dW mass_matrix = integrator.f.mass_matrix theta = alg.theta - OrdinaryDiffEq.markfirststage!(nlsolver) + OrdinaryDiffEqNonlinearSolve.markfirststage!(nlsolver) repeat_step = false @@ -197,8 +197,8 @@ end @.. tmp = uprev + dt*(1-theta)*tmp + gtmp2 end end - z = OrdinaryDiffEq.nlsolve!(nlsolver, integrator, cache, repeat_step) - OrdinaryDiffEq.nlsolvefail(nlsolver) && return + z = OrdinaryDiffEqNonlinearSolve.nlsolve!(nlsolver, integrator, cache, repeat_step) +OrdinaryDiffEqNonlinearSolve.nlsolvefail(nlsolver) && return if alg.symplectic @.. u = uprev + z + gtmp2 diff --git a/src/solve.jl b/src/solve.jl index 92149726d..d52f477e9 100644 --- a/src/solve.jl +++ b/src/solve.jl @@ -70,7 +70,7 @@ function DiffEqBase.__init( initializealg = SDEDefaultInit(), kwargs...) where recompile_flag - is_sde = _prob isa SDEProblem + is_sde = _prob isa SDEProblem use_old_kwargs = haskey(kwargs, :alias_u0) || haskey(kwargs, :alias_jumps) || haskey(kwargs, :alias_noise) @@ -105,7 +105,7 @@ function DiffEqBase.__init( else alias_noise = nothing end - + aliases = is_sde ? SciMLBase.SDEAliasSpecifier(;alias_u0, alias_jumps) : SciMLBase.RODEAliasSpecifier(;alias_u0, alias_jumps, alias_noise) @@ -286,9 +286,9 @@ function DiffEqBase.__init( noise_rate_prototype = nothing end - tstops_internal = OrdinaryDiffEq.initialize_tstops(tType, tstops, d_discontinuities, tspan) - saveat_internal = OrdinaryDiffEq.initialize_saveat(tType, saveat, tspan) - d_discontinuities_internal = OrdinaryDiffEq.initialize_d_discontinuities(tType, d_discontinuities, tspan) + tstops_internal = OrdinaryDiffEqCore.initialize_tstops(tType, tstops, d_discontinuities, tspan) + saveat_internal = OrdinaryDiffEqCore.initialize_saveat(tType, saveat, tspan) + d_discontinuities_internal = OrdinaryDiffEqCore.initialize_d_discontinuities(tType, d_discontinuities, tspan) ### Algorithm-specific defaults ### save_idxs, saved_subsystem = SciMLBase.get_save_idxs_and_saved_subsystem(prob, save_idxs) diff --git a/test/complex_tests.jl b/test/complex_tests.jl index 1b14e2c7c..cefbe1f43 100644 --- a/test/complex_tests.jl +++ b/test/complex_tests.jl @@ -20,7 +20,7 @@ implicit_noautodiff = [SKenCarp(autodiff=false), ImplicitEulerHeun(autodiff=fals # currently broken for alg in implicit_autodiff - @test_throws StochasticDiffEq.OrdinaryDiffEq.FirstAutodiffJacError solve(prob, alg) + @test_throws StochasticDiffEq.OrdinaryDiffEqDifferentiation.FirstAutodiffJacError solve(prob, alg) end end diff --git a/test/utility_tests.jl b/test/utility_tests.jl index 1c6a0b5dc..bdd6babd2 100644 --- a/test/utility_tests.jl +++ b/test/utility_tests.jl @@ -1,13 +1,13 @@ using StochasticDiffEq, LinearAlgebra, SparseArrays, Random, LinearSolve, Test -using StochasticDiffEq.OrdinaryDiffEq: WOperator, calc_W!, calc_W +using StochasticDiffEq.OrdinaryDiffEqDifferentiation: WOperator, calc_W!, calc_W using StochasticDiffEq.SciMLOperators: MatrixOperator using OrdinaryDiffEq #horid nasty hack to deal with temporary calc_W refactor # if there is a method that takes a W_transform argument, define the version that doesn't to set W_transform to true if hasmethod(calc_W, (Any, Any, Any, Any, Any)) - OrdinaryDiffEq.calc_W(integ, nlsolver, dgamma, repeat_step::Bool) = OrdinaryDiffEq.calc_W(integ, nlsolver, dgamma, repeat_step, true) - OrdinaryDiffEq.calc_W!(integ, nlsolver, cache, dgamma, repeat_step::Bool) = OrdinaryDiffEq.calc_W(integ, nlsolver, dgamma, cacherepeat_step, true) + OrdinaryDiffEqDifferentiation.calc_W(integ, nlsolver, dgamma, repeat_step::Bool) = OrdinaryDiffEqDifferentiation.calc_W(integ, nlsolver, dgamma, repeat_step, true) + OrdinaryDiffEqDifferentiation.calc_W!(integ, nlsolver, cache, dgamma, repeat_step::Bool) = OrdinaryDiffEqDifferentiation.calc_W(integ, nlsolver, dgamma, cacherepeat_step, true) end @testset "Derivative Utilities" begin @testset "calc_W!" begin @@ -44,7 +44,7 @@ end ldiv!(tmp, lu!(integrator.cache.nlsolver.cache.W), u0); @test tmp != concrete_W \ u0 # But jacobian2W! will update the cache - StochasticDiffEq.OrdinaryDiffEq.jacobian2W!(integrator.cache.nlsolver.cache.W._concrete_form, mm, dtgamma, integrator.cache.nlsolver.cache.W.J.A) + StochasticDiffEq.OrdinaryDiffEqDifferentiation.jacobian2W!(integrator.cache.nlsolver.cache.W._concrete_form, mm, dtgamma, integrator.cache.nlsolver.cache.W.J.A) @test convert(AbstractMatrix, integrator.cache.nlsolver.cache.W) == concrete_W ldiv!(tmp, lu!(integrator.cache.nlsolver.cache.W), u0); @test tmp == concrete_W \ u0 end