a bunch more for downstream

SciML · Aug 8, 2024 · f30cc7b · f30cc7b
1 parent 2d05624
commit f30cc7b
Show file tree

Hide file tree

Showing 12 changed files with 17 additions and 12 deletions.
diff --git a/lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl b/lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl
@@ -3,7 +3,8 @@ module OrdinaryDiffEqAdamsBashforthMoulton
 import OrdinaryDiffEqCore: OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCache, @cache, alg_cache,
                        initialize!, @unpack, perform_step!, alg_order, isstandard, OrdinaryDiffEqAlgorithm,
                        OrdinaryDiffEqAdaptiveAlgorithm, OrdinaryDiffEqAdamsVarOrderVarStepAlgorithm,
-                       constvalue, calculate_residuals, calculate_residuals!, trivial_limiter!
+                       constvalue, calculate_residuals, calculate_residuals!, trivial_limiter!,
+                       full_cache
 import OrdinaryDiffEqLowOrderRK: BS3ConstantCache, BS3Cache, RK4ConstantCache, RK4Cache
 import RecursiveArrayTools: recursivefill!
 using MuladdMacro, FastBroadcast

diff --git a/lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl b/lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl
@@ -3,7 +3,8 @@ module OrdinaryDiffEqExplicitRK
 import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, alg_stability_size, OrdinaryDiffEqAdaptiveAlgorithm,
                        @cache, alg_cache, OrdinaryDiffEqConstantCache, @unpack, unwrap_alg,
                        OrdinaryDiffEqMutableCache, initialize!, perform_step!, isfsal,
-                       CompositeAlgorithm, calculate_residuals!, calculate_residuals
+                       CompositeAlgorithm, calculate_residuals!, calculate_residuals,
+                       full_cache
 using TruncatedStacktraces, RecursiveArrayTools, FastBroadcast, MuladdMacro, DiffEqBase
 import LinearAlgebra: norm
 

diff --git a/lib/OrdinaryDiffEqExponentialRK/src/OrdinaryDiffEqExponentialRK.jl b/lib/OrdinaryDiffEqExponentialRK/src/OrdinaryDiffEqExponentialRK.jl
@@ -5,7 +5,8 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, ismultistep, OrdinaryD
                         @cache, alg_cache,
                        initialize!, perform_step!, @unpack, unwrap_alg,
                        OrdinaryDiffEqAdaptiveExponentialAlgorithm, CompositeAlgorithm,
-                       ExponentialAlgorithm, fsal_typeof, isdtchangeable, calculate_residuals, calculate_residuals!
+                       ExponentialAlgorithm, fsal_typeof, isdtchangeable, calculate_residuals, calculate_residuals!,
+                       full_cache
 using RecursiveArrayTools
 using MuladdMacro, FastBroadcast
 using LinearAlgebra: axpy!, mul!

diff --git a/lib/OrdinaryDiffEqExtrapolation/src/OrdinaryDiffEqExtrapolation.jl b/lib/OrdinaryDiffEqExtrapolation/src/OrdinaryDiffEqExtrapolation.jl
@@ -11,7 +11,7 @@ import OrdinaryDiffEqCore: alg_order, alg_maximum_order, get_current_adaptive_or
                        OrdinaryDiffEqAdaptiveAlgorithm,
                        OrdinaryDiffEqAdaptiveImplicitAlgorithm,
                        alg_cache, CompiledFloats, @threaded, stepsize_controller!,
-                       DEFAULT_PRECS,
+                       DEFAULT_PRECS, full_cache
                        constvalue, PolyesterThreads, Sequential, BaseThreads,
                        _digest_beta1_beta2, timedepentdtmin, _unwrap_val,
                        _reshape, _vec

diff --git a/lib/OrdinaryDiffEqFunctionMap/src/OrdinaryDiffEqFunctionMap.jl b/lib/OrdinaryDiffEqFunctionMap/src/OrdinaryDiffEqFunctionMap.jl
@@ -4,7 +4,7 @@ import OrdinaryDiffEqCore: isfsal, beta2_default, beta1_default, OrdinaryDiffEqA
                        initialize!, perform_step!, @unpack, unwrap_alg, OrdinaryDiffEqMutableCache,
                        alg_cache, @cache, _ode_addsteps!, _ode_interpolant!, _ode_interpolant,
                        alg_order, OrdinaryDiffEqConstantCache, dt_required,
-                       isdiscretecache, isdiscretealg
+                       isdiscretecache, isdiscretealg, full_cache
 using DiffEqBase
 import RecursiveArrayTools: recursivecopy!
 import FastBroadcast: @..

diff --git a/lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl b/lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl
@@ -5,7 +5,7 @@ import OrdinaryDiffEqCore: alg_order, alg_extrapolates, dt_required, OrdinaryDif
                        OrdinaryDiffEqExponentialAlgorithm,
                        OrdinaryDiffEqMutableCache, @cache, alg_cache, OrdinaryDiffEqConstantCache,
                        initialize!, perform_step!, @unpack, unwrap_alg, calculate_residuals!,
-                       _vec, isdtchangeable
+                       _vec, isdtchangeable, full_cache
 using LinearAlgebra: mul!, I
 using SciMLOperators: AbstractSciMLOperator
 using ExponentialUtilities

diff --git a/lib/OrdinaryDiffEqLowOrderRK/src/OrdinaryDiffEqLowOrderRK.jl b/lib/OrdinaryDiffEqLowOrderRK/src/OrdinaryDiffEqLowOrderRK.jl
@@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, isfsal, beta2_default, beta1_default, alg_
                        @cache, CompiledFloats, alg_cache, CompositeAlgorithm, copyat_or_push!,
                        AutoAlgSwitch, _ode_interpolant, _ode_interpolant!, full_cache,
                        accept_step_controller, DerivativeOrderNotPossibleError,
-                       has_lazy_interpolation
+                       has_lazy_interpolation, du_cache, u_cache
 using SciMLBase
 import MuladdMacro: @muladd
 import FastBroadcast: @..

diff --git a/lib/OrdinaryDiffEqPRK/src/OrdinaryDiffEqPRK.jl b/lib/OrdinaryDiffEqPRK/src/OrdinaryDiffEqPRK.jl
@@ -2,7 +2,8 @@ module OrdinaryDiffEqPRK
 
 import OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, alg_order, OrdinaryDiffEqMutableCache,
                        OrdinaryDiffEqConstantCache, constvalue, @unpack, @cache, alg_cache,
-                       unwrap_alg, perform_step!, @threaded, initialize!, isthreaded
+                       unwrap_alg, perform_step!, @threaded, initialize!, isthreaded,
+                       full_cache
 import MuladdMacro: @muladd
 import FastBroadcast: @..
 using Polyester

diff --git a/lib/OrdinaryDiffEqQPRK/src/OrdinaryDiffEqQPRK.jl b/lib/OrdinaryDiffEqQPRK/src/OrdinaryDiffEqQPRK.jl
@@ -4,7 +4,8 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqAdaptiveAlgorithm, OrdinaryDiffEqConsta
                        explicit_rk_docstring, @cache, @unpack, OrdinaryDiffEqMutableCache,
                        OrdinaryDiffEqAdaptiveAlgorithm, @fold, @OnDemandTableauExtract,
                        trivial_limiter!, alg_cache, alg_order, initialize!, perform_step!,
-                       constvalue, calculate_residuals!, calculate_residuals
+                       constvalue, calculate_residuals!, calculate_residuals,
+                       full_cache
 using Static: False
 using MuladdMacro, FastBroadcast
 using RecursiveArrayTools: recursive_unitless_bottom_eltype, recursivefill!

diff --git a/lib/OrdinaryDiffEqStabilizedIRK/src/OrdinaryDiffEqStabilizedIRK.jl b/lib/OrdinaryDiffEqStabilizedIRK/src/OrdinaryDiffEqStabilizedIRK.jl
@@ -10,7 +10,7 @@ import OrdinaryDiffEqCore: alg_order, alg_maximum_order,
                        OrdinaryDiffEqAdaptiveAlgorithm,
                        OrdinaryDiffEqAdaptiveImplicitAlgorithm,
                        alg_cache, _unwrap_val, DEFAULT_PRECS, @cache,
-                       _reshape, _vec
+                       _reshape, _vec, full_cache
 
 using OrdinaryDiffEqDifferentiation: dolinsolve, update_W!
 using OrdinaryDiffEqNonlinearSolve: NLNewton, nlsolve!, isnewton, build_nlsolver, markfirststage!, du_alias_or_new, get_W

diff --git a/lib/OrdinaryDiffEqStabilizedRK/src/OrdinaryDiffEqStabilizedRK.jl b/lib/OrdinaryDiffEqStabilizedRK/src/OrdinaryDiffEqStabilizedRK.jl
@@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, calculate_residuals!,
                        OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCache,
                        OrdinaryDiffEqAdaptiveAlgorithm, calc_dt_propose!,
                        alg_cache, _vec, _reshape, @cache,
-                       constvalue, _unwrap_val
+                       constvalue, _unwrap_val, full_cache
 using FastBroadcast, MuladdMacro, RecursiveArrayTools
 import StaticArrays: SArray, MVector, SVector, @SVector, StaticArray, MMatrix, SA
 

diff --git a/src/OrdinaryDiffEq.jl b/src/OrdinaryDiffEq.jl
@@ -18,7 +18,7 @@ import OrdinaryDiffEqCore: trivial_limiter!, CompositeAlgorithm, alg_order, Sham
         qmax_default, qsteady_min_default, qsteady_max_default, stepsize_controller!,
         accept_step_controller, step_accept_controller!, step_reject_controller!,
         DummyController, issplit, calculate_residuals, calculate_residuals!,
-        nlsolve_f, unwrap_cache
+        nlsolve_f, unwrap_cache, ode_addsteps!, get_chunksize
 
 export CompositeAlgorithm, ShampineCollocationInit, BrownFullBasicInit, NoInit
        AutoSwitch