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*}

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]

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`

.

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 `Symbol`

s 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

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.

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.

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.

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!

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
```