Switch to DifferentiationInterface in Implicit Solvers

.github/workflows/CI.yml

@@ -94,4 +94,4 @@ jobs:
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           file: lcov.info
-          fail_ci_if_error: false
+          fail_ci_if_error: true

.github/workflows/Downstream.yml

@@ -77,4 +77,4 @@ jobs:
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           file: lcov.info
-          fail_ci_if_error: true
+          fail_ci_if_error: false

lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl

@@ -9,12 +9,13 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCac
                            constvalue, calculate_residuals, calculate_residuals!,
                            trivial_limiter!, get_fsalfirstlast,
                            generic_solver_docstring,
-                           full_cache
+                           full_cache,
+                           _bool_to_ADType
 import OrdinaryDiffEqLowOrderRK: BS3ConstantCache, BS3Cache, RK4ConstantCache, RK4Cache
 import RecursiveArrayTools: recursivefill!
 using MuladdMacro, FastBroadcast
 import Static: False
-import ADTypes: AutoForwardDiff
+import ADTypes: AutoForwardDiff, AbstractADType
 import OrdinaryDiffEqCore
 
 using Reexport

lib/OrdinaryDiffEqBDF/Project.toml

@@ -1,9 +1,10 @@
 name = "OrdinaryDiffEqBDF"
 uuid = "6ad6398a-0878-4a85-9266-38940aa047c8"
 authors = ["ParamThakkar123 <[email protected]>"]
-version = "1.1.2"
+version = "1.2"
 
 [deps]
+ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"
 FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898"
@@ -31,7 +32,7 @@ LinearAlgebra = "<0.0.1, 1"
 MacroTools = "0.5.13"
 MuladdMacro = "0.2.4"
 ODEProblemLibrary = "0.1.8"
-OrdinaryDiffEqCore = "1.1"
+OrdinaryDiffEqCore = "1.11"
 OrdinaryDiffEqDifferentiation = "<0.0.1, 1"
 OrdinaryDiffEqNonlinearSolve = "<0.0.1, 1"
 OrdinaryDiffEqSDIRK = "<0.0.1, 1"

lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl

@@ -20,7 +20,8 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!,
                            step_accept_controller!,
                            step_reject_controller!, post_newton_controller!,
                            u_modified!, DAEAlgorithm, _unwrap_val, DummyController,
-                           get_fsalfirstlast, generic_solver_docstring
+                           get_fsalfirstlast, generic_solver_docstring, _bool_to_ADType,
+                           _process_AD_choice
 using OrdinaryDiffEqSDIRK: ImplicitEulerConstantCache, ImplicitEulerCache
 
 using TruncatedStacktraces, MuladdMacro, MacroTools, FastBroadcast, RecursiveArrayTools
@@ -32,6 +33,8 @@ using OrdinaryDiffEqDifferentiation: UJacobianWrapper
 using OrdinaryDiffEqNonlinearSolve: NLNewton, du_alias_or_new, build_nlsolver,
                                     nlsolve!, nlsolvefail, isnewton, markfirststage!,
                                     set_new_W!, DIRK, compute_step!, COEFFICIENT_MULTISTEP
+import ADTypes
+import ADTypes: AutoForwardDiff, AutoFiniteDiff, AbstractADType
 
 using Reexport
 @reexport using DiffEqBase

lib/OrdinaryDiffEqBDF/src/algorithms.jl

@@ -5,7 +5,7 @@ function BDF_docstring(description::String,
         extra_keyword_default::String = "")
     keyword_default = """
         chunk_size = Val{0}(),
-        autodiff = true,
+        autodiff = AutoForwardDiff(),
         standardtag = Val{true}(),
         concrete_jac = nothing,
         diff_type = Val{:forward},
@@ -112,18 +112,22 @@ struct ABDF2{CS, AD, F, F2, P, FDT, ST, CJ, K, T, StepLimiter} <:
     extrapolant::Symbol
     controller::Symbol
     step_limiter!::StepLimiter
+    autodiff::AD
 end
-function ABDF2(; chunk_size = Val{0}(), autodiff = true, standardtag = Val{true}(),
+function ABDF2(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         κ = nothing, tol = nothing, linsolve = nothing, precs = DEFAULT_PRECS,
         nlsolve = NLNewton(),
         smooth_est = true, extrapolant = :linear,
         controller = :Standard, step_limiter! = trivial_limiter!)
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
     ABDF2{
-        _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve), typeof(nlsolve),
+        _unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve), typeof(nlsolve),
         typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
         typeof(κ), typeof(tol), typeof(step_limiter!)}(linsolve, nlsolve, precs, κ, tol,
-        smooth_est, extrapolant, controller, step_limiter!)
+        smooth_est, extrapolant, controller, step_limiter!, AD_choice)
 end
 
 @doc BDF_docstring(
@@ -167,14 +171,18 @@ struct SBDF{CS, AD, F, F2, P, FDT, ST, CJ, K, T} <:
     extrapolant::Symbol
     order::Int
     ark::Bool
+    autodiff::AD
 end
 
-function SBDF(order; chunk_size = Val{0}(), autodiff = Val{true}(),
+function SBDF(order; chunk_size = Val{0}(), autodiff = AutoForwardDiff(),
         standardtag = Val{true}(), concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(), κ = nothing,
         tol = nothing,
         extrapolant = :linear, ark = false)
-    SBDF{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve), typeof(nlsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    SBDF{_unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve), typeof(nlsolve),
         typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
         typeof(κ), typeof(tol)}(linsolve,
         nlsolve,
@@ -183,17 +191,21 @@ function SBDF(order; chunk_size = Val{0}(), autodiff = Val{true}(),
         tol,
         extrapolant,
         order,
-        ark)
+        ark,
+        AD_choice)
 end
 
 # All keyword form needed for remake
-function SBDF(; chunk_size = Val{0}(), autodiff = Val{true}(), standardtag = Val{true}(),
+function SBDF(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(), κ = nothing,
         tol = nothing,
         extrapolant = :linear,
         order, ark = false)
-    SBDF{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve), typeof(nlsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    SBDF{_unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve), typeof(nlsolve),
         typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
         typeof(κ), typeof(tol)}(linsolve,
         nlsolve,
@@ -202,7 +214,8 @@ function SBDF(; chunk_size = Val{0}(), autodiff = Val{true}(), standardtag = Val
         tol,
         extrapolant,
         order,
-        ark)
+        ark,
+        AD_choice)
 end
 
 """
@@ -287,23 +300,28 @@ struct QNDF1{CS, AD, F, F2, P, FDT, ST, CJ, κType, StepLimiter} <:
     kappa::κType
     controller::Symbol
     step_limiter!::StepLimiter
+    autodiff::AD
 end
 
-function QNDF1(; chunk_size = Val{0}(), autodiff = Val{true}(), standardtag = Val{true}(),
+function QNDF1(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(),
         extrapolant = :linear, kappa = -37 // 200,
         controller = :Standard, step_limiter! = trivial_limiter!)
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
     QNDF1{
-        _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve), typeof(nlsolve),
+        _unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve), typeof(nlsolve),
         typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
         typeof(kappa), typeof(step_limiter!)}(linsolve,
         nlsolve,
         precs,
         extrapolant,
         kappa,
         controller,
-        step_limiter!)
+        step_limiter!,
+        AD_choice)
 end
 
 @doc BDF_docstring(
@@ -342,23 +360,28 @@ struct QNDF2{CS, AD, F, F2, P, FDT, ST, CJ, κType, StepLimiter} <:
     kappa::κType
     controller::Symbol
     step_limiter!::StepLimiter
+    autodiff::AD
 end
 
-function QNDF2(; chunk_size = Val{0}(), autodiff = Val{true}(), standardtag = Val{true}(),
+function QNDF2(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(),
         extrapolant = :linear, kappa = -1 // 9,
         controller = :Standard, step_limiter! = trivial_limiter!)
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
     QNDF2{
-        _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve), typeof(nlsolve),
+        _unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve), typeof(nlsolve),
         typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
         typeof(kappa), typeof(step_limiter!)}(linsolve,
         nlsolve,
         precs,
         extrapolant,
         kappa,
         controller,
-        step_limiter!)
+        step_limiter!,
+        AD_choice)
 end
 
 @doc BDF_docstring(
@@ -405,22 +428,26 @@ struct QNDF{MO, CS, AD, F, F2, P, FDT, ST, CJ, K, T, κType, StepLimiter} <:
     kappa::κType
     controller::Symbol
     step_limiter!::StepLimiter
+    autodiff::AD
 end
 
 function QNDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
-        autodiff = Val{true}(), standardtag = Val{true}(), concrete_jac = nothing,
+        autodiff = AutoForwardDiff(), standardtag = Val{true}(), concrete_jac = nothing,
         diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(), κ = nothing,
         tol = nothing,
         extrapolant = :linear, kappa = (
             -37 // 200, -1 // 9, -823 // 10000, -83 // 2000, 0 // 1),
         controller = :Standard, step_limiter! = trivial_limiter!) where {MO}
-    QNDF{MO, _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    QNDF{MO, _unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),
         _unwrap_val(concrete_jac),
         typeof(κ), typeof(tol), typeof(kappa), typeof(step_limiter!)}(
         max_order, linsolve, nlsolve, precs, κ, tol,
-        extrapolant, kappa, controller, step_limiter!)
+        extrapolant, kappa, controller, step_limiter!, AD_choice)
 end
 
 TruncatedStacktraces.@truncate_stacktrace QNDF
@@ -452,17 +479,22 @@ struct MEBDF2{CS, AD, F, F2, P, FDT, ST, CJ} <:
     nlsolve::F2
     precs::P
     extrapolant::Symbol
+    autodiff::AD
 end
-function MEBDF2(; chunk_size = Val{0}(), autodiff = true, standardtag = Val{true}(),
+function MEBDF2(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(),
         extrapolant = :constant)
-    MEBDF2{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    MEBDF2{_unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),
         _unwrap_val(concrete_jac)}(linsolve,
         nlsolve,
         precs,
-        extrapolant)
+        extrapolant,
+        AD_choice)
 end
 
 @doc BDF_docstring(
@@ -504,20 +536,24 @@ struct FBDF{MO, CS, AD, F, F2, P, FDT, ST, CJ, K, T, StepLimiter} <:
     extrapolant::Symbol
     controller::Symbol
     step_limiter!::StepLimiter
+    autodiff::AD
 end
 
 function FBDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
-        autodiff = Val{true}(), standardtag = Val{true}(), concrete_jac = nothing,
+        autodiff = AutoForwardDiff(), standardtag = Val{true}(), concrete_jac = nothing,
         diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(), κ = nothing,
         tol = nothing,
         extrapolant = :linear, controller = :Standard, step_limiter! = trivial_limiter!) where {MO}
-    FBDF{MO, _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    FBDF{MO, _unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),
         _unwrap_val(concrete_jac),
         typeof(κ), typeof(tol), typeof(step_limiter!)}(
         max_order, linsolve, nlsolve, precs, κ, tol, extrapolant,
-        controller, step_limiter!)
+        controller, step_limiter!, AD_choice)
 end
 
 TruncatedStacktraces.@truncate_stacktrace FBDF
@@ -620,17 +656,21 @@ struct DImplicitEuler{CS, AD, F, F2, P, FDT, ST, CJ} <: DAEAlgorithm{CS, AD, FDT
     precs::P
     extrapolant::Symbol
     controller::Symbol
+    autodiff::AD
 end
 function DImplicitEuler(;
-        chunk_size = Val{0}(), autodiff = true, standardtag = Val{true}(),
+        chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(),
         extrapolant = :constant,
         controller = :Standard)
-    DImplicitEuler{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    DImplicitEuler{_unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),
         _unwrap_val(concrete_jac)}(linsolve,
-        nlsolve, precs, extrapolant, controller)
+        nlsolve, precs, extrapolant, controller, AD_choice)
 end
 
 @doc BDF_docstring("Fully implicit implementation of BDF2.",
@@ -659,16 +699,20 @@ struct DABDF2{CS, AD, F, F2, P, FDT, ST, CJ} <: DAEAlgorithm{CS, AD, FDT, ST, CJ
     precs::P
     extrapolant::Symbol
     controller::Symbol
+    autodiff::AD
 end
-function DABDF2(; chunk_size = Val{0}(), autodiff = Val{true}(), standardtag = Val{true}(),
+function DABDF2(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(),
         extrapolant = :constant,
         controller = :Standard)
-    DABDF2{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    DABDF2{_unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),
         _unwrap_val(concrete_jac)}(linsolve,
-        nlsolve, precs, extrapolant, controller)
+        nlsolve, precs, extrapolant, controller, AD_choice)
 end
 
 #=
@@ -718,18 +762,22 @@ struct DFBDF{MO, CS, AD, F, F2, P, FDT, ST, CJ, K, T} <: DAEAlgorithm{CS, AD, FD
     tol::T
     extrapolant::Symbol
     controller::Symbol
+    autodiff::AD
 end
 function DFBDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
-        autodiff = Val{true}(), standardtag = Val{true}(), concrete_jac = nothing,
+        autodiff = AutoForwardDiff(), standardtag = Val{true}(), concrete_jac = nothing,
         diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(), κ = nothing,
         tol = nothing,
         extrapolant = :linear, controller = :Standard) where {MO}
-    DFBDF{MO, _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+
+    AD_choice = _process_AD_choice(autodiff, chunk_size, diff_type)
+
+    DFBDF{MO, _unwrap_val(chunk_size), typeof(AD_choice), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),
         _unwrap_val(concrete_jac),
         typeof(κ), typeof(tol)}(max_order, linsolve, nlsolve, precs, κ, tol, extrapolant,
-        controller)
+        controller, AD_choice)
 end
 
 TruncatedStacktraces.@truncate_stacktrace DFBDF