ERROR: InexactError: Int64(Int64, 1//1000000)


#1

Based on the simple food chain code from here , I have been changing the formulas to something more complex and have run into an error.

My code is

using DifferentialEquations
f = @ode_def_bare FoodChain begin
dBB = r(1-BB/K)*BB - xI*yIB*BI*((BI^h/(BB^h+BI^h))/eIB)
dBI = -xI*BI + xI*yIB*BI*(BI/(BB+BI)) - xT * yTI*BT*(FTI/eTI)
dBT = -xT*BT +xI*yTI*BT*FTI - q*BT*E
end r K xI yIB h eIB xT yTI eTI q E
u0 = [155,107,93]
tspan = (0.0,10000.0)
p = (1.1, 450, 0.18, 10, 1.2, 0.66, 0.06, 10, 0.85, 0.01, 23)
prob = ODEProblem(f,u0,tspan,p)
sol=solve(prob, saveat=0.05)

using Plots
plot(sol,xlabel = "Time" ,ylabel = "Density", lw=0.5, layout = (3,1))

The output and error are:

julia> using DifferentialEquations

julia>

julia> f = @ode_def_bare FoodChain begin

       dBB = r(1-BB/K)*BB - xI*yIB*BI*((BI^h/(BB^h+BI^h))/eIB)

       dBI = -xI*BI + xI*yIB*BI*(BI/(BB+BI)) - xT * yTI*BT*(FTI/eTI)

       dBT = -xT*BT +xI*yTI*BT*FTI - q*BT*E

       end r K xI yIB h eIB xT yTI eTI q E
(::FoodChain{getfield(Main, Symbol("##11#12")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any}) (ge
neric function with 2 methods)

julia>

julia> u0 = [155,107,93]
3-element Array{Int64,1}:
 155
 107
  93

julia>

julia> tspan = (0.0,10000.0)
(0.0, 10000.0)

julia>

julia> p = (1.1, 450, 0.18, 10, 1.2, 0.66, 0.06, 10, 0.85, 0.01, 23)
(1.1, 450, 0.18, 10, 1.2, 0.66, 0.06, 10, 0.85, 0.01, 23)

julia>

julia> prob = ODEProblem(f,u0,tspan,p)
ODEProblem with uType Array{Int64,1} and tType Float64. In-place: true
timespan: (0.0, 10000.0)
u0: [155, 107, 93]

julia>

julia> sol=solve(prob, saveat=0.05)
ERROR: InexactError: Int64(Int64, 1//1000000)
Stacktrace:
 [1] #__init#203(::Int64, ::Float64, ::Array{Float64,1}, ::Array{Float64,1}, ::Nothing, ::Bool, ::No
thing, ::Bool, ::Bool, ::Bool, ::Nothing, ::Bool, ::Bool, ::Float64, ::Bool, ::Rational{Int64}, ::No
thing, ::Nothing, ::Int64, ::Rational{Int64}, ::Int64, ::Int64, ::Rational{Int64}, ::Bool, ::Int64,
::Nothing, ::Nothing, ::Int64, ::Float64, ::Float64, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof
(LinearAlgebra.opnorm), ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFA
ULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Int64, ::Stri
ng, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Nothing, ::Bool, ::Bool, ::Base.Iterators.Pairs
{Symbol,Bool,Tuple{Symbol},NamedTuple{(:default_set,),Tuple{Bool}}}, ::typeof(DiffEqBase.__init), ::
ODEProblem{Array{Int64,1},Tuple{Float64,Float64},true,Tuple{Float64,Int64,Float64,Int64,Float64,Floa
t64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfield(Main, Symbol("##11#12")),Nothing,Nothing
,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.StandardODEProblem}, ::CompositeAlgorithm{Tuple
{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType}},AutoSwitch{Vern9,Rodas
5{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}}, ::Array{
Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at .\rational.jl:85
 [2] (::getfield(DiffEqBase, Symbol("#kw##__init")))(::NamedTuple{(:default_set, :saveat),Tuple{Bool
,Float64}}, ::typeof(DiffEqBase.__init), ::ODEProblem{Array{Int64,1},Tuple{Float64,Float64},true,Tup
le{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfie
ld(Main, Symbol("##11#12")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.Stan
dardODEProblem}, ::CompositeAlgorithm{Tuple{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearAlge
bra.lu!)},DataType}},AutoSwitch{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)},Da
taType},Rational{Int64},Float64}}, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}
) at .\none:0
 [3] #__solve#202(::Base.Iterators.Pairs{Symbol,Real,Tuple{Symbol,Symbol},NamedTuple{(:default_set,
:saveat),Tuple{Bool,Float64}}}, ::Function, ::ODEProblem{Array{Int64,1},Tuple{Float64,Float64},true,
Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{get
field(Main, Symbol("##11#12")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.S
tandardODEProblem}, ::CompositeAlgorithm{Tuple{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearA
lgebra.lu!)},DataType}},AutoSwitch{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)}
,DataType},Rational{Int64},Float64}}, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{tru
e}}) at C:\Users\Helga\.julia\packages\OrdinaryDiffEq\Ih6Ud\src\solve.jl:6
 [4] (::getfield(DiffEqBase, Symbol("#kw##__solve")))(::NamedTuple{(:default_set, :saveat),Tuple{Boo
l,Float64}}, ::typeof(DiffEqBase.__solve), ::ODEProblem{Array{Int64,1},Tuple{Float64,Float64},true,T
uple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getf
ield(Main, Symbol("##11#12")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.St
andardODEProblem}, ::CompositeAlgorithm{Tuple{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearAl
gebra.lu!)},DataType}},AutoSwitch{Vern9,Rodas5{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)},
DataType},Rational{Int64},Float64}}) at .\none:0
 [5] #__solve#2(::Bool, ::Base.Iterators.Pairs{Symbol,Float64,Tuple{Symbol},NamedTuple{(:saveat,),Tu
ple{Float64}}}, ::Function, ::ODEProblem{Array{Int64,1},Tuple{Float64,Float64},true,Tuple{Float64,In
t64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfield(Main, Symb
ol("##11#12")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.StandardODEProble
m}, ::Nothing) at C:\Users\Helga\.julia\packages\DifferentialEquations\88DSk\src\default_solve.jl
:15
 [6] #__solve at .\none:0 [inlined]
 [7] #__solve#1 at C:\Users\Helga\.julia\packages\DifferentialEquations\88DSk\src\default_solve.j
l:5 [inlined]
 [8] #__solve at .\none:0 [inlined]
 [9] #solve#442 at C:\Users\Helga\.julia\packages\DiffEqBase\nW6r3\src\solve.jl:41 [inlined]
 [10] (::getfield(DiffEqBase, Symbol("#kw##solve")))(::NamedTuple{(:saveat,),Tuple{Float64}}, ::type
of(solve), ::ODEProblem{Array{Int64,1},Tuple{Float64,Float64},true,Tuple{Float64,Int64,Float64,Int64
,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfield(Main, Symbol("##11#12")),No
thing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.StandardODEProblem}) at .\none:0
 [11] top-level scope at none:0

julia> using Plots

julia> plot(sol,xlabel = "Time" ,ylabel = "Density", lw=0.5, layout = (3,1))

Why is the error occurring and how could I fix it? And for future reference is it necessary to post the entire output or is it more useful (easier to read) to just post the section where the error occurs?


Something is making Julia think I am using imaginary numbers?
#2

A qualified guess is that you should use a floating point vector here, i.e. u0 = [155.0, 107.0, 93.0]. I think the output vector is allocated based on this input, i.e. a Vector{Int}, and therefor you get this error when you try to insert something that is not convertible to an Int, i.e.

julia> A = [1, 2]; A[1] = 1//2
ERROR: InexactError: Int64(Int64, 1//2)

#3

Thank you for your reply. I have changed u0 to

u0 = [155.0,107.0,93.0]

My code is now

using DifferentialEquations
f = @ode_def_bare FoodChain begin
dBB = r(1-BB/K)*BB - xI*yIB*BI*((BI^h/(BB^h+BI^h))/eIB)
dBI = -xI*BI + xI*yIB*BI*(BI/(BB+BI)) - xT * yTI*BT*(FTI/eTI)
dBT = -xT*BT +xI*yTI*BT*FTI - q*BT*E
end r K xI yIB h eIB xT yTI eTI q E
u0 = [155.0,107.0,93.0]
tspan = (0.0,10000.0)
p = (1.1, 450, 0.18, 10, 1.2, 0.66, 0.06, 10, 0.85, 0.01, 23)
prob = ODEProblem(f,u0,tspan,p)
sol=solve(prob, saveat=0.05)

using Plots
plot(sol,xlabel = "Time" ,ylabel = "Density", lw=0.5, layout = (3,1))

But now generates the error:

julia> sol=solve(prob, saveat=0.05)
ERROR: MethodError: objects of type Float64 are not callable

What else is happening?


#4

The error is because you somewhere do something like

julia> r = 1.0; r(2.0)
ERROR: MethodError: objects of type Float64 are not callable

Primary suspect is r(1-BB/K), but I am just guessing here.


#5

It is also helpful if you show the backtrace and copy paste your code into the REPL to see exactly what line that errors.


#6

I am sorry but I do not understand your example.

EDIT: I think I understand based on here


#7

What is a backtrace?


#8

The stuff that comes after ERROR.


#9

I can post all of it, but it seems quite long. How much would be considered useful?


#10

I found some errors in the formula and have changed the code to

using DifferentialEquations
f = @ode_def_bare FoodChain begin
dBB = r*(1-BB/K)*BB - xI*yIB*BI*((BI^h/(BB^h+BI^h))/eIB)
dBI = -xI*BI + xI*yIB*BI*(BI^h/(BB^h+BI^h)) - xT * yTI*BT*((BT^h/(BI^h+BT^h))/eTI)
dBT = -xT*BT + xI*yTI*BT*(BT^h/(BI^h+BT^h)) - q*BT*E
end r K xI yIB h eIB xT yTI eTI q E
u0 = [155.0,107.0,93.0]
tspan = (0.0,10000.0)
p = (1.1, 450 ,0.18 ,10, 1.2, 0.66, 0.06, 10, 0.85, 0.01, 23)
prob = ODEProblem(f,u0,tspan,p)
sol=solve(prob, saveat=0.05)

using Plots
plot(sol,xlabel = "Time" ,ylabel = "Density", lw=0.5, layout = (3,1))

The Stacktrace is

julia> sol=solve(prob, saveat=0.05)
ERROR: MethodError: objects of type Float64 are not callable
Stacktrace:
 [1] macro expansion at .\none:3 [inlined]
 [2] (::getfield(Main, Symbol("##9#10")))(::Array{Float64,1}, ::Array{Float64,1}, ::Tuple{Float64,In
t64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}, ::Float64) at C:\Users\Helga
\.julia\packages\ParameterizedFunctions\ozDxQ\src\ode_def_opts.jl:249
 [3] (::FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any})
(::Array{Float64,1}, ::Array{Float64,1}, ::Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64
,Int64,Float64,Float64,Int64}, ::Float64) at C:\Users\Helga\.julia\packages\ParameterizedFunctions\o
zDxQ\src\maketype.jl:82
 [4] initialize!(::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,false,
LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSol
veFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}},Array{Float64,1},Float64,
Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},Float64,Float
64,Float64,Array{Array{Float64,1},1},OrdinaryDiffEq.ODECompositeSolution{Float64,2,Array{Array{Float
64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},ODEProblem{Array{Float6
4,1},Tuple{Float64,Float64},true,Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Flo
at64,Float64,Int64},FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothi
ng,Any,Any},Nothing,DiffEqBase.StandardODEProblem},CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,fal
se,LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,Lin
SolveFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}},OrdinaryDiffEq.Composi
teInterpolationData{FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothi
ng,Any,Any},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDi
ffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,
1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}},OrdinaryDiffEq.Rosenbrock23Cache{Array{Float6
4,1},Array{Float64,1},Array{Float64,2},Array{Float64,2},OrdinaryDiffEq.Rosenbrock23ConstantCache{Flo
at64,typeof(identity),typeof(identity)},DiffEqDiffTools.TimeGradientWrapper{FoodChain{getfield(Main,
 Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Array{Float64,1},Tuple{Float64,I
nt64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},DiffEqDiffTools.UJacobianWr
apper{FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Fl
oat64,Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},LinSol
veFactorize{typeof(LinearAlgebra.lu!)},DiffEqDiffTools.JacobianCache{Array{Float64,1},Array{Float64,
1},Array{Float64,1},Val{:central},Float64,Val{true}},DiffEqDiffTools.GradientCache{Nothing,Array{Flo
at64,1},Array{Float64,1},Val{:central},Float64,Val{true}}}},AutoSwitch{Tsit5,Rosenbrock23{0,false,Li
nSolveFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}}}},FoodChain{getfield(
Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},OrdinaryDiffEq.CompositeCac
he{Tuple{OrdinaryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,1},OrdinaryDiffEq
.Tsit5ConstantCache{Float64,Float64}},OrdinaryDiffEq.Rosenbrock23Cache{Array{Float64,1},Array{Float6
4,1},Array{Float64,2},Array{Float64,2},OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64,typeof(ident
ity),typeof(identity)},DiffEqDiffTools.TimeGradientWrapper{FoodChain{getfield(Main, Symbol("##9#10")
),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Array{Float64,1},Tuple{Float64,Int64,Float64,Int6
4,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},DiffEqDiffTools.UJacobianWrapper{FoodChain{g
etfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Float64,Tuple{Float
64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},LinSolveFactorize{typeo
f(LinearAlgebra.lu!)},DiffEqDiffTools.JacobianCache{Array{Float64,1},Array{Float64,1},Array{Float64,
1},Val{:central},Float64,Val{true}},DiffEqDiffTools.GradientCache{Nothing,Array{Float64,1},Array{Flo
at64,1},Val{:central},Float64,Val{true}}}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{t
ypeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}},OrdinaryDiffEq.DEOptions{Float64,Float
64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tupl
e{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE
),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.Les
sThan},DataStructures.BinaryHeap{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float6
4,1},Float64,Array{Float64,1}},Array{Float64,1},Float64}, ::OrdinaryDiffEq.Tsit5Cache{Array{Float64,
1},Array{Float64,1},Array{Float64,1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}}) at C:\User
s\Helga\.julia\packages\OrdinaryDiffEq\Ih6Ud\src\perform_step\low_order_rk_perform_step.jl:580
 [5] initialize!(::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,false,
LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSol
veFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}},Array{Float64,1},Float64,
Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},Float64,Float
64,Float64,Array{Array{Float64,1},1},OrdinaryDiffEq.ODECompositeSolution{Float64,2,Array{Array{Float
64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},ODEProblem{Array{Float6
4,1},Tuple{Float64,Float64},true,Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Flo
at64,Float64,Int64},FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothi
ng,Any,Any},Nothing,DiffEqBase.StandardODEProblem},CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,fal
se,LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,Lin
SolveFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}},OrdinaryDiffEq.Composi
teInterpolationData{FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothi
ng,Any,Any},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDi
ffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,
1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}},OrdinaryDiffEq.Rosenbrock23Cache{Array{Float6
4,1},Array{Float64,1},Array{Float64,2},Array{Float64,2},OrdinaryDiffEq.Rosenbrock23ConstantCache{Flo
at64,typeof(identity),typeof(identity)},DiffEqDiffTools.TimeGradientWrapper{FoodChain{getfield(Main,
 Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Array{Float64,1},Tuple{Float64,I
nt64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},DiffEqDiffTools.UJacobianWr
apper{FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Fl
oat64,Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},LinSol
veFactorize{typeof(LinearAlgebra.lu!)},DiffEqDiffTools.JacobianCache{Array{Float64,1},Array{Float64,
1},Array{Float64,1},Val{:central},Float64,Val{true}},DiffEqDiffTools.GradientCache{Nothing,Array{Flo
at64,1},Array{Float64,1},Val{:central},Float64,Val{true}}}},AutoSwitch{Tsit5,Rosenbrock23{0,false,Li
nSolveFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}}}},FoodChain{getfield(
Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},OrdinaryDiffEq.CompositeCac
he{Tuple{OrdinaryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,1},OrdinaryDiffEq
.Tsit5ConstantCache{Float64,Float64}},OrdinaryDiffEq.Rosenbrock23Cache{Array{Float64,1},Array{Float6
4,1},Array{Float64,2},Array{Float64,2},OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64,typeof(ident
ity),typeof(identity)},DiffEqDiffTools.TimeGradientWrapper{FoodChain{getfield(Main, Symbol("##9#10")
),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Array{Float64,1},Tuple{Float64,Int64,Float64,Int6
4,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},DiffEqDiffTools.UJacobianWrapper{FoodChain{g
etfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Float64,Tuple{Float
64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},LinSolveFactorize{typeo
f(LinearAlgebra.lu!)},DiffEqDiffTools.JacobianCache{Array{Float64,1},Array{Float64,1},Array{Float64,
1},Val{:central},Float64,Val{true}},DiffEqDiffTools.GradientCache{Nothing,Array{Float64,1},Array{Flo
at64,1},Val{:central},Float64,Val{true}}}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{t
ypeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float64}},OrdinaryDiffEq.DEOptions{Float64,Float
64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tupl
e{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE
),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.Les
sThan},DataStructures.BinaryHeap{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float6
4,1},Float64,Array{Float64,1}},Array{Float64,1},Float64}, ::OrdinaryDiffEq.CompositeCache{Tuple{Ordi
naryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,1},OrdinaryDiffEq.Tsit5Constan
tCache{Float64,Float64}},OrdinaryDiffEq.Rosenbrock23Cache{Array{Float64,1},Array{Float64,1},Array{Fl
oat64,2},Array{Float64,2},OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64,typeof(identity),typeof(i
dentity)},DiffEqDiffTools.TimeGradientWrapper{FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Not
hing,Nothing,Nothing,Nothing,Any,Any},Array{Float64,1},Tuple{Float64,Int64,Float64,Int64,Float64,Flo
at64,Float64,Int64,Float64,Float64,Int64}},DiffEqDiffTools.UJacobianWrapper{FoodChain{getfield(Main,
 Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Float64,Tuple{Float64,Int64,Floa
t64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64}},LinSolveFactorize{typeof(LinearAlgeb
ra.lu!)},DiffEqDiffTools.JacobianCache{Array{Float64,1},Array{Float64,1},Array{Float64,1},Val{:centr
al},Float64,Val{true}},DiffEqDiffTools.GradientCache{Nothing,Array{Float64,1},Array{Float64,1},Val{:
central},Float64,Val{true}}}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(LinearA
lgebra.lu!)},DataType},Rational{Int64},Float64}}) at C:\Users\Helga\.julia\packages\OrdinaryDiffEq\I
h6Ud\src\perform_step\composite_perform_step.jl:38
 [6] #__init#203(::Int64, ::Float64, ::Array{Float64,1}, ::Array{Float64,1}, ::Nothing, ::Bool, ::No
thing, ::Bool, ::Bool, ::Bool, ::Nothing, ::Bool, ::Bool, ::Float64, ::Bool, ::Rational{Int64}, ::No
thing, ::Nothing, ::Int64, ::Rational{Int64}, ::Int64, ::Int64, ::Rational{Int64}, ::Bool, ::Int64,
::Nothing, ::Nothing, ::Int64, ::Float64, ::Float64, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof
(LinearAlgebra.opnorm), ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFA
ULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Int64, ::Stri
ng, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Nothing, ::Bool, ::Bool, ::Base.Iterators.Pairs
{Symbol,Bool,Tuple{Symbol},NamedTuple{(:default_set,),Tuple{Bool}}}, ::typeof(DiffEqBase.__init), ::
ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Tuple{Float64,Int64,Float64,Int64,Float64,Fl
oat64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfield(Main, Symbol("##9#10")),Nothing,Nothin
g,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.StandardODEProblem}, ::CompositeAlgorithm{Tupl
e{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType}},AutoSwitch{Tsit
5,Rosenbrock23{0,false,LinSolveFactorize{typeof(LinearAlgebra.lu!)},DataType},Rational{Int64},Float6
4}}, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\Helga\.julia\pac
kages\OrdinaryDiffEq\Ih6Ud\src\solve.jl:270
 [7] (::getfield(DiffEqBase, Symbol("#kw##__init")))(::NamedTuple{(:default_set, :saveat),Tuple{Bool
,Float64}}, ::typeof(DiffEqBase.__init), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,T
uple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getf
ield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.Sta
ndardODEProblem}, ::CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(Lin
earAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(LinearAlg
ebra.lu!)},DataType},Rational{Int64},Float64}}, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Ty
pe{Val{true}}) at .\none:0
 [8] #__solve#202(::Base.Iterators.Pairs{Symbol,Real,Tuple{Symbol,Symbol},NamedTuple{(:default_set,
:saveat),Tuple{Bool,Float64}}}, ::Function, ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},tru
e,Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{g
etfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.
StandardODEProblem}, ::CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(
LinearAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(Linear
Algebra.lu!)},DataType},Rational{Int64},Float64}}, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, :
:Type{Val{true}}) at C:\Users\Helga\.julia\packages\OrdinaryDiffEq\Ih6Ud\src\solve.jl:6
 [9] (::getfield(DiffEqBase, Symbol("#kw##__solve")))(::NamedTuple{(:default_set, :saveat),Tuple{Boo
l,Float64}}, ::typeof(DiffEqBase.__solve), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true
,Tuple{Float64,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{ge
tfield(Main, Symbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.S
tandardODEProblem}, ::CompositeAlgorithm{Tuple{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(L
inearAlgebra.lu!)},DataType}},AutoSwitch{Tsit5,Rosenbrock23{0,false,LinSolveFactorize{typeof(LinearA
lgebra.lu!)},DataType},Rational{Int64},Float64}}) at .\none:0
 [10] #__solve#2(::Bool, ::Base.Iterators.Pairs{Symbol,Float64,Tuple{Symbol},NamedTuple{(:saveat,),T
uple{Float64}}}, ::Function, ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Tuple{Float64
,Int64,Float64,Int64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfield(Main, S
ymbol("##9#10")),Nothing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.StandardODEProb
lem}, ::Nothing) at C:\Users\Helga\.julia\packages\DifferentialEquations\88DSk\src\default_solve.jl:
15
 [11] #__solve at .\none:0 [inlined]
 [12] #__solve#1 at C:\Users\Helga\.julia\packages\DifferentialEquations\88DSk\src\default_solve.jl:
5 [inlined]
 [13] #__solve at .\none:0 [inlined]
 [14] #solve#442 at C:\Users\Helga\.julia\packages\DiffEqBase\nW6r3\src\solve.jl:41 [inlined]
 [15] (::getfield(DiffEqBase, Symbol("#kw##solve")))(::NamedTuple{(:saveat,),Tuple{Float64}}, ::type
of(solve), ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Tuple{Float64,Int64,Float64,Int
64,Float64,Float64,Float64,Int64,Float64,Float64,Int64},FoodChain{getfield(Main, Symbol("##9#10")),N
othing,Nothing,Nothing,Nothing,Nothing,Any,Any},Nothing,DiffEqBase.StandardODEProblem}) at .\none:0
 [16] top-level scope at none:0