fd_typed.jl

│ ─ %-1  = invoke perform_step!(::OrdinaryDiffEq.ODEIntegrator{Tsit5,true,Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Float64,DiffEqBase.NullParameters,Float
64,Float64,Float64,Array{Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},1},ODESolution{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},2,Array{
Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float
64,4},1},1},1},ODEProblem{Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Tuple{Float64,Float64},true,DiffEqBase.NullParameters,ODEFunction{true,typeof(lorenz),L
inearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple
{}}},DiffEqBase.StandardODEProblem},Tsit5,OrdinaryDiffEq.InterpolationData{ODEFunction{true,typeof(lorenz),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothi
ng,Nothing,Nothing,Nothing,Nothing,Nothing},Array{Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},1},Array{Float64,1},Array{Array{Array{ForwardDiff.Dual{ForwardD
iff.Tag{var"#25#26",Float64},Float64,4},1},1},1},OrdinaryDiffEq.Tsit5Cache{Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Array{ForwardDiff.Dual{ForwardDiff.Tag
{var"#25#26",Float64},Float64,4},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}}},DiffEqBase.DEStats},ODEF
unction{true,typeof(lorenz),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},OrdinaryDiffEq.Tsit5Cache{Array{For
wardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#2
6",Float64},Float64,4},1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}},OrdinaryDiffEq.DEOptions{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},ForwardDiff.Dual{Fo
rwardDiff.Tag{var"#25#26",Float64},Float64,4},Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tuple{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_I
SOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.LessThan},DataStructures.BinaryHea
p{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float64,1},Array{Float64,1},Array{Float64,1}},Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Forw
ardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},Nothing},::OrdinaryDiffEq.Tsit5Cache{Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Array{ForwardDi
ff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}},::
Bool)::Core.Compiler.Const(nothing, false)
CodeInfo(
1 ─ %1  = Base.getfield(integrator, :dt)::Float64
│   %2  = Base.getfield(integrator, :uprev)::Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1}
│   %3  = Base.getfield(cache, :tab)::OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}
│   %4  = Base.getfield(%3, :a31)::Float64
│   %5  = Base.getfield(%3, :a32)::Float64
│   %6  = Base.getfield(cache, :k1)::Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1}
│   %7  = Base.getfield(cache, :k2)::Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1}
└── %8  = Base.getfield(cache, :tmp)::Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1}
2 ┄ %9  = φ (#1 => 1, #6 => %71)::Int64
│   %10 = φ (#1 => 1, #6 => %72)::Int64
│   %11 = Base.arrayref(false, %7, %9)::ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4}
│   %12 = Base.arrayref(false, %6, %9)::ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4}
│   %13 = Base.getfield(%12, :value)::Float64
│   %14 = Base.mul_float(%4, %13)::Float64
│   %15 = Base.getfield(%12, :partials)::ForwardDiff.Partials{4,Float64}
│   %16 = Base.getfield(%15, :values)::NTuple{4,Float64}
│   %17 = Base.getfield(%16, 1, false)::Float64
│   %18 = Base.mul_float(%17, %4)::Float64
│   %19 = Base.getfield(%16, 2, false)::Float64
│   %20 = Base.mul_float(%19, %4)::Float64
│   %21 = Base.getfield(%16, 3, false)::Float64
│   %22 = Base.mul_float(%21, %4)::Float64
│   %23 = Base.getfield(%16, 4, false)::Float64
│   %24 = Base.mul_float(%23, %4)::Float64
│   %25 = Base.getfield(%11, :value)::Float64
│   %26 = Base.muladd_float(%25, %5, %14)::Float64
│   %27 = Base.getfield(%11, :partials)::ForwardDiff.Partials{4,Float64}
│   %28 = Base.getfield(%27, :values)::NTuple{4,Float64}
│   %29 = Base.getfield(%28, 1, true)::Float64
│   %30 = Base.muladd_float(%29, %5, %18)::Float64
│   %31 = Base.getfield(%11, :partials)::ForwardDiff.Partials{4,Float64}
│   %32 = Base.getfield(%31, :values)::NTuple{4,Float64}
│   %33 = Base.getfield(%32, 2, true)::Float64
│   %34 = Base.muladd_float(%33, %5, %20)::Float64
│   %35 = Base.getfield(%11, :partials)::ForwardDiff.Partials{4,Float64}
│   %36 = Base.getfield(%35, :values)::NTuple{4,Float64}
│   %37 = Base.getfield(%36, 3, true)::Float64
│   %38 = Base.muladd_float(%37, %5, %22)::Float64
│   %39 = Base.getfield(%11, :partials)::ForwardDiff.Partials{4,Float64}
│   %40 = Base.getfield(%39, :values)::NTuple{4,Float64}
│   %41 = Base.getfield(%40, 4, true)::Float64
│   %42 = Base.muladd_float(%41, %5, %24)::Float64
│   %43 = Base.arrayref(false, %2, %9)::ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4}
│   %44 = Base.getfield(%43, :value)::Float64
│   %45 = Base.muladd_float(%26, %1, %44)::Float64
│   %46 = Base.getfield(%43, :partials)::ForwardDiff.Partials{4,Float64}
│   %47 = Base.getfield(%46, :values)::NTuple{4,Float64}
│   %48 = Base.getfield(%47, 1, true)::Float64
│   %49 = Base.muladd_float(%30, %1, %48)::Float64
│   %50 = Base.getfield(%43, :partials)::ForwardDiff.Partials{4,Float64}
│   %51 = Base.getfield(%50, :values)::NTuple{4,Float64}
│   %52 = Base.getfield(%51, 2, true)::Float64
│   %53 = Base.muladd_float(%34, %1, %52)::Float64
│   %54 = Base.getfield(%43, :partials)::ForwardDiff.Partials{4,Float64}
│   %55 = Base.getfield(%54, :values)::NTuple{4,Float64}
│   %56 = Base.getfield(%55, 3, true)::Float64
│   %57 = Base.muladd_float(%38, %1, %56)::Float64
│   %58 = Base.getfield(%43, :partials)::ForwardDiff.Partials{4,Float64}
│   %59 = Base.getfield(%58, :values)::NTuple{4,Float64}
│   %60 = Base.getfield(%59, 4, true)::Float64
│   %61 = Base.muladd_float(%42, %1, %60)::Float64
│   %62 = Core.tuple(%49, %53, %57, %61)::NTuple{4,Float64}
│   %63 = %new(ForwardDiff.Partials{4,Float64}, %62)::ForwardDiff.Partials{4,Float64}
│   %64 = %new(ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4}, %45, %63)::ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4}
│         Base.arrayset(false, %8, %64, %9)::Array{ForwardDiff.Dual{ForwardDiff.Tag{var"#25#26",Float64},Float64,4},1}
│   %66 = (%10 === 3)::Bool
└──       goto #4 if not %66
3 ─       goto #5
4 ─ %69 = Base.add_int(%10, 1)::Int64
└──       goto #5
5 ┄ %71 = φ (#4 => %69)::Int64
│   %72 = φ (#4 => %69)::Int64
│   %73 = φ (#3 => true, #4 => false)::Bool
│   %74 = Base.not_int(%73)::Bool
└──       goto #7 if not %74
6 ─       goto #2
7 ─       return OrdinaryDiffEq.nothing
)
Select a call to descend into or ↩ to ascend. [q]uit.
Toggles: [o]ptimize, [w]arn, [d]ebuginfo, [s]yntax highlight for LLVM/Native.
Show: [L]LVM IR, [N]ative code
Advanced: dump [P]arams cache.

 • ↩