Merge pull request #598 from oameye/OrdinaryDiffEqCore

build: replace OrdinaryDiffEq with OrdinaryDiffEqCore

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"]

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

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

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,16 +658,16 @@ 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,
                           new_jac_conv_bound = 1e-3,
                           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,16 +693,16 @@ 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,
                           new_jac_conv_bound = 1e-3,
                           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,16 +729,16 @@ 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,
                           new_jac_conv_bound = 1e-3,
                           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,16 +764,16 @@ 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,
                        new_jac_conv_bound = 1e-3,
                        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,16 +799,16 @@ 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,
                       new_jac_conv_bound = 1e-3,
                       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)

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