DiffEqBiological Tutorial II: Network Properties API

Samuel Isaacson

The DiffEqBiological API provides a collection of functions for easily accessing network properties, and for incrementally building and extending a network. In this tutorial we'll go through the API, and then illustrate how to programmatically construct a network.

We'll illustrate the API using a toggle-switch like network that contains a variety of different reaction types:

using DifferentialEquations, DiffEqBiological, Latexify, Plots
fmt = :svg
pyplot(fmt=fmt)
rn = @reaction_network begin
    hillr(D₂,α,K,n),  --> m₁
    hillr(D₁,α,K,n),  --> m₂
    (δ,γ), m₁  
    (δ,γ), m₂  
    β, m₁ --> m₁ + P₁
    β, m₂ --> m₂ + P₂
    μ, P₁ --> 
    μ, P₂ --> 
    (k₊,k₋), 2P₁  D₁ 
    (k₊,k₋), 2P₂  D₂
    (k₊,k₋), P₁+P₂  T
end α K n δ γ β μ k₊ k₋;

This corresponds to the chemical reaction network given by

latexify(rn; env=:chemical)
\begin{align*} \require{mhchem} \ce{ \varnothing &->[\frac{\alpha \cdot K^{n}}{K^{n} + D_2^{n}}] m_{1}}\\ \ce{ \varnothing &->[\frac{\alpha \cdot K^{n}}{K^{n} + D_1^{n}}] m_{2}}\\ \ce{ m_{1} &<=>[\delta][\gamma] \varnothing}\\ \ce{ m_{2} &<=>[\delta][\gamma] \varnothing}\\ \ce{ m_{1} &->[\beta] m_{1} + P_{1}}\\ \ce{ m_{2} &->[\beta] m_{2} + P_{2}}\\ \ce{ P_{1} &->[\mu] \varnothing}\\ \ce{ P_{2} &->[\mu] \varnothing}\\ \ce{ 2 \cdot P_1 &<=>[k_{+}][k_{-}] D_{1}}\\ \ce{ 2 \cdot P_2 &<=>[k_{+}][k_{-}] D_{2}}\\ \ce{ P_{1} + P_{2} &<=>[k_{+}][k_{-}] T} \end{align*}

Network Properties

Basic properties of the generated network include the speciesmap and paramsmap functions we examined in the last tutorial, along with the corresponding species and params functions:

species(rn)
7-element Array{Symbol,1}:
 :m₁
 :m₂
 :P₁
 :P₂
 :D₁
 :D₂
 :T
params(rn)
9-element Array{Symbol,1}:
 :α 
 :K 
 :n 
 :δ 
 :γ 
 :β 
 :μ 
 :k₊
 :k₋

The numbers of species, parameters and reactions can be accessed using numspecies(rn), numparams(rn) and numreactions(rn).

A number of functions are available to access properties of reactions within the generated network, including substrates, products, dependents, ismassaction, substratestoich, substratesymstoich, productstoich, productsymstoich, and netstoich. Each of these functions takes two arguments, the reaction network rn and the index of the reaction to query information about. For example, to find the substrate symbols and their corresponding stoichiometries for the 11th reaction, 2P₁ --> D₁, we would use

substratesymstoich(rn, 11)
1-element Array{DiffEqBiological.ReactantStruct,1}:
 DiffEqBiological.ReactantStruct(:P₁, 2)

Broadcasting works on all these functions, allowing the construction of a vector holding the queried information across all reactions, i.e.

substratesymstoich.(rn, 1:numreactions(rn))
16-element Array{Array{DiffEqBiological.ReactantStruct,1},1}:
 []                                              
 []                                              
 [ReactantStruct(:m₁, 1)]                        
 []                                              
 [ReactantStruct(:m₂, 1)]                        
 []                                              
 [ReactantStruct(:m₁, 1)]                        
 [ReactantStruct(:m₂, 1)]                        
 [ReactantStruct(:P₁, 1)]                        
 [ReactantStruct(:P₂, 1)]                        
 [ReactantStruct(:P₁, 2)]                        
 [ReactantStruct(:D₁, 1)]                        
 [ReactantStruct(:P₂, 2)]                        
 [ReactantStruct(:D₂, 1)]                        
 [ReactantStruct(:P₁, 1), ReactantStruct(:P₂, 1)]
 [ReactantStruct(:T, 1)]

To see the net stoichiometries for all reactions we would use

netstoich.(rn, 1:numreactions(rn))
16-element Array{Array{Pair{Int64,Int64},1},1}:
 [1=>1]              
 [2=>1]              
 [1=>-1]             
 [1=>1]              
 [2=>-1]             
 [2=>1]              
 [3=>1]              
 [4=>1]              
 [3=>-1]             
 [4=>-1]             
 [3=>-2, 5=>1]       
 [3=>2, 5=>-1]       
 [4=>-2, 6=>1]       
 [4=>2, 6=>-1]       
 [3=>-1, 4=>-1, 7=>1]
 [3=>1, 4=>1, 7=>-1]

Here the first integer in each pair corresponds to the index of the species (with symbol species(rn)[index]). The second integer corresponds to the net stoichiometric coefficient of the species within the reaction. substratestoich and productstoich are defined similarly.

Several functions are also provided that calculate different types of dependency graphs. These include rxtospecies_depgraph, which provides a mapping from reaction index to the indices of species whose population changes when the reaction occurs:

rxtospecies_depgraph(rn)
16-element Array{Array{Int64,1},1}:
 [1]      
 [2]      
 [1]      
 [1]      
 [2]      
 [2]      
 [3]      
 [4]      
 [3]      
 [4]      
 [3, 5]   
 [3, 5]   
 [4, 6]   
 [4, 6]   
 [3, 4, 7]
 [3, 4, 7]

Here the last row indicates that the species with indices [3,4,7] will change values when the reaction T --> P₁ + P₂ occurs. To confirm these are the correct species we can look at

species(rn)[[3,4,7]]
3-element Array{Symbol,1}:
 :P₁
 :P₂
 :T

The speciestorx_depgraph similarly provides a mapping from species to reactions for which their rate laws depend on that species. These correspond to all reactions for which the given species is in the dependent set of the reaction. We can verify this for the first species, m₁:

speciestorx_depgraph(rn)[1]
2-element Array{Int64,1}:
 3
 7
findall(depset -> in(:m₁, depset), dependents.(rn, 1:numreactions(rn)))
2-element Array{Int64,1}:
 3
 7

Finally, rxtorx_depgraph provides a mapping that shows when a given reaction occurs, which other reactions have rate laws that involve species whose value would have changed:

rxtorx_depgraph(rn)
16-element Array{Array{Int64,1},1}:
 [1, 3, 7]              
 [2, 5, 8]              
 [3, 7]                 
 [3, 4, 7]              
 [5, 8]                 
 [5, 6, 8]              
 [7, 9, 11, 15]         
 [8, 10, 13, 15]        
 [9, 11, 15]            
 [10, 13, 15]           
 [2, 9, 11, 12, 15]     
 [2, 9, 11, 12, 15]     
 [1, 10, 13, 14, 15]    
 [1, 10, 13, 14, 15]    
 [9, 10, 11, 13, 15, 16]
 [9, 10, 11, 13, 15, 16]

Note on Using Network Property API Functions

Many basic network query and reaction property functions are simply accessors, returning information that is already stored within the generated reaction_network. For these functions, modifying the returned data structures may lead to inconsistent internal state within the network. As such, they should be used for accessing, but not modifying, network properties. The API documentation indicates which functions return newly allocated data structures and which return data stored within the reaction_network.


Incremental Construction of Networks

The @reaction_network macro is monolithic, in that it not only constructs and stores basic network properties such as the reaction stoichiometries, but also generates everything needed to immediately solve ODE, SDE and jump models using the network. This includes Jacobian functions, noise functions, and jump functions for each reaction. While this allows for a compact interface to the DifferentialEquations.jl solvers, it can also be computationally expensive for large networks, where a user may only wish to solve one type of problem and/or have fine-grained control over what is generated. In addition, some types of reaction network structures are more amenable to being constructed programmatically, as opposed to writing out all reactions by hand within one macro. For these reasons DiffEqBiological provides two additional macros that only initially setup basic reaction network properties, and which can be extended through a programmatic interface: @min_reaction_network and @empty_reaction_network. We now give an introduction to constructing these more minimal network representations, and how they can be programmatically extended. See also the relevant API section.

The @min_reaction_network macro works identically to the @reaction_network macro, but the generated network will only be complete with respect to its representation of chemical network properties (i.e. species, parameters and reactions). No ODE, SDE or jump models are generated during the macro call. It can subsequently be extended with the addition of new species, parameters or reactions. The @empty_reaction_network allocates an empty network structure that can also be extended using the programmatic interface. For example, consider a partial version of the toggle-switch like network we defined above:

rnmin = @min_reaction_network begin
    (δ,γ), m₁  
    (δ,γ), m₂  
    β, m₁ --> m₁ + P₁
    β, m₂ --> m₂ + P₂
    μ, P₁ --> 
    μ, P₂ --> 
end δ γ β μ;

Here we have left out the first two, and last three, reactions from the original reaction_network. To expand the network until it is functionally equivalent to the original model we add back in the missing species, parameters, and finally the missing reactions. Note, it is required that species and parameters be defined before any reactions using them are added. The necessary network extension functions are given by addspecies!, addparam! and addreaction!, and described in the API. To complete rnmin we first add the relevant species:

addspecies!(rnmin, :D₁)
addspecies!(rnmin, :D₂)
addspecies!(rnmin, :T)

Next we add the needed parameters

addparam!(rnmin, )
addparam!(rnmin, :K)
addparam!(rnmin, :n)
addparam!(rnmin, :k₊)
addparam!(rnmin, :k₋)

Note, both addspecies! and addparam! also accept strings encoding the variable names (which are then converted to Symbols internally).

We are now ready to add the missing reactions. The API provides two forms of the addreaction! function, one takes expressions analogous to what one would write in the macro:

addreaction!(rnmin, :(hillr(D₁,α,K,n)), :( --> m₂))
addreaction!(rnmin, :((k₊,k₋)), :(2P₂  D₂))
addreaction!(rnmin, :k₊, :(2P₁ --> D₁))
addreaction!(rnmin, :k₋, :(D₁ --> 2P₁))

The rate can be an expression or symbol as above, but can also just be a numeric value. The second form of addreaction! takes tuples of Pair{Symbol,Int} that encode the stoichiometric coefficients of substrates and reactants:

# signature is addreaction!(rnmin, paramexpr, substratestoich, productstoich)
addreaction!(rnmin, :(hillr(D₂,α,K,n)), (), (:m₁ => 1,))
addreaction!(rnmin, :k₊, (:P₁=>1, :P₂=>1), (:T=>1,))
addreaction!(rnmin, :k₋, (:T=>1,), (:P₁=>1, :P₂=>1))

Let's check that rn and rnmin have the same set of species:

setdiff(species(rn), species(rnmin))
0-element Array{Symbol,1}

the same set of params:

setdiff(params(rn), params(rnmin))
0-element Array{Symbol,1}

and the final reaction has the same substrates, reactions, and rate expression:

rxidx = numreactions(rn)
setdiff(substrates(rn, rxidx), substrates(rnmin, rxidx))
0-element Array{Symbol,1}
setdiff(products(rn, rxidx), products(rnmin, rxidx))
0-element Array{Symbol,1}
rateexpr(rn, rxidx) == rateexpr(rnmin, rxidx)
true

Extending Incrementally Generated Networks to Include ODEs, SDEs or Jumps

Once a network generated from @min_reaction_network or @empty_reaction_network has had all the associated species, parameters and reactions filled in, corresponding ODE, SDE or jump models can be constructed. The relevant API functions are addodes!, addsdes! and addjumps!. One benefit to contructing models with these functions is that they offer more fine-grained control over what actually gets constructed. For example, addodes! has the optional keyword argument, build_jac, which if set to false will disable construction of symbolic Jacobians and functions for evaluating Jacobians. For large networks this can give a significant speed-up in the time required for constructing an ODE model. Each function and its associated keyword arguments are described in the API section, Functions to add ODEs, SDEs or Jumps to a Network.

Let's extend rnmin to include the needed functions for use in ODE solvers:

addodes!(rnmin)

The Generated Functions for Models section of the API shows what functions have been generated. For ODEs these include oderhsfun(rnmin), which returns a function of the form f(du,u,p,t) which evaluates the ODEs (i.e. the time derivatives of u) within du. For each generated function, the corresponding expressions from which it was generated can be retrieved using accessors from the Generated Expressions section of the API. The equations within du can be retrieved using the odeexprs(rnmin) function. For example:

odeexprs(rnmin)
7-element Array{Union{Float64, Int64, Expr, Symbol},1}:
 :((-(δ * m₁) + γ) + (α * K ^ n) / (K ^ n + D₂ ^ n))                       
               
 :((-(δ * m₂) + γ) + (α * K ^ n) / (K ^ n + D₁ ^ n))                       
               
 :(((((β * m₁ - μ * P₁) + -2 * (k₊ / 2) * P₁ ^ 2) + 2 * k₋ * D₁) - k₊ * P₁ 
* P₂) + k₋ * T)
 :(((((β * m₂ - μ * P₂) + -2 * (k₊ / 2) * P₂ ^ 2) + 2 * k₋ * D₂) - k₊ * P₁ 
* P₂) + k₋ * T)
 :((k₊ / 2) * P₁ ^ 2 - k₋ * D₁)                                            
               
 :((k₊ / 2) * P₂ ^ 2 - k₋ * D₂)                                            
               
 :(k₊ * P₁ * P₂ - k₋ * T)

Using Latexify we can see the ODEs themselves to compare with these expressions:

latexify(rnmin)
\begin{align*} \frac{dm_1}{dt} =& - \delta \cdot m_1 + \gamma + \frac{\alpha \cdot K^{n}}{K^{n} + D_2^{n}} \\ \frac{dm_2}{dt} =& - \delta \cdot m_2 + \gamma + \frac{\alpha \cdot K^{n}}{K^{n} + D_1^{n}} \\ \frac{dP_1}{dt} =& \beta \cdot m_1 - \mu \cdot P_1 -2 \cdot \frac{k_+}{2} \cdot P_1^{2} + 2 \cdot k_- \cdot D_1 - k_+ \cdot P_1 \cdot P_2 + k_- \cdot T \\ \frac{dP_2}{dt} =& \beta \cdot m_2 - \mu \cdot P_2 -2 \cdot \frac{k_+}{2} \cdot P_2^{2} + 2 \cdot k_- \cdot D_2 - k_+ \cdot P_1 \cdot P_2 + k_- \cdot T \\ \frac{dD_1}{dt} =& \frac{k_+}{2} \cdot P_1^{2} - k_- \cdot D_1 \\ \frac{dD_2}{dt} =& \frac{k_+}{2} \cdot P_2^{2} - k_- \cdot D_2 \\ \frac{dT}{dt} =& k_+ \cdot P_1 \cdot P_2 - k_- \cdot T \\ \end{align*}

For ODEs two other functions are generated by addodes!. jacfun(rnmin) will return the generated Jacobian evaluation function, fjac(dJ,u,p,t), which given the current solution u evaluates the Jacobian within dJ. jacobianexprs(rnmin) gives the corresponding matrix of expressions, which can be used with Latexify to see the Jacobian:

latexify(jacobianexprs(rnmin))
\begin{equation*} \left[ \begin{array}{ccccccc} - \delta & 0 & 0 & 0 & 0 & \frac{ - K^{n} \cdot n \cdot \alpha \cdot D_2^{-1 + n}}{\left( K^{n} + D_2^{n} \right)^{2}} & 0 \\ 0 & - \delta & 0 & 0 & \frac{ - K^{n} \cdot n \cdot \alpha \cdot D_1^{-1 + n}}{\left( K^{n} + D_1^{n} \right)^{2}} & 0 & 0 \\ \beta & 0 & - \mu - 2 \cdot k_+ \cdot P_1 - k_+ \cdot P_2 & - k_+ \cdot P_1 & 2 \cdot k_- & 0 & k_{-} \\ 0 & \beta & - k_+ \cdot P_2 & - \mu - 2 \cdot k_+ \cdot P_2 - k_+ \cdot P_1 & 0 & 2 \cdot k_- & k_{-} \\ 0 & 0 & k_+ \cdot P_1 & 0 & - k_- & 0 & 0 \\ 0 & 0 & 0 & k_+ \cdot P_2 & 0 & - k_- & 0 \\ 0 & 0 & k_+ \cdot P_2 & k_+ \cdot P_1 & 0 & 0 & - k_- \\ \end{array} \right] \end{equation*}

addodes! also generates a function that evaluates the Jacobian of the ODE derivative functions with respect to the parameters. paramjacfun(rnmin) then returns the generated function. It has the form fpjac(dPJ,u,p,t), which given the current solution u evaluates the Jacobian matrix with respect to parameters p within dPJ. For use in DifferentialEquations.jl solvers, an ODEFunction representation of the ODEs is available from odefun(rnmin).

addsdes! and addjumps! work similarly to complete the network for use in StochasticDiffEq and DiffEqJump solvers.

Note on Using Generated Function and Expression API Functions

The generated functions and expressions accessible through the API require first calling the appropriate addodes!, addsdes or addjumps function. These are responsible for actually constructing the underlying functions and expressions. The API accessors simply return already constructed functions and expressions that are stored within the reaction_network structure.


Example of Generating a Network Programmatically

For a user directly typing in a reaction network, it is generally easier to use the @min_reaction_network or @reaction_network macros to fully specify reactions. However, for large, structured networks it can be much easier to generate the network programmatically. For very large networks, with tens of thousands of reactions, the form of addreaction! that uses stoichiometric coefficients should be preferred as it offers substantially better performance. To put together everything we've seen, let's generate the network corresponding to a 1D continuous time random walk, approximating the diffusion of molecules within an interval.

The basic "reaction" network we wish to study is

\[ u_1 \leftrightarrows u_2 \leftrightarrows u_3 \cdots \leftrightarrows u_{N} \]

for $N$ lattice sites on $[0,1]$. For $h = 1/N$ the lattice spacing, we'll assume the rate molecules hop from their current site to any particular neighbor is just $h^{-2}$. We can interpret this hopping process as a collection of $2N-2$ "reactions", with the form $u_i \to u_j$ for $j=i+1$ or $j=i-1$. We construct the corresponding reaction network as follows. First we set values for the basic parameters:

N = 64
h = 1 / N
0.015625

then we create an empty network, and add each species

rn = @empty_reaction_network

for i = 1:N
    addspecies!(rn, Symbol(:u, i))
end

We next add one parameter β, which we will set equal to the hopping rate of molecules, $h^{-2}$:

addparam!(rn, )

Finally, we add in the $2N-2$ possible hopping reactions:

for i = 1:N
    (i < N) && addreaction!(rn, , (Symbol(:u,i)=>1,), (Symbol(:u,i+1)=>1,))
    (i > 1) && addreaction!(rn, , (Symbol(:u,i)=>1,), (Symbol(:u,i-1)=>1,))
end

Let's first construct an ODE model for the network

addodes!(rn)

We now need to specify the initial condition, parameter vector and time interval to solve on. We start with 10000 molecules placed at the center of the domain, and setup an ODEProblem to solve:

u₀ = zeros(N)
u₀[div(N,2)] = 10000
p = [1/(h*h)]
tspan = (0.,.01)
oprob = ODEProblem(rn, u₀, tspan, p)
ODEProblem with uType Array{Float64,1} and tType Float64. In-place: true
timespan: (0.0, 0.01)
u0: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0  …  0.0, 0.0, 0.0, 0.
0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

We are now ready to solve the problem and plot the solution. Since we have essentially generated a method of lines discretization of the diffusion equation with a discontinuous initial condition, we'll use an A-L stable implicit ODE solver, Rodas5, and plot the solution at a few times:

sol = solve(oprob, Rodas5())
times = [0., .0001, .001, .01]
plt = plot()
for time in times
    plot!(plt, 1:N, sol(time), fmt=fmt, xlabel="i", ylabel="uᵢ", label=string("t = ", time), lw=3)
end
plot(plt, ylims=(0.,10000.))

Here we see the characteristic diffusion of molecules from the center of the domain, resulting in a shortening and widening of the solution as $t$ increases.

Let's now look at a stochastic chemical kinetics jump process version of the model, where β gives the probability per time each molecule can hop from its current lattice site to an individual neighboring site. We first add in the jumps, disabling regular_jumps since they are not needed, and using the minimal_jumps flag to construct a minimal representation of the needed jumps. We then construct a JumpProblem, and use the Composition-Rejection Direct method, DirectCR, to simulate the process of the molecules hopping about on the lattice:

addjumps!(rn, build_regular_jumps=false, minimal_jumps=true)

# make the initial condition integer valued 
u₀ = zeros(Int, N)
u₀[div(N,2)] = 10000

# setup and solve the problem
dprob = DiscreteProblem(rn, u₀, tspan, p)
jprob = JumpProblem(dprob, DirectCR(), rn, save_positions=(false,false))
jsol = solve(jprob, SSAStepper(), saveat=times)
retcode: Default
Interpolation: Piecewise constant interpolation
t: 4-element Array{Float64,1}:
 0.0   
 0.0001
 0.001 
 0.01  
u: 4-element Array{Array{Int64,1},1}:
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0  …  0, 0, 0, 0, 0, 0, 0, 0, 0, 0]       
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0  …  0, 0, 0, 0, 0, 0, 0, 0, 0, 0]       
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0  …  0, 0, 0, 0, 0, 0, 0, 0, 0, 0]       
 [3, 4, 2, 3, 12, 6, 5, 17, 21, 22  …  19, 13, 10, 9, 5, 5, 4, 1, 0, 0]

We can now plot bar graphs showing the locations of the molecules at the same set of times we examined the ODE solution. For comparison, we also plot the corresponding ODE solutions (red lines) that we found:

times = [0., .0001, .001, .01]
plts = []
for i = 1:4
    b = bar(1:N, jsol[i], legend=false, fmt=fmt, xlabel="i", ylabel="uᵢ", title=string("t = ", times[i]))
    plot!(b,sol(times[i]))
    push!(plts,b)
end
plot(plts...)

Similar to the ODE solutions, we see that the molecules spread out and become more and more well-mixed throughout the domain as $t$ increases. The simulation results are noisy due to the finite numbers of molecules present in the stochsatic simulation, but since the number of molecules is large they agree well with the ODE solution at each time.


Getting Help

Have a question related to DiffEqBiological or this tutorial? Feel free to ask in the DifferentialEquations.jl Gitter. If you think you've found a bug in DiffEqBiological, or would like to request/discuss new functionality, feel free to open an issue on Github (but please check there is no related issue already open). If you've found a bug in this tutorial, or have a suggestion, feel free to open an issue on the DiffEqTutorials Github site. Or, submit a pull request to DiffEqTutorials updating the tutorial!


Appendix

This tutorial is part of the DiffEqTutorials.jl repository, found at: https://github.com/JuliaDiffEq/DiffEqTutorials.jl

To locally run this tutorial, do the following commands:

using DiffEqTutorials
DiffEqTutorials.weave_file("models","04-diffeqbio_II_networkproperties.jmd")

Computer Information:

Julia Version 1.1.1
Commit 55e36cc (2019-05-16 04:10 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin15.6.0)
  CPU: Intel(R) Core(TM) i7-6920HQ CPU @ 2.90GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.1 (ORCJIT, skylake)

Package Information:

Status `~/.julia/environments/v1.1/Project.toml`
[14f7f29c-3bd6-536c-9a0b-7339e30b5a3e] AMD 0.3.0
[28f2ccd6-bb30-5033-b560-165f7b14dc2f] ApproxFun 0.11.3
[c52e3926-4ff0-5f6e-af25-54175e0327b1] Atom 0.8.5
[aae01518-5342-5314-be14-df237901396f] BandedMatrices 0.9.4
[6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf] BenchmarkTools 0.4.2
[ad839575-38b3-5650-b840-f874b8c74a25] Blink 0.10.1
[336ed68f-0bac-5ca0-87d4-7b16caf5d00b] CSV 0.5.11
[5d742f6a-9f54-50ce-8119-2520741973ca] CSVFiles 0.15.0
[159f3aea-2a34-519c-b102-8c37f9878175] Cairo 0.5.6
[3da002f7-5984-5a60-b8a6-cbb66c0b333f] ColorTypes 0.8.0
[a93c6f00-e57d-5684-b7b6-d8193f3e46c0] DataFrames 0.19.2
[864edb3b-99cc-5e75-8d2d-829cb0a9cfe8] DataStructures 0.17.0
[2b5f629d-d688-5b77-993f-72d75c75574e] DiffEqBase 5.20.0
[eb300fae-53e8-50a0-950c-e21f52c2b7e0] DiffEqBiological 3.9.0
[f3b72e0c-5b89-59e1-b016-84e28bfd966d] DiffEqDevTools 2.14.0
[c894b116-72e5-5b58-be3c-e6d8d4ac2b12] DiffEqJump 6.2.0
[78ddff82-25fc-5f2b-89aa-309469cbf16f] DiffEqMonteCarlo 0.15.1
[9fdde737-9c7f-55bf-ade8-46b3f136cc48] DiffEqOperators 4.1.0
[34035eb4-37db-58ae-b003-a3202c898701] DiffEqPDEBase 0.4.0
[a077e3f3-b75c-5d7f-a0c6-6bc4c8ec64a9] DiffEqProblemLibrary 4.5.1
[6d1b261a-3be8-11e9-3f2f-0b112a9a8436] DiffEqTutorials 0.1.0
[0c46a032-eb83-5123-abaf-570d42b7fbaa] DifferentialEquations 6.6.0
[aaf54ef3-cdf8-58ed-94cc-d582ad619b94] DistributedArrays 0.6.3
[31c24e10-a181-5473-b8eb-7969acd0382f] Distributions 0.21.1
[e30172f5-a6a5-5a46-863b-614d45cd2de4] Documenter 0.23.2
[5789e2e9-d7fb-5bc7-8068-2c6fae9b9549] FileIO 1.0.7
[f6369f11-7733-5829-9624-2563aa707210] ForwardDiff 0.10.3
[069b7b12-0de2-55c6-9aab-29f3d0a68a2e] FunctionWrappers 1.0.0
[28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71] GR 0.41.0
[14197337-ba66-59df-a3e3-ca00e7dcff7a] GenericLinearAlgebra 0.1.0
[4c0ca9eb-093a-5379-98c5-f87ac0bbbf44] Gtk 0.17.0
[19dc6840-f33b-545b-b366-655c7e3ffd49] HCubature 1.4.0
[f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f] HDF5 0.12.0
[cd3eb016-35fb-5094-929b-558a96fad6f3] HTTP 0.7.1
[09f84164-cd44-5f33-b23f-e6b0d136a0d5] HypothesisTests 0.8.0
[7073ff75-c697-5162-941a-fcdaad2a7d2a] IJulia 1.19.0
[42fd0dbc-a981-5370-80f2-aaf504508153] IterativeSolvers 0.8.1
[30d91d44-8115-11e8-1d28-c19a5ac16de8] JuAFEM 0.2.0
[f80590ac-b429-510a-8a99-e7c46989f22d] JuliaFEM 0.5.0
[aa1ae85d-cabe-5617-a682-6adf51b2e16a] JuliaInterpreter 0.5.2
[e5e0dc1b-0480-54bc-9374-aad01c23163d] Juno 0.7.2
[0b1a1467-8014-51b9-945f-bf0ae24f4b77] KrylovKit 0.3.4
[b964fa9f-0449-5b57-a5c2-d3ea65f4040f] LaTeXStrings 1.0.3
[2b0e0bc5-e4fd-59b4-8912-456d1b03d8d7] LanguageServer 0.6.0
[23fbe1c1-3f47-55db-b15f-69d7ec21a316] Latexify 0.8.2
[5078a376-72f3-5289-bfd5-ec5146d43c02] LazyArrays 0.9.1
[093fc24a-ae57-5d10-9952-331d41423f4d] LightGraphs 1.2.0
[7a12625a-238d-50fd-b39a-03d52299707e] LinearMaps 2.5.0
[23992714-dd62-5051-b70f-ba57cb901cac] MAT 0.5.0
[1914dd2f-81c6-5fcd-8719-6d5c9610ff09] MacroTools 0.5.1
[961ee093-0014-501f-94e3-6117800e7a78] ModelingToolkit 0.6.4
[46d2c3a1-f734-5fdb-9937-b9b9aeba4221] MuladdMacro 0.2.1
[47be7bcc-f1a6-5447-8b36-7eeeff7534fd] ORCA 0.2.1
[510215fc-4207-5dde-b226-833fc4488ee2] Observables 0.2.3
[5fb14364-9ced-5910-84b2-373655c76a03] OhMyREPL 0.5.1
[bac558e1-5e72-5ebc-8fee-abe8a469f55d] OrderedCollections 1.1.0
[1dea7af3-3e70-54e6-95c3-0bf5283fa5ed] OrdinaryDiffEq 5.14.0
[3b7a836e-365b-5785-a47d-02c71176b4aa] PGFPlots 3.1.3
[9b87118b-4619-50d2-8e1e-99f35a4d4d9d] PackageCompiler 0.6.4
[65888b18-ceab-5e60-b2b9-181511a3b968] ParameterizedFunctions 4.2.1
[d96e819e-fc66-5662-9728-84c9c7592b0a] Parameters 0.11.0
[995b91a9-d308-5afd-9ec6-746e21dbc043] PlotUtils 0.5.8
[58dd65bb-95f3-509e-9936-c39a10fdeae7] Plotly 0.2.0
[f0f68f2c-4968-5e81-91da-67840de0976a] PlotlyJS 0.12.5
[91a5bcdd-55d7-5caf-9e0b-520d859cae80] Plots 0.26.1
[f27b6e38-b328-58d1-80ce-0feddd5e7a45] Polynomials 0.5.2
[27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae] Primes 0.4.0
[c46f51b8-102a-5cf2-8d2c-8597cb0e0da7] ProfileView 0.4.1
[438e738f-606a-5dbb-bf0a-cddfbfd45ab0] PyCall 1.91.2
[d330b81b-6aea-500a-939a-2ce795aea3ee] PyPlot 2.8.1
[1fd47b50-473d-5c70-9696-f719f8f3bcdc] QuadGK 2.0.3
[e6cf234a-135c-5ec9-84dd-332b85af5143] RandomNumbers 1.3.0
[b4db0fb7-de2a-5028-82bf-5021f5cfa881] ReactionNetworkImporters 0.1.5
[295af30f-e4ad-537b-8983-00126c2a3abe] Revise 2.1.6
[c4c386cf-5103-5370-be45-f3a111cca3b8] Rsvg 0.2.3
[276daf66-3868-5448-9aa4-cd146d93841b] SpecialFunctions 0.7.2
[90137ffa-7385-5640-81b9-e52037218182] StaticArrays 0.11.0
[2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91] StatsBase 0.32.0
[f3b207a7-027a-5e70-b257-86293d7955fd] StatsPlots 0.10.2
[9672c7b4-1e72-59bd-8a11-6ac3964bc41f] SteadyStateDiffEq 1.5.0
[789caeaf-c7a9-5a7d-9973-96adeb23e2a0] StochasticDiffEq 6.8.0
[c3572dad-4567-51f8-b174-8c6c989267f4] Sundials 3.6.1
[123dc426-2d89-5057-bbad-38513e3affd8] SymEngine 0.7.0
[e0df1984-e451-5cb5-8b61-797a481e67e3] TextParse 0.9.1
[a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f] TimerOutputs 0.5.0
[37b6cedf-1f77-55f8-9503-c64b63398394] Traceur 0.3.0
[28d57a85-8fef-5791-bfe6-a80928e7c999] Transducers 0.3.1
[39424ebd-4cf3-5550-a685-96706a953f40] TreeView 0.3.1
[b8865327-cd53-5732-bb35-84acbb429228] UnicodePlots 1.1.0
[1986cc42-f94f-5a68-af5c-568840ba703d] Unitful 0.16.0
[2a06ce6d-1589-592b-9c33-f37faeaed826] UnitfulPlots 0.0.0
[44d3d7a6-8a23-5bf8-98c5-b353f8df5ec9] Weave 0.9.1
[0f1e0344-ec1d-5b48-a673-e5cf874b6c29] WebIO 0.8.9
[9abbd945-dff8-562f-b5e8-e1ebf5ef1b79] Profile
[2f01184e-e22b-5df5-ae63-d93ebab69eaf] SparseArrays