OrdinaryDiffEq.jl/lib/OrdinaryDiffEqTaylorSeries/src/OrdinaryDiffEqTaylorSeries.jl at e451f4036f5bb7a1020299aa491ec05ca05f95ec · SciML/OrdinaryDiffEq.jl · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
module OrdinaryDiffEqTaylorSeries

import OrdinaryDiffEqCore: alg_order, get_current_adaptive_order, get_current_alg_order,
                           alg_stability_size, explicit_rk_docstring,
                           OrdinaryDiffEqAdaptiveAlgorithm, OrdinaryDiffEqMutableCache,
                           alg_cache,
                           OrdinaryDiffEqConstantCache, @fold, trivial_limiter!,
                           step_accept_controller!,
                           stepsize_controller!,
                           unwrap_alg,
                           constvalue, @unpack, perform_step!, calculate_residuals, @cache,
                           calculate_residuals!, _ode_interpolant, _ode_interpolant!,
                           CompiledFloats, @OnDemandTableauExtract, initialize!,
                           perform_step!, OrdinaryDiffEqAlgorithm,
                           CompositeAlgorithm, _ode_addsteps!, copyat_or_push!,
                           AutoAlgSwitch, get_fsalfirstlast,
                           full_cache, DerivativeOrderNotPossibleError
import Static: False
import MuladdMacro: @muladd
import FastBroadcast: @..
import RecursiveArrayTools: recursivefill!, recursive_unitless_bottom_eltype
import LinearAlgebra: norm
using TruncatedStacktraces
using TaylorDiff, Symbolics
using TaylorDiff: make_seed, get_coefficient, append_coefficient, flatten
import DiffEqBase: @def
import OrdinaryDiffEqCore

using Reexport
@reexport using DiffEqBase

include("algorithms.jl")
include("alg_utils.jl")
include("TaylorSeries_caches.jl")
include("TaylorSeries_perform_step.jl")

import PrecompileTools
import Preferences

PrecompileTools.@compile_workload begin
    lorenz = OrdinaryDiffEqCore.lorenz
    lorenz_oop = OrdinaryDiffEqCore.lorenz_oop
    solver_list = [ExplicitTaylor2()]
    prob_list = []

    if Preferences.@load_preference("PrecompileNoSpecialize", false)
        push!(prob_list,
            ODEProblem{true, SciMLBase.NoSpecialize}(lorenz, [1.0; 0.0; 0.0], (0.0, 1.0)))
        push!(prob_list,
            ODEProblem{true, SciMLBase.NoSpecialize}(lorenz, [1.0; 0.0; 0.0], (0.0, 1.0),
                Float64[]))
    end

    for prob in prob_list, solver in solver_list
        solve(prob, solver)(5.0)
    end

    prob_list = nothing
    solver_list = nothing
end

export ExplicitTaylor2, ExplicitTaylor, ExplicitTaylorAdaptiveOrder

end