From 4d4ef3c26391103c5ca3f5cae19a657e507c8ea9 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Fri, 12 Nov 2021 18:23:10 +0000
Subject: [PATCH 01/25] Added generic + michaelis menten

---
 pints/toy/stochastic/__init__.py              |  13 ++
 pints/toy/stochastic/_markov_jump_model.py    | 186 ++++++++++++++++++
 .../toy/stochastic/_michaelis_menten_model.py |  42 ++++
 3 files changed, 241 insertions(+)
 create mode 100644 pints/toy/stochastic/__init__.py
 create mode 100644 pints/toy/stochastic/_markov_jump_model.py
 create mode 100644 pints/toy/stochastic/_michaelis_menten_model.py

diff --git a/pints/toy/stochastic/__init__.py b/pints/toy/stochastic/__init__.py
new file mode 100644
index 000000000..602bda884
--- /dev/null
+++ b/pints/toy/stochastic/__init__.py
@@ -0,0 +1,13 @@
+#
+# Root of the stochastic toy module.
+# Provides a number of stochastic toy models for tests of Pints' functions.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from __future__ import absolute_import, division
+from __future__ import print_function, unicode_literals
+
+from ._markov_jump_model import MarkovJumpModel  # noqa
+from ._michaelis_menten_model import MichaelisMentenModel # noqa
diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py
new file mode 100644
index 000000000..58ab3e2b3
--- /dev/null
+++ b/pints/toy/stochastic/_markov_jump_model.py
@@ -0,0 +1,186 @@
+#
+# Stochastic degradation toy model.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from __future__ import absolute_import, division
+from __future__ import print_function, unicode_literals
+import numpy as np
+from scipy.interpolate import interp1d
+import pints
+import random
+
+from .. import ToyModel
+
+
+class MarkovJumpModel(pints.ForwardModel, ToyModel):
+    r"""
+    A general purpose Markov Jump model used for any systems of reactions
+    that proceed through jumps. We simulate a population of N different species
+    reacting through M different mechanisms.
+
+    A model has three parameters:
+        - x_0 - an N-vector specifying the initial population of each
+            of the N species
+        - V - an NxM matrix consisting of stochiometric vectors v_i specifying
+            the changes to the state, x,  from reaction i taking place
+        - a - a function from the current state, x, and reaction rates, k,
+            to a vector of the rates of each reaction taking place
+
+    Simulations are performed using Gillespie's algorithm [1]_, [2]_:
+
+    1. Sample values :math:`r_0`, :math:`r_1`, from a uniform distribution
+
+    .. math::
+        r_0, r_1 \sim U(0,1)
+
+    2. Calculate the time :math:`\tau` until the next single reaction as
+
+    .. math::
+        \tau = \frac{-\ln(r)}{a_0}
+
+    3. Decide which reaction, i, takes place using r_1 * a_0 and iterating
+
+    through propensities
+
+    4. Update the state :math:`x` at time :math:`t + \tau` as:
+
+    .. math::
+        x(t + \tau) = x(t) + V[i]
+
+    4. Return to step (1) until no reaction can take place
+
+    The model has one parameter, the rate constant :math:`k`.
+
+    Extends :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`.
+
+    Parameters
+    ----------
+    initial_molecule_count
+        The initial molecule count :math:`A(0)`.
+
+    References
+    ----------
+    .. [1] A Practical Guide to Stochastic Simulations of Reaction Diffusion
+           Processes. Erban, Chapman, Maini (2007).
+           arXiv:0704.1908v2 [q-bio.SC]
+           https://arxiv.org/abs/0704.1908
+    .. [2] A general method for numerically simulating the stochastic time
+           evolution of coupled chemical reactions. Gillespie (1976).
+           Journal of Computational Physics
+           https://doi.org/10.1016/0021-9991(76)90041-3
+    """
+    def __init__(self, x0, V, a):
+        super(MarkovJumpModel, self).__init__()
+        self._x0 = np.asarray(x0)
+        self._V = V
+        self._a = a
+        if any(self._x0 < 0):
+            raise ValueError('Initial molecule count cannot be negative.')
+
+    def n_parameters(self):
+        """ See :meth:`pints.ForwardModel.n_parameters()`. """
+        return len(self._V)
+
+    def simulate_raw(self, rates, max_time):
+        """
+        Returns raw times, mol counts when reactions occur
+        """
+        # parameters = np.asarray(parameters)
+        # if len(parameters) != self.n_parameters():
+        #     raise ValueError('This model should have only 1 parameter.')
+        # k = parameters[0]
+
+        current_rates = self._a(self._x0, rates)
+        a_0 = sum(current_rates)
+
+        # Initial time and count
+        t = 0
+        x = np.array(self._x0)
+
+        # Run gillespie SSA, calculating time until next
+        # reaction, deciding which reaction, and applying it
+        mol_count = [np.array(x)]
+        time = [t]
+        while a_0 > 0 and t <= max_time:
+            r_1, r_2 = random.random(), random.random()
+            t += -np.log(r_1) / (a_0)
+            s = 0
+            r = 0
+            while s <= r_2 * a_0:
+                s += current_rates[r]
+                r += 1
+            r -= 1
+            x = np.add(x, self._V[r])
+
+            current_rates = self._a(x, rates)
+            a_0 = sum(current_rates)
+
+            time.append(t)
+            mol_count.append(np.array(x))
+        return time, mol_count
+
+    def simulate_approx(self, rates, max_time, tau):
+        assert tau > 0, "cannot tau-leap with negative tau"
+        current_rates = np.array(self._a(self._x0, rates))
+        # Initial time and count
+        t = 0
+        x = self._x0.copy()
+        N = len(rates)
+        # Run gillespie SSA, calculating time until next
+        # reaction, deciding which reaction, and applying it
+        mol_count = [x.copy()]
+        time = [t]
+        while any(current_rates > 0) and t <= max_time:
+            # Estimate number of each reaction in [t, t+tau)
+            k = [np.random.poisson(current_rates[i] * tau) for i in range(N)]
+
+            # Apply the reactions
+            for r in range(N):
+                x += np.array(self._V[r]) * k[r]
+
+            # Update rates
+            current_rates = np.array(self._a(x, rates))
+
+            # Advance Time
+            t += tau
+            time.append(t)
+            mol_count.append(x.copy())
+        return time, mol_count
+
+    def interpolate_mol_counts(self, time, mol_count, output_times):
+        """
+        Takes raw times and inputs and mol counts and outputs interpolated
+        values at output_times
+        """
+        # Interpolate as step function, decreasing mol_count by 1 at each
+        # reaction time point
+        interp_func = interp1d(time, mol_count, kind='previous', axis=0,
+                               fill_value="extrapolate", bounds_error=False)
+
+        # Compute molecule count values at given time points using f1
+        # at any time beyond the last reaction, molecule count = 0
+        values = interp_func(output_times)
+        return values
+
+    def simulate(self, parameters, times, approx_tau=None):
+        """ See :meth:`pints.ForwardModel.simulate()`. """
+        times = np.asarray(times)
+        if np.any(times < 0):
+            raise ValueError('Negative times are not allowed.')
+        if approx_tau is None:
+            # run Gillespie
+            time, mol_count = self.simulate_raw(parameters, max(times))
+        else:
+            if (not approx_tau) or approx_tau <= 0:
+                ValueError("You must provide a positive value for approx_tau\
+                 to use tau-leaping approximation")
+            # Run Euler tau-leaping
+            time, mol_count = self.simulate_approx(parameters, max(times),
+                                                   approx_tau)
+        # interpolate
+        values = self.interpolate_mol_counts(np.asarray(time),
+                                             np.asarray(mol_count), times)
+        return values
diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py
new file mode 100644
index 000000000..396a51981
--- /dev/null
+++ b/pints/toy/stochastic/_michaelis_menten_model.py
@@ -0,0 +1,42 @@
+#
+# Stochastic degradation toy model.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from __future__ import absolute_import, division
+from __future__ import print_function, unicode_literals
+
+from . import MarkovJumpModel
+
+
+class MichaelisMentenModel(MarkovJumpModel):
+    r"""
+    Simulates the Michaelis Menten Dynamics using Gillespie.
+
+    This system of reaction involves 4 chemical species with
+    inital counts x_0, and reactions:
+
+        - X1+X2 -> X3 with rate k1
+        - X3 -> X1+X2 with rate k2
+        - X3 -> X2+X4 with rate k3
+    """
+    def __init__(self, x_0):
+        mat = [[-1, -1, 1, 0],
+               [1, 1, -1, 0],
+               [0, 1, -1, 1]]
+        super(MichaelisMentenModel, self).__init__(x_0,
+                                                   mat, self._propensities)
+
+    @staticmethod
+    def _propensities(xs, ks):
+        return [
+            xs[0] * xs[1] * ks[0],
+            xs[2] * ks[1],
+            xs[2] * ks[2]
+        ]
+
+    def n_parameters(self):
+        """ See :meth:`pints.ForwardModel.n_parameters()`. """
+        return 3

From 556e56019878e611dd8b8b487eb5ed1029754ac1 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Fri, 12 Nov 2021 19:19:03 +0000
Subject: [PATCH 02/25] jupyter notebook added (not fully working yet)

---
 model-michaelis-menten.ipynb | 556 +++++++++++++++++++++++++++++++++++
 1 file changed, 556 insertions(+)
 create mode 100644 model-michaelis-menten.ipynb

diff --git a/model-michaelis-menten.ipynb b/model-michaelis-menten.ipynb
new file mode 100644
index 000000000..def051632
--- /dev/null
+++ b/model-michaelis-menten.ipynb
@@ -0,0 +1,556 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Michaelis Menten"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Reactions are:\n",
+    "\n",
+    "\n",
+    "X1 + X2 -> X3\n",
+    "\n",
+    "X3 -> X1 + X2\n",
+    "\n",
+    "X3 -> X2 + X4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pints\n",
+    "import pints.toy.stochastic\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import math"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify initial concentration, time points at which to record concentration values, and rate constant value (k)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_0 = [1e4, 2e3, 2e4, 0]\n",
+    "model = pints.toy.stochastic.MichaelisMentenModel(x_0)\n",
+    "\n",
+    "times = np.linspace(0, 24, 100)\n",
+    "k = [1e-5, 0.2, 0.2]\n",
+    "\n",
+    "values = model.simulate(k, times)\n",
+    "print(\"Done\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.step(times, values[:,0], label = 'X1')\n",
+    "plt.step(times, values[:,1], label = 'X2')\n",
+    "plt.step(times, values[:,2], label = 'X3')\n",
+    "plt.step(times, values[:,3], label = 'X4')\n",
+    "plt.legend()\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also evaluate this model using tau-leaping for more efficient but approximate simulations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "values_exact = model.simulate(k, times)\n",
+    "values_approx = model.simulate(k, times, approx_tau=0.0125)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_output(vs, suffix=''):\n",
+    "    plt.step(times, vs[:,0], label = 'X1'+suffix)\n",
+    "    plt.step(times, vs[:,1], label = 'X2'+suffix)\n",
+    "    plt.step(times, vs[:,2], label = 'X3'+suffix)\n",
+    "    plt.step(times, vs[:,3], label = 'X4'+suffix)\n",
+    "    plt.legend()\n",
+    "    plt.xlabel('time')\n",
+    "    plt.ylabel('Molecule Count'),\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_output(values_exact)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mc_estimate_approx(n,tau):\n",
+    "    return sum([model.simulate(k, times, approx_tau=tau) for i in range(n)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mse(r1,r2):\n",
+    "    return np.square(r1 - r2).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[10000.,  2000., 20000.,     0.],\n",
+       "       [10860.,  3810., 18190.,   950.],\n",
+       "       [11568.,  5312., 16688.,  1744.],\n",
+       "       [12207.,  6752., 15248.,  2545.],\n",
+       "       [12724.,  8009., 13991.,  3285.],\n",
+       "       [13116.,  9079., 12921.,  3963.],\n",
+       "       [13439., 10020., 11980.,  4581.],\n",
+       "       [13663., 10819., 11181.,  5156.],\n",
+       "       [13796., 11488., 10512.,  5692.],\n",
+       "       [13904., 12045.,  9955.,  6141.],\n",
+       "       [13918., 12516.,  9484.,  6598.],\n",
+       "       [13935., 12958.,  9042.,  7023.],\n",
+       "       [13881., 13324.,  8676.,  7443.],\n",
+       "       [13842., 13700.,  8300.,  7858.],\n",
+       "       [13776., 14023.,  7977.,  8247.],\n",
+       "       [13710., 14324.,  7676.,  8614.],\n",
+       "       [13621., 14564.,  7436.,  8943.],\n",
+       "       [13518., 14796.,  7204.,  9278.],\n",
+       "       [13427., 15045.,  6955.,  9618.],\n",
+       "       [13230., 15197.,  6803.,  9967.],\n",
+       "       [13071., 15356.,  6644., 10285.],\n",
+       "       [12933., 15519.,  6481., 10586.],\n",
+       "       [12740., 15636.,  6364., 10896.],\n",
+       "       [12562., 15772.,  6228., 11210.],\n",
+       "       [12388., 15911.,  6089., 11523.],\n",
+       "       [12199., 16008.,  5992., 11809.],\n",
+       "       [12068., 16187.,  5813., 12119.],\n",
+       "       [11898., 16320.,  5680., 12422.],\n",
+       "       [11711., 16417.,  5583., 12706.],\n",
+       "       [11522., 16498.,  5502., 12976.],\n",
+       "       [11365., 16574.,  5426., 13209.],\n",
+       "       [11208., 16690.,  5310., 13482.],\n",
+       "       [11013., 16752.,  5248., 13739.],\n",
+       "       [10839., 16826.,  5174., 13987.],\n",
+       "       [10649., 16869.,  5131., 14220.],\n",
+       "       [10459., 16950.,  5050., 14491.],\n",
+       "       [10288., 17024.,  4976., 14736.],\n",
+       "       [10110., 17111.,  4889., 15001.],\n",
+       "       [ 9915., 17160.,  4840., 15245.],\n",
+       "       [ 9711., 17212.,  4788., 15501.],\n",
+       "       [ 9579., 17322.,  4678., 15743.],\n",
+       "       [ 9378., 17332.,  4668., 15954.],\n",
+       "       [ 9234., 17430.,  4570., 16196.],\n",
+       "       [ 9082., 17484.,  4516., 16402.],\n",
+       "       [ 8918., 17530.,  4470., 16612.],\n",
+       "       [ 8721., 17564.,  4436., 16843.],\n",
+       "       [ 8534., 17589.,  4411., 17055.],\n",
+       "       [ 8363., 17613.,  4387., 17250.],\n",
+       "       [ 8215., 17684.,  4316., 17469.],\n",
+       "       [ 8104., 17766.,  4234., 17662.],\n",
+       "       [ 7972., 17834.,  4166., 17862.],\n",
+       "       [ 7815., 17854.,  4146., 18039.],\n",
+       "       [ 7703., 17952.,  4048., 18249.],\n",
+       "       [ 7583., 18006.,  3994., 18423.],\n",
+       "       [ 7407., 18012.,  3988., 18605.],\n",
+       "       [ 7299., 18093.,  3907., 18794.],\n",
+       "       [ 7193., 18201.,  3799., 19008.],\n",
+       "       [ 7049., 18227.,  3773., 19178.],\n",
+       "       [ 6937., 18303.,  3697., 19366.],\n",
+       "       [ 6816., 18357.,  3643., 19541.],\n",
+       "       [ 6692., 18414.,  3586., 19722.],\n",
+       "       [ 6585., 18503.,  3497., 19918.],\n",
+       "       [ 6437., 18517.,  3483., 20080.],\n",
+       "       [ 6346., 18581.,  3419., 20235.],\n",
+       "       [ 6264., 18670.,  3330., 20406.],\n",
+       "       [ 6134., 18680.,  3320., 20546.],\n",
+       "       [ 6009., 18729.,  3271., 20720.],\n",
+       "       [ 5920., 18793.,  3207., 20873.],\n",
+       "       [ 5789., 18818.,  3182., 21029.],\n",
+       "       [ 5651., 18826.,  3174., 21175.],\n",
+       "       [ 5521., 18861.,  3139., 21340.],\n",
+       "       [ 5447., 18942.,  3058., 21495.],\n",
+       "       [ 5337., 18983.,  3017., 21646.],\n",
+       "       [ 5218., 19016.,  2984., 21798.],\n",
+       "       [ 5117., 19039.,  2961., 21922.],\n",
+       "       [ 5036., 19086.,  2914., 22050.],\n",
+       "       [ 4959., 19155.,  2845., 22196.],\n",
+       "       [ 4877., 19206.,  2794., 22329.],\n",
+       "       [ 4801., 19276.,  2724., 22475.],\n",
+       "       [ 4674., 19294.,  2706., 22620.],\n",
+       "       [ 4580., 19300.,  2700., 22720.],\n",
+       "       [ 4461., 19323.,  2677., 22862.],\n",
+       "       [ 4379., 19380.,  2620., 23001.],\n",
+       "       [ 4320., 19438.,  2562., 23118.],\n",
+       "       [ 4288., 19527.,  2473., 23239.],\n",
+       "       [ 4204., 19558.,  2442., 23354.],\n",
+       "       [ 4122., 19595.,  2405., 23473.],\n",
+       "       [ 4048., 19639.,  2361., 23591.],\n",
+       "       [ 3980., 19693.,  2307., 23713.],\n",
+       "       [ 3902., 19705.,  2295., 23803.],\n",
+       "       [ 3854., 19775.,  2225., 23921.],\n",
+       "       [ 3775., 19814.,  2186., 24039.],\n",
+       "       [ 3708., 19836.,  2164., 24128.],\n",
+       "       [ 3633., 19863.,  2137., 24230.],\n",
+       "       [ 3579., 19905.,  2095., 24326.],\n",
+       "       [ 3501., 19924.,  2076., 24423.],\n",
+       "       [ 3434., 19957.,  2043., 24523.],\n",
+       "       [ 3375., 19998.,  2002., 24623.],\n",
+       "       [ 3322., 20034.,  1966., 24712.],\n",
+       "       [ 3245., 20046.,  1954., 24801.]])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.simulate(k, times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[10000.,  2000., 20000.,     0.],\n",
+       "       [10843.,  3798., 18202.,   955.],\n",
+       "       [11578.,  5414., 16586.,  1836.],\n",
+       "       [12160.,  6773., 15227.,  2613.],\n",
+       "       [12623.,  7957., 14043.,  3334.],\n",
+       "       [13040.,  8983., 13017.,  3943.],\n",
+       "       [13335.,  9904., 12096.,  4569.],\n",
+       "       [13599., 10693., 11307.,  5094.],\n",
+       "       [13765., 11394., 10606.,  5629.],\n",
+       "       [13861., 11953., 10047.,  6092.],\n",
+       "       [13939., 12501.,  9499.,  6562.],\n",
+       "       [13952., 12961.,  9039.,  7009.],\n",
+       "       [13988., 13429.,  8571.,  7441.],\n",
+       "       [13911., 13747.,  8253.,  7836.],\n",
+       "       [13840., 14051.,  7949.,  8211.],\n",
+       "       [13747., 14344.,  7656.,  8597.],\n",
+       "       [13659., 14656.,  7344.,  8997.],\n",
+       "       [13482., 14823.,  7177.,  9341.],\n",
+       "       [13313., 15005.,  6995.,  9692.],\n",
+       "       [13147., 15168.,  6832., 10021.],\n",
+       "       [12972., 15323.,  6677., 10351.],\n",
+       "       [12838., 15516.,  6484., 10678.],\n",
+       "       [12624., 15602.,  6398., 10978.],\n",
+       "       [12500., 15815.,  6185., 11315.],\n",
+       "       [12324., 15933.,  6067., 11609.],\n",
+       "       [12207., 16075.,  5925., 11868.],\n",
+       "       [12018., 16164.,  5836., 12146.],\n",
+       "       [11794., 16224.,  5776., 12430.],\n",
+       "       [11579., 16320.,  5680., 12741.],\n",
+       "       [11383., 16410.,  5590., 13027.],\n",
+       "       [11219., 16534.,  5466., 13315.],\n",
+       "       [11040., 16605.,  5395., 13565.],\n",
+       "       [10869., 16684.,  5316., 13815.],\n",
+       "       [10705., 16774.,  5226., 14069.],\n",
+       "       [10535., 16862.,  5138., 14327.],\n",
+       "       [10342., 16909.,  5091., 14567.],\n",
+       "       [10150., 16971.,  5029., 14821.],\n",
+       "       [ 9972., 17037.,  4963., 15065.],\n",
+       "       [ 9758., 17033.,  4967., 15275.],\n",
+       "       [ 9596., 17121.,  4879., 15525.],\n",
+       "       [ 9425., 17195.,  4805., 15770.],\n",
+       "       [ 9294., 17292.,  4708., 15998.],\n",
+       "       [ 9138., 17338.,  4662., 16200.],\n",
+       "       [ 9019., 17420.,  4580., 16401.],\n",
+       "       [ 8845., 17488.,  4512., 16643.],\n",
+       "       [ 8705., 17562.,  4438., 16857.],\n",
+       "       [ 8559., 17624.,  4376., 17065.],\n",
+       "       [ 8412., 17681.,  4319., 17269.],\n",
+       "       [ 8277., 17774.,  4226., 17497.],\n",
+       "       [ 8126., 17827.,  4173., 17701.],\n",
+       "       [ 7978., 17861.,  4139., 17883.],\n",
+       "       [ 7855., 17966.,  4034., 18111.],\n",
+       "       [ 7709., 18002.,  3998., 18293.],\n",
+       "       [ 7584., 18081.,  3919., 18497.],\n",
+       "       [ 7466., 18168.,  3832., 18702.],\n",
+       "       [ 7295., 18200.,  3800., 18905.],\n",
+       "       [ 7151., 18255.,  3745., 19104.],\n",
+       "       [ 7019., 18304.,  3696., 19285.],\n",
+       "       [ 6887., 18340.,  3660., 19453.],\n",
+       "       [ 6776., 18432.,  3568., 19656.],\n",
+       "       [ 6672., 18510.,  3490., 19838.],\n",
+       "       [ 6527., 18529.,  3471., 20002.],\n",
+       "       [ 6425., 18590.,  3410., 20165.],\n",
+       "       [ 6312., 18635.,  3365., 20323.],\n",
+       "       [ 6170., 18660.,  3340., 20490.],\n",
+       "       [ 6040., 18684.,  3316., 20644.],\n",
+       "       [ 5909., 18721.,  3279., 20812.],\n",
+       "       [ 5828., 18780.,  3220., 20952.],\n",
+       "       [ 5741., 18851.,  3149., 21110.],\n",
+       "       [ 5629., 18889.,  3111., 21260.],\n",
+       "       [ 5539., 18959.,  3041., 21420.],\n",
+       "       [ 5391., 18950.,  3050., 21559.],\n",
+       "       [ 5311., 19023.,  2977., 21712.],\n",
+       "       [ 5186., 19052.,  2948., 21866.],\n",
+       "       [ 5062., 19063.,  2937., 22001.],\n",
+       "       [ 4958., 19093.,  2907., 22135.],\n",
+       "       [ 4866., 19131.,  2869., 22265.],\n",
+       "       [ 4761., 19178.,  2822., 22417.],\n",
+       "       [ 4689., 19228.,  2772., 22539.],\n",
+       "       [ 4601., 19268.,  2732., 22667.],\n",
+       "       [ 4568., 19352.,  2648., 22784.],\n",
+       "       [ 4475., 19395.,  2605., 22920.],\n",
+       "       [ 4393., 19430.,  2570., 23037.],\n",
+       "       [ 4302., 19458.,  2542., 23156.],\n",
+       "       [ 4227., 19529.,  2471., 23302.],\n",
+       "       [ 4146., 19559.,  2441., 23413.],\n",
+       "       [ 4033., 19563.,  2437., 23530.],\n",
+       "       [ 3946., 19590.,  2410., 23644.],\n",
+       "       [ 3860., 19618.,  2382., 23758.],\n",
+       "       [ 3803., 19675.,  2325., 23872.],\n",
+       "       [ 3750., 19732.,  2268., 23982.],\n",
+       "       [ 3716., 19810.,  2190., 24094.],\n",
+       "       [ 3660., 19867.,  2133., 24207.],\n",
+       "       [ 3601., 19896.,  2104., 24295.],\n",
+       "       [ 3516., 19915.,  2085., 24399.],\n",
+       "       [ 3450., 19939.,  2061., 24489.],\n",
+       "       [ 3380., 19967.,  2033., 24587.],\n",
+       "       [ 3333., 20019.,  1981., 24686.],\n",
+       "       [ 3279., 20065.,  1935., 24786.],\n",
+       "       [ 3210., 20098.,  1902., 24888.]])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.simulate(k, times, approx_tau=0.0125)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "empirical_mean = sum([model.simulate(k, times) for i in range(30)])/30"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_output(empirical_mean)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exact_mse = 0\n",
+    "for i in range(25):\n",
+    "    exact = model.simulate(k, times)\n",
+    "    exact_mse += mse(exact, empirical_mean)/25"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running for tau = 0.0125\n",
+      "Running for tau = 0.025\n",
+      "Running for tau = 0.05\n",
+      "Running for tau = 0.1\n",
+      "Running for tau = 0.25\n",
+      "Running for tau = 0.5\n",
+      "Running for tau = 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "taus = [0.0125, 0.025, 0.05, 0.1, 0.25, 0.5, 1]\n",
+    "approx_mses = []\n",
+    "\n",
+    "for tau in taus:\n",
+    "    amse = 0\n",
+    "    print(\"Running for tau = \" + str(tau))\n",
+    "    for i in range(1000):\n",
+    "        sim = model.simulate(k, times, approx_tau=tau)\n",
+    "        amse = mse(empirical_mean, sim)/1000\n",
+    "    approx_mses.append(amse)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c7017d8>]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot([0]+taus[:4], [exact_mse]+approx_mses[:4], 'bo')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 32-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 1e99263b630160118349638c38dde15612300fab Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Fri, 12 Nov 2021 23:55:03 +0000
Subject: [PATCH 03/25] change to ipynb

---
 model-michaelis-menten.ipynb | 219 ++++++++++++++++++++++++++++++-----
 1 file changed, 189 insertions(+), 30 deletions(-)

diff --git a/model-michaelis-menten.ipynb b/model-michaelis-menten.ipynb
index def051632..51f6e000d 100644
--- a/model-michaelis-menten.ipynb
+++ b/model-michaelis-menten.ipynb
@@ -43,15 +43,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Done\n"
-     ]
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -62,17 +67,32 @@
     "k = [1e-5, 0.2, 0.2]\n",
     "\n",
     "values = model.simulate(k, times)\n",
-    "print(\"Done\")"
+    "\n",
+    "plt.step(times, values[:,0], label = 'X1')\n",
+    "plt.step(times, values[:,1], label = 'X2')\n",
+    "plt.step(times, values[:,2], label = 'X3')\n",
+    "plt.step(times, values[:,3], label = 'X4')\n",
+    "plt.legend()\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Given the stochastic nature of this model we can use multiple simulations to make sure that the runs are similar."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -84,10 +104,13 @@
     }
    ],
    "source": [
-    "plt.step(times, values[:,0], label = 'X1')\n",
-    "plt.step(times, values[:,1], label = 'X2')\n",
-    "plt.step(times, values[:,2], label = 'X3')\n",
-    "plt.step(times, values[:,3], label = 'X4')\n",
+    "for i in range(3):\n",
+    "    values = model.simulate(k, times)\n",
+    "    plt.step(times, values[:,0], label = 'X1_' + str(i))\n",
+    "    plt.step(times, values[:,1], label = 'X2_' + str(i))\n",
+    "    plt.step(times, values[:,2], label = 'X3_' + str(i))\n",
+    "    plt.step(times, values[:,3], label = 'X4_' + str(i))\n",
+    "\n",
     "plt.legend()\n",
     "plt.xlabel('time')\n",
     "plt.ylabel('concentration (A(t))'),\n",
@@ -97,40 +120,176 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": []
+   "source": [
+    "Another way of obtaining these simulations is by using tau-leaping for more efficient but approximate solutions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "values_approx = model.simulate(k, times, approx_tau=0.0125)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.step(times, values_approx[:,0], label = 'X1_tau')\n",
+    "plt.step(times, values_approx[:,1], label = 'X2_tau')\n",
+    "plt.step(times, values_approx[:,2], label = 'X3_tau')\n",
+    "plt.step(times, values_approx[:,3], label = 'X4_tau')\n",
+    "plt.step(times, values[:,0], label = 'X1_normal')\n",
+    "plt.step(times, values[:,1], label = 'X2_normal')\n",
+    "plt.step(times, values[:,2], label = 'X3_normal')\n",
+    "plt.step(times, values[:,3], label = 'X4_normal')\n",
+    "plt.legend()\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can also evaluate this model using tau-leaping for more efficient but approximate simulations"
+    "We can also run multiple simulations using tau leaping."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 33,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "values_exact = model.simulate(k, times)\n",
-    "values_approx = model.simulate(k, times, approx_tau=0.0125)"
+    "for i in range(3):\n",
+    "    values = model.simulate(k, times, approx_tau=0.0125)\n",
+    "    plt.step(times, values[:,0], label = 'X1_' + str(i))\n",
+    "    plt.step(times, values[:,1], label = 'X2_' + str(i))\n",
+    "    plt.step(times, values[:,2], label = 'X3_' + str(i))\n",
+    "    plt.step(times, values[:,3], label = 'X4_' + str(i))\n",
+    "\n",
+    "plt.legend()\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For tau-leaping, we may try multiple values to find the best performing approximate tau value."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running for tau = 0.0125\n",
+      "Running for tau = 0.025\n",
+      "Running for tau = 0.05\n",
+      "Running for tau = 0.1\n",
+      "Running for tau = 0.25\n",
+      "Running for tau = 0.5\n",
+      "Running for tau = 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "taus = [0.0125, 0.025, 0.05, 0.1, 0.25, 0.5, 1]\n",
+    "approx_mses = []\n",
+    "\n",
+    "# compute empirical mean\n",
+    "empirical_mean = sum([model.simulate(k, times) for i in range(30)])/30\n",
+    "\n",
+    "# compute exact mean squared error\n",
+    "exact_mse = 0\n",
+    "for i in range(25):\n",
+    "    exact = model.simulate(k, times)\n",
+    "    exact_mse += np.square(exact - empirical_mean).mean() / 25\n",
+    "\n",
+    "for tau in taus:\n",
+    "    amse = 0\n",
+    "    print(\"Running for tau = \" + str(tau))\n",
+    "    for i in range(1000):\n",
+    "        sim = model.simulate(k, times, approx_tau=tau)\n",
+    "        amse = np.square(empirical_mean - sim).mean() / 1000 \n",
+    "    approx_mses.append(amse)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1c7bfef8>]"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot([0]+taus[:4], [exact_mse]+approx_mses[:4], 'bo')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "def plot_output(vs, suffix=''):\n",
-    "    plt.step(times, vs[:,0], label = 'X1'+suffix)\n",
-    "    plt.step(times, vs[:,1], label = 'X2'+suffix)\n",
-    "    plt.step(times, vs[:,2], label = 'X3'+suffix)\n",
-    "    plt.step(times, vs[:,3], label = 'X4'+suffix)\n",
-    "    plt.legend()\n",
-    "    plt.xlabel('time')\n",
-    "    plt.ylabel('Molecule Count'),\n",
-    "    plt.show()"
+    "Here ends the jupyter notebook, remove the rest"
    ]
   },
   {

From 74c8b2e7bd56d86413f74c300ad296b9f9772a71 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sat, 20 Nov 2021 22:42:09 +0000
Subject: [PATCH 04/25] removed tau-leaping for now, clarified notebook, minor
 refactoring

---
 examples/toy/model-michaelis-menten.ipynb     | 200 +++++
 model-michaelis-menten.ipynb                  | 715 ------------------
 pints/toy/stochastic/__init__.py              |   3 -
 pints/toy/stochastic/_markov_jump_model.py    |  99 +--
 .../toy/stochastic/_michaelis_menten_model.py |  26 +-
 5 files changed, 244 insertions(+), 799 deletions(-)
 create mode 100644 examples/toy/model-michaelis-menten.ipynb
 delete mode 100644 model-michaelis-menten.ipynb

diff --git a/examples/toy/model-michaelis-menten.ipynb b/examples/toy/model-michaelis-menten.ipynb
new file mode 100644
index 000000000..677f67de7
--- /dev/null
+++ b/examples/toy/model-michaelis-menten.ipynb
@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Michaelis Menten"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This example shows how the the Michaelis Menten model can be used.\n",
+    "The Michaelis Menten model is a stochastic model, more details can be found [here](https://en.wikipedia.org/wiki/Michaelis-Menten_kinetics).\n",
+    "\n",
+    "Its reactions are:\n",
+    "$$X_1 + X_2 \\xrightarrow{} X_3$$\n",
+    "$$X_3 \\xrightarrow{} X_1 + X_2$$\n",
+    "$$X_3 \\xrightarrow{} X_2 + X_4$$\n",
+    "\n",
+    "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pints\n",
+    "import pints.toy.stochastic\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify initial concentration, time points at which to record concentration values, and rate constant value (k)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_0 = [1e4, 2e3, 2e4, 0]\n",
+    "model = pints.toy.stochastic.MichaelisMentenModel(x_0)\n",
+    "\n",
+    "times = np.linspace(0, 24, 100)\n",
+    "k = [1e-5, 0.2, 0.2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The main option is to use the model's ```simulate``` function. This function, given a set of parameters and times, computes the appropriate times and values using Gillispie's algorithm and then uses interpolation to find the values at the exact times requested."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "values = model.simulate(k, times)\n",
+    "\n",
+    "plt.step(times, values[:,0], label = 'X1')\n",
+    "plt.step(times, values[:,1], label = 'X2')\n",
+    "plt.step(times, values[:,2], label = 'X3')\n",
+    "plt.step(times, values[:,3], label = 'X4')\n",
+    "plt.legend()\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another option for simulating the model is by using the ```simulate_raw``` function. This gives the pure Gillispie's algorithm simulations times and values, without interpolating them. Although more precise, these simulations are similar to the ones given by ```simulate```."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "times, values = model.simulate_raw(k, 24)\n",
+    "values = np.array(values)\n",
+    "\n",
+    "plt.step(times, values[:,0], label = 'X1')\n",
+    "plt.step(times, values[:,1], label = 'X2')\n",
+    "plt.step(times, values[:,2], label = 'X3')\n",
+    "plt.step(times, values[:,3], label = 'X4')\n",
+    "plt.legend()\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Given the stochastic nature of this model we can use multiple simulations to make sure that the runs are covering the same model with the same parameters. Our simulations are close, suggesting we are obtaining accurate simulations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "times = np.linspace(0, 24, 100)\n",
+    "\n",
+    "for i in range(3):\n",
+    "    values = model.simulate(k, times)\n",
+    "    plt.step(times, values[:,0])\n",
+    "    plt.step(times, values[:,1])\n",
+    "    plt.step(times, values[:,2])\n",
+    "    plt.step(times, values[:,3])\n",
+    "\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 32-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/model-michaelis-menten.ipynb b/model-michaelis-menten.ipynb
deleted file mode 100644
index 51f6e000d..000000000
--- a/model-michaelis-menten.ipynb
+++ /dev/null
@@ -1,715 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Michaelis Menten"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Reactions are:\n",
-    "\n",
-    "\n",
-    "X1 + X2 -> X3\n",
-    "\n",
-    "X3 -> X1 + X2\n",
-    "\n",
-    "X3 -> X2 + X4"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pints\n",
-    "import pints.toy.stochastic\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "import math"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Specify initial concentration, time points at which to record concentration values, and rate constant value (k)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "x_0 = [1e4, 2e3, 2e4, 0]\n",
-    "model = pints.toy.stochastic.MichaelisMentenModel(x_0)\n",
-    "\n",
-    "times = np.linspace(0, 24, 100)\n",
-    "k = [1e-5, 0.2, 0.2]\n",
-    "\n",
-    "values = model.simulate(k, times)\n",
-    "\n",
-    "plt.step(times, values[:,0], label = 'X1')\n",
-    "plt.step(times, values[:,1], label = 'X2')\n",
-    "plt.step(times, values[:,2], label = 'X3')\n",
-    "plt.step(times, values[:,3], label = 'X4')\n",
-    "plt.legend()\n",
-    "plt.xlabel('time')\n",
-    "plt.ylabel('concentration (A(t))'),\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Given the stochastic nature of this model we can use multiple simulations to make sure that the runs are similar."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for i in range(3):\n",
-    "    values = model.simulate(k, times)\n",
-    "    plt.step(times, values[:,0], label = 'X1_' + str(i))\n",
-    "    plt.step(times, values[:,1], label = 'X2_' + str(i))\n",
-    "    plt.step(times, values[:,2], label = 'X3_' + str(i))\n",
-    "    plt.step(times, values[:,3], label = 'X4_' + str(i))\n",
-    "\n",
-    "plt.legend()\n",
-    "plt.xlabel('time')\n",
-    "plt.ylabel('concentration (A(t))'),\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Another way of obtaining these simulations is by using tau-leaping for more efficient but approximate solutions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "values_approx = model.simulate(k, times, approx_tau=0.0125)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.step(times, values_approx[:,0], label = 'X1_tau')\n",
-    "plt.step(times, values_approx[:,1], label = 'X2_tau')\n",
-    "plt.step(times, values_approx[:,2], label = 'X3_tau')\n",
-    "plt.step(times, values_approx[:,3], label = 'X4_tau')\n",
-    "plt.step(times, values[:,0], label = 'X1_normal')\n",
-    "plt.step(times, values[:,1], label = 'X2_normal')\n",
-    "plt.step(times, values[:,2], label = 'X3_normal')\n",
-    "plt.step(times, values[:,3], label = 'X4_normal')\n",
-    "plt.legend()\n",
-    "plt.xlabel('time')\n",
-    "plt.ylabel('concentration (A(t))'),\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can also run multiple simulations using tau leaping."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for i in range(3):\n",
-    "    values = model.simulate(k, times, approx_tau=0.0125)\n",
-    "    plt.step(times, values[:,0], label = 'X1_' + str(i))\n",
-    "    plt.step(times, values[:,1], label = 'X2_' + str(i))\n",
-    "    plt.step(times, values[:,2], label = 'X3_' + str(i))\n",
-    "    plt.step(times, values[:,3], label = 'X4_' + str(i))\n",
-    "\n",
-    "plt.legend()\n",
-    "plt.xlabel('time')\n",
-    "plt.ylabel('concentration (A(t))'),\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For tau-leaping, we may try multiple values to find the best performing approximate tau value."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running for tau = 0.0125\n",
-      "Running for tau = 0.025\n",
-      "Running for tau = 0.05\n",
-      "Running for tau = 0.1\n",
-      "Running for tau = 0.25\n",
-      "Running for tau = 0.5\n",
-      "Running for tau = 1\n"
-     ]
-    }
-   ],
-   "source": [
-    "taus = [0.0125, 0.025, 0.05, 0.1, 0.25, 0.5, 1]\n",
-    "approx_mses = []\n",
-    "\n",
-    "# compute empirical mean\n",
-    "empirical_mean = sum([model.simulate(k, times) for i in range(30)])/30\n",
-    "\n",
-    "# compute exact mean squared error\n",
-    "exact_mse = 0\n",
-    "for i in range(25):\n",
-    "    exact = model.simulate(k, times)\n",
-    "    exact_mse += np.square(exact - empirical_mean).mean() / 25\n",
-    "\n",
-    "for tau in taus:\n",
-    "    amse = 0\n",
-    "    print(\"Running for tau = \" + str(tau))\n",
-    "    for i in range(1000):\n",
-    "        sim = model.simulate(k, times, approx_tau=tau)\n",
-    "        amse = np.square(empirical_mean - sim).mean() / 1000 \n",
-    "    approx_mses.append(amse)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c7bfef8>]"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot([0]+taus[:4], [exact_mse]+approx_mses[:4], 'bo')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here ends the jupyter notebook, remove the rest"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEGCAYAAACtqQjWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmE0lEQVR4nO3df7xUdb3v8ddHQskfXMUf/MZNXlIJynQraT7MR94S0UTP8fdJ1Lzh77STHsnqUKmFxzJL0yteBawULTPNMLMuKHYU3XBIFOVEKrERkYDaIiIqn/vHWgPLcc/sNTNrzcxa834+HjyYvWbNrO9qp2+/vz7L3B0REZEkbNPoBoiISH4oVEREJDEKFRERSYxCRUREEqNQERGRxHyg0Q2ot912283b2toa3QwRkUyZP3/+39x9957Oa7lQaWtro6Ojo9HNEBHJFDNbFuc8DX+JiEhiFCoiIpIYhYqIiCRGoSIiIolJLVTMbKiZzTazxWb2nJldHB7/ppmtMLOF4Z9xkc981cyWmtkSMzsycnxseGypmU2KHB9uZvPC43eb2bZp3Y+IiPQszZ7KO8BX3H0k8AngAjMbGb73A3ffL/wzCyB87xTgI8BY4CYz62VmvYAfA0cBI4FTI99zTfhd/xNYB5yd4v2IiEgPUgsVd1/p7gvC168DzwODy3xkPDDT3d9y95eApcBB4Z+l7v6iu28CZgLjzcyATwO/CD8/AzgulZsREZFY6rJPxczagI8D84BPAhea2QSgg6A3s44gcJ6MfKyTrSG0vOj4GGBX4O/u/k435xdffyIwEWDYsGEJ3JGISHNbd/c9dD344Jaft9t3HwZccUXq1009VMxsR+Be4BJ37zKzm4ErAQ///j7whTTb4O5TgakA7e3teoCMiORSNEg2PP00ANsfeGBd25BqqJhZb4JA+Zm7/xLA3VdF3r8VKETpCmBo5ONDwmOUOL4G2NnMPhD2VqLni4i0hFJBsv2BB9L3mGPY5eST6tqe1EIlnPO4DXje3a+LHB/o7ivDH48Hng1fPwDcaWbXAYOAEcBTgAEjzGw4QWicApzm7m5ms4ETCOZZzgDuT+t+REQaqXg4q6AZgiQqzZ7KJ4HTgUVmtjA8dgXB6q39CIa/XgbOAXD358zsHmAxwcqxC9z9XQAzuxB4GOgF3O7uz4Xfdzkw08yuAv6LIMRERHIhznBWMwRJlLXaM+rb29tdBSVFpFmVC5JGhoeZzXf39p7Oa7kqxSIizabZ5kVqoVAREWmAPAVJlEJFRCQlpSbXIV9BEqVQERFJUNy9InkKkiiFiohIjfI6lFUNhYqISBUUJN1TqIiIxKQg6ZlCRUSkDAVJZRQqIiJFFCTVU6iIiKAgSYpCRURaloIkeQoVEWkpCpJ0KVREJPcUJPWjUBGRXFKQNIZCRURyQ0HSeAoVEcms4oKNCpLGU6iISGZ1PfggG194gT777APkt0hjlihURCRTor2TQqDs+ZM7GtwqKVCoiEjTKzVX0meffeh7zDGNbJoUUaiISFPSpHs2KVREpGkoSLJPoSIiDaUgyReFiojUnYIkvxQqIlIXCpLWoFARkbqI7ilRkOSXQkVEUqM9Ja1HoSIiidKektamUBGRmmm+RAoUKiJSFQWJdEehIiJV0cS7dEehIiKxaeJderJNWl9sZkPNbLaZLTaz58zs4vB4PzN7xMz+HP69S3jczOxHZrbUzJ4xs/0j33VGeP6fzeyMyPEDzGxR+JkfmZmldT8irWrd3few7PQJLDt9Aq9OnrxlqEsT79KdNHsq7wBfcfcFZrYTMN/MHgHOBP7g7lPMbBIwCbgcOAoYEf4ZA9wMjDGzfsBkoB3w8HsecPd14TlfBOYBs4CxwEMp3pNI7unBV1KL1ELF3VcCK8PXr5vZ88BgYDxweHjaDGAOQaiMB+5wdweeNLOdzWxgeO4j7r4WIAymsWY2B+jr7k+Gx+8AjiOlULnmqWsAuPygy9P4epGmoQdfZUDHNFj0i8o+M2A0HDUlnfZE1GVOxczagI8T9Cj6h4ED8CrQP3w9GFge+VhneKzc8c5ujnd3/YnARIBhw4ZVdQ8vrH2hqs+JZIHmShqgmmAoWPZ48PeehybXnoSkHipmtiNwL3CJu3dFpz3c3c3M026Du08FpgK0t7enfj2RLNAmxZTEDYtagmHPQ2H0CdB+VuWfTVmqoWJmvQkC5Wfu/svw8CozG+juK8PhrdfC4yuAoZGPDwmPrWDrcFnh+Jzw+JBuzheRGLQkuApxAiNuWDRxMNQitVAJV2LdBjzv7tdF3noAOAOYEv59f+T4hWY2k2Ci/h9h8DwMfKewSgz4LPBVd19rZl1m9gmCYbUJwA1p3Y9IHmiYK6ZS4REnMHIaFnGl2VP5JHA6sMjMFobHriAIk3vM7GxgGVD4T6NZwDhgKbABOAsgDI8rgafD875dmLQHzgemAx8kmKDXyi+RIhrm4v0hUfiXfqXh0eKBEUeaq78eB0rtGzmim/MduKDEd90O3N7N8Q5gVA3NFMmlli2hEicklj0e/Fn0C4VHCrSjXiSHcjFfUs3qqDghEf1ehUfiFCoiOZHZ+ZJa5i+KxQmJ9rMUIilSqIhkWKbmSzR/0RIUKiIZ1jTDXLUstVV45IpCRSRj6j7MldTeDIVHS1CoiGRMtHeS2DBXueBQYEgFFCoiGZBY76SaSXEFhlRAoVKBJWuXcNZvg3+wxn1oHCd++MQGt0jyrOJJeM1rSBNQqMQ07kPjtrxesnYJgEJFEhdr02LHNFg0A6bNeO+HNUwlTcCCjeyto7293Ts6Omr6jkJvZdrYaUk0SWSLZadP2Posk9dfpe+eb7LLfn2LTioTHgoMSYmZzXf39p7OU09FpN6KhqnWLeyia/F6ADa+tok+e2zLnp9eA8vmhWdoqEqyQ6EiUg+RIFn3hwV0Lfsg9PkfAGxYvhGA7Yf2oc8e29J35I7BZxQekkEKFZEkxVhd1bVqABvfcPq0jQZg+wFkszaXSDcUKiLVqHBp7rp1Hw16J3/ZlY1/X02fj2SkLpdIhRQqInFFgyTG0tz3ruR6EYDtDxzQnHW5RBKiUBEpFqcXEmO+o2nqconUkUJFWlcKVXMzW35eJCE9hoqZ/cHdj+jpmEjTSrnkeqbKz4ukrGSomFkfYHtgNzPbha2PBu4LDK5D20Tiq6YgYkJLdjXMJbJVuZ7KOcAlwCBgPltDpQu4Md1mNT/VAaujWkuvp7DfQ8NcIt0rGSru/kPgh2Z2kbvfUMc2NT3VAauDOCutouq8UTCV8vMiOdDjnIq732BmhwBt0fPdvWX/s+zED5+4JUQKvRVJQKkgaZKd5eqdiPQszkT9T4C9gIXAu+FhB/RPk1QnoSW79abeiUjP4iwpbgdGequVM5bapbzqqh7UO5FKvP3223R2drJx48ZGN6Vqffr0YciQIfTu3buqz8cJlWeBAcDKqq4g+ZeD8ChFvROpRGdnJzvttBNtbW2YWc8faDLuzpo1a+js7GT48OFVfUecUNkNWGxmTwFvRS5+bFVXlHyosGRJlqh3ItXauHFjZgMFwMzYddddWb16ddXfESdUvln1t0t+LfoFvLoIBozObHiUot6J1CKrgVJQa/vjrP56tKYrSHaV2x9SCJSzflPfNqVEvRPJi+XLl3PYYYcxf/58+vXrx7p169h///2ZPXs25557Lk8++SSHHnooD4b/f09anNVfrxOs9gLYFugNvOHufUt/SnIh2hspNmB00DvJMJVXkTwaOnQo5513HpMmTWLq1KlMmjSJiRMn0tbWxmWXXcaGDRu45ZZbUrt+nJ7KToXXFvSLxgOfSK1F0ljR3knOeiPFVF5F8urLX/4yBxxwANdffz2PP/44N94YFEE54ogjmDNnTqrXrqhKcbis+FdmNhmYVO5cM7sdOAZ4zd1Hhce+CXwRKMwCXeHus8L3vgqcTbAX5kvu/nB4fCzwQ6AX8H/dfUp4fDgwE9iVoIzM6e6+qZL7SUrmS7aUmnTPQW+kmIa5pF6+9evnWPxKV6LfOXJQXyZ/7iM9nte7d2+uvfZaxo4dy+9+97uqlwdXI87w1z9FftyGYN9KnEXY0wlqhBX/E/sDd/9e0TVGAqcAHyGoNfZ7M/tw+PaPgc8AncDTZvaAuy8Grgm/a6aZ/R+CQLo5RrsSlYuSLTmedC+mSXhpFQ899BADBw7k2Wef5TOf+Uzdrhunp/K5yOt3gJcJhsDKcvfHzKwtZjvGAzPd/S3gJTNbChwUvrfU3V8EMLOZwHgzex74NHBaeM4MglVqdQ+VzJZsaaFhLvVOpBHi9CjSsnDhQh555JEtk/KnnHIKAwcOrMu1t+npBHc/K/Lni+5+tbu/VsM1LzSzZ8zs9rCkPgSl9JdHzukMj5U6vivwd3d/p+i4xFXonUAuh7miCr0TQL0TyT1357zzzuP6669n2LBhXHbZZVx66aV1u36c4a8hwA3AJ8NDc4GL3b2ziuvdDFxJsJrsSuD7wBeq+J6KmNlEYCLAsGHD0r5c81LvpMGtEknfrbfeyrBhw7YMeZ1//vlMmzaNRx99lK9//eu88MILrF+/niFDhnDbbbdx5JFHJnr9OMNf04A7gcJEwefDYxUP0rn7qsJrM7sVKCyUXgEMjZw6JDxGieNrgJ3N7ANhbyV6fnfXnQpMBWhvb2+tGmYtNAkfpbkTaVUTJ05k4sSJW37u1asXCxYsAGDu3LmpXz9OqOzu7tMiP083s0uquZiZDXT3Qg2x4wnqigE8ANxpZtcRTNSPAJ4ieDDYiHCl1wqCyfzT3N3NbDZwAsEKsDOA+6tpU+61yCR8tGcC6p2INEqcUFljZp8H7gp/PpWgp1CWmd0FHE7wOOJOYDJwuJntRzD89TLB0yVx9+fM7B5gMcFigAvc/d3wey4EHiZYUny7uz8XXuJyYKaZXQX8F3BbjHtpDS00zFUQ7ZmA5k5EGiVOqHyBYE7lBwRh8J9Aj/+p6+6ndnO45L/43f1q4Opujs8CZnVz/EW2rhCTqGjvJMfDXJo3EWk+cXbULwNUkTimptkI2WK9E/VMRJpDyVAxs2sJ9ojcUnT8HGC4u5fdUd+KGroRsrshrxxS70SkuZXrqXwa+Ldujt8KPEMPZVpaUZIbIe+c91fuX1hyQdv7/Pua2xix+WW2HfyxXA95qXci0tzKhcp23T1C2N03W9YfGNCkokEy76W1AIwZ3q/k+UdsmMUn35wNwNC3/sIC35MfbPp68OZ8YP4TAIzfbzCnjcnu/hz1TkTiK1X6/r777uO8886jq6uLXr168bWvfY2TTz458euXC5U3zWyEu/85etDMRgBvJt6SFlTcG4kGyZjh/XoOg2lXwca/woDRrHp9JM+8e8j7Tpn30lrmvbR2y3WyGDDqnYjEV6r0/fbbb88dd9zBiBEjeOWVVzjggAM48sgj2XnnnRO9frlQ+XfgoXDJ7vzwWDvwVeCSRFvRQsr1RmIFSbFwQr4/QcmAiUVvF18vKwGj3olI9borfR+tVDxo0CD22GMPVq9eXb9QcfeHzOw44DLgovDws8A/u/uiRFvRQu5fuILFK7sYObBvdSFSodPGDNvy/VkKGPVOJPMemrS1vl5SBoyGo6b0eFpPpe+feuopNm3axF577ZVs++hhSbG7P0uwW11qEP2XeSFQ7j7n4Oq+rIZVXs0eMOqdiCSnVOn7lStXcvrppzNjxgy22abHmsIVq+ghXVKdaO9k5MC+jN+vhoLKCW1sbMaAUe9EciVGjyItpUrfd3V1cfTRR3P11VfziU+k8wBfhUpKXut6i84NSxkz7Z/Z4O8wcMgh3P2/L0/myxPe2FgqYBav7NryflrUOxFJVqnS99OmTeP4449nwoQJnHBCelsOFCopebvrY2x+5w3YDrbps5Le2/+p+i+r48bGaMCcfMsTLF7Zxcm3pLc0Wb0TkWSVKn3/3e9+l8cee4w1a9Ywffp0AKZPn85+++2X6PXjPE/lwwTPQenv7qPM7KPAse5+VaItyZld3j2MXeww7j7r4NqfCNmgWl7RYbriYbHC+0mEjHonIskpV/p+8uTJqV8/Tk/lVoIVYLcAuPszZnYnoFCppwbU8io1LAa1zb10N+QlIvkQJ1S2d/enijbRv1Pq5FbW3SqvvIgGDNQ296IhL5H8ihMqfzOzvQjK3mNmJwAry3+kNSW6yqvJC0RWOveiCXmR1hAnVC4geBTvPma2AniJ4JHC0o2a9qBEZeiZKNHwLNVrUe9EpDXEeZ7Ki8D/MrMdgG3c/fX0m5U/VT1nJSPPRCnVazngmTkcvmIh/XfaTr0TkRZR7nkq/1riOADufl1KbcqUOPMoDX3OSp1Fey0feuaP9O56BT46Sr0TkRZRrqeyU91akWFx5lFiP2elyedR4jjq5Sf55OPB3Mnarlf4S99BTDn0PADGtw3mtEY2TqQFlCp9P336dL785S+zefNm3n77bS666CLOPffcxK9frqDktxK/Wk614jxKKdG5k7eHj+DFwfsBzVNfTCTvSpW+P/jgg3niiSfYbrvtWL9+PaNGjeLYY49l0KBBiV4/zubHaYQrv6Lc/QuJtkQCGZlHKacwd7IncFB4rN7lX0RaWU+l79966y02b96cyrXjrP56MPK6D3A88EoqrcmIPO9HqUaczYz1Lv8i0mjXPHUNL6x9IdHv3KffPlx+UM81BEuVvl++fDlHH300S5cu5dprr028lwLxVn/dG/3ZzO4CHk+8JRlS636UqlaCNbFKlwuXK/+igBFJRnel74cOHcozzzzDK6+8wnHHHccJJ5xA//79E71uNQUlRwB7JNqKDKp2HuU9K8FWL4JXF3HiH6cHBzI0OV/LZsZGVkUWqZc4PYq0lCp9XzBo0CBGjRrF3LlzE69Y3OMTWszsdTPrKvwBfg007n+tjDvxwycybew0po2dxt7vApve2PpmhibnC70ToKblwqeNGcbd5xzM3ecczMiBfbcMi518yxPcOe+vSTZZpCWUKn3f2dnJm2++CcC6det4/PHH2XvvvRO/fpzhLy0tTtO2O8CZ2ZyYT3ozo4bFRGpXqvT9bbfdxr333ouZ4e5ceumljB6d/MhInNVfxwP/z93/Ef68M3C4u/8q8dZI04oOd0E61YWb8WmUIlmThdL3k939vsIP7v53M5sM/Cq1VjWhVl/xFZ2Mh9qGvOLQvItINsUJle7mXVruiZGJVSCO7pp/+w2WbNv7Pbvsm2k1WLNUFtZyZJHsiBMOHWZ2HfDj8OcLgPnpNal5JbJzPrJrflzvPWCH7be81Wx1wZqxsnCcisgi0jhxQuUi4BvA3QQ76x8hCBapVrhr/kQgGh81P3Y4Bc1WWVi9FpHmFmf11xvAJDPbIXwdi5ndDhwDvObuo8Jj/QjCqQ14GTjJ3ddZUPr4h8A4YANwprsvCD9zBvD18GuvcvcZ4fEDgOnAB4FZwMXu/r5yMlKZLD3qt9xqscL7ChmR+oqzT+UQM1sMPB/+/DEzuynGd08HxhYdmwT8wd1HAH8IfwY4imBT5QhgInBzeK1+wGRgDEEZqclmtkv4mZuBL0Y+V3wtqUJS+0/qIbrH5TvHj2bM8H5b3pv30lquuG+R9ryI1Fmc4a8fAEcCDwC4+5/M7LCePuTuj5lZW9Hh8cDh4esZwByCjZTjgTvCnsaTZrazmQ0Mz33E3dcCmNkjwFgzmwP0dfcnw+N3AMcBD8W4n6bWiBIuzTIhX4vosBhoxZi0rlKl72fPnk1bWxtdXV2MHDmS4447jhtvvDHx6/fYUwFw9+VFh96t8nr93b3wfPtXgULRmcFA9Bqd4bFyxzu7Od4tM5toZh1m1rF69eqqGj5yUF9GDkp3GfG4D41j737BDtcla5cw68VZqV6vIEu9k7i0U19aVbT0PbCl9H1bWxsA3/jGNzjssB77BVWL01NZbmaHAG5mvYGLCYfCauHubmZ1mQNx96nAVID29vaqrjn5cx+pvgExH74V+2FeKchi7yQu7dSXVtNd6XuA+fPns2rVKsaOHUtHR0cq144TKucSTKIPBlYAv6P61V+rzGygu68Mh7deC4+vAIZGzhsSHlvB1uGywvE54fEh3ZzfnJrw4VtZmpCvlTZSSiO8+p3v8NbzyZa+327ffRhwxRU9ntdd6fvNmzfzla98hZ/+9Kf8/ve/T7RdUXFWf/0N+JeErvcAcAYwJfz7/sjxC81sJsGk/D/C4HkY+E5kcv6zwFfdfW1Y4PITwDxgAnBDQm1MRxUP30pzfqUZ96DUg5YkS6soLn1/0003MW7cOIYMGdLzh2tQMlTM7Aa6eeJjgbt/qdwXh89dORzYzcw6CVZxTQHuMbOzgWXASeHpswiWEy8lWFJ8VniNtWZ2JfB0eN63C5P2wPlsXVL8EDmYpI96T4n8lDZF5nnIKw5tpJQ0xelRpKW70vdPPPEEc+fO5aabbmL9+vVs2rSJHXfckSlTpiR67XI9lZoG3Nz91BJvHdHNuU6JITV3vx24vZvjHcCoWtrYzNKYX2mlIa841GuRPCpV+v5nP/vZlnOmT59OR0dH4oECZUKlsMmwwMx2DI+vT7wVUhetOuQVhybzJS9Klb5/9NFH+dSnPpX69a2nTehmNgr4CdAPMGA1MMHdn0u9dSlob2/3tFY9lDTt6ODvCudUCs767VksWbtky3LjaudXlp0+AaClh7ziKC67D2zZWKmAkXKef/559t1330Y3o2bd3YeZzXf39p4+G2f111TgX919dvjFhwO3AodU3NJWEnMZcRy1zK9oyKtyeq6LSPXihMoOhUABcPc5ZrZDim3KhwSXEdcyv6Ihr9ooYEQqEydUXjSzbxAMgQF8HngxvSblSBXLiOOodKlxq6/ySor2u4j0LE6ofAH4FvDL8Oe54TFpgDhDYRrySp9Wjkkp7k5QeD2bai32Hmfz4zqg7J4UqZ84Q2Ea8qovrRyTgj59+rBmzRp23XXXTAaLu7NmzRr69OlT9XeU2/z4QA8XP7bqq0piCkNhH/vPVRy62Nn9g7tnttJwVmneRQqGDBlCZ2cn1RaubQZ9+vSpadd9uZ7KwQQVgu8iKIWSvdjNuehQ2J7zltNrlcPo3dU7aaC4AVNMgZMPvXv3Zvjw4Y1uRkOV3KdiZr2AzwCnAh8FfgPcldX9KQV126dS496USj189EEAHPmbp+pyPalMNGCKLV7ZxciBfbn7nIPr3CqR+Grep+Lu7wK/BX5rZtsRhMscM/uWuyf/ZJc8SHBvSjU2vPNm3R/wJfEUP0QsShP9kidlJ+rDMDmaIFDagB8B96XfrIyqc4n76Cqvwa++zYoBHwTSK0Ap6dBEv+RJueGvOwgKNs4CZrr7s/VsWFpSHf6q85DXstMnvGfJcN9jjmGXk09KrKyL1J9KxEizSqJMy+eBNwie9PilyPI4IygsnO6zdSWW7lZ51aNsvqRDK8kk63osKJk3We+pdLexsdzSYfVa8kE9GGm0JAtKShOpdGOjei35oB6MZIV6KkmqQ0+llvL16rXkj3owUi/qqeRIUrW81GvJH/VgpNmop5KklHoqpVZ51UK9lnxTD0aSpp5KziRdyyvaa+lY1UHHqg5mvThry3sKmGxTD0YaRaFSqwbvoq9WtNrxz//751sCRcNi+aOAkXrS8Fetph393jAZfQK0V/Z0xu5UunQ4KRoWax0aIpNKaPirnlJ4wmOjnomiYbHWUUlFZYWMxKWeSq1SnJyH6pYOJyU6LNaxKvjfrL3/1v9QUcjkU3FF5eJeTJTCpnWopyI1KzXvAurF5FlxReVSZfsXr+zacr5IgXoqtUqwp9KoeZRqlOvFKGBaQ6Fk/8iB7y8DqB5M/qinkkFZerZ8qV6MejCtI1qyP0qrylqbeiq1SrCn0gzzKLXqaR6mQGGTX1pVlk/qqUhDlJuHKSjuzUQpbLJP+2Jam3oqtaqhpxKdQ4Hmn0dJSrmwAc3N5JV6MNkWt6eiUKlVDaFSXNMLkqnrlVUaOmsd5QImSmHTPJo6VMzsZeB14F3gHXdvN7N+wN1AG/AycJK7r7PgkZM/BMYBG4Az3X1B+D1nAF8Pv/Yqd5/R07UTCZXuSrNUGSqQ7TmUtMTtzUQpbLKp1JJl9WaaSxZCpd3d/xY59h/AWnefYmaTgF3c/XIzGwdcRBAqY4AfuvuYMIQ6gHbAgfnAAe6+rty1EwmVhEqzKFQqV03YFFP4ZIOGy5pLFkNlCXC4u680s4HAHHff28xuCV/fFT2v8MfdzwmPv+e8UhILFah5HqVV5lDqoVTYFFNPJ5sUMI3X7Ku/HPidmTlwi7tPBfq7+8rw/VeB/uHrwcDyyGc7w2Oljr+PmU0EJgIMG9bY//NlaS9KlkRXnZUTd0WaAqa5VFKnLEqBU3+NCpVD3X2Fme0BPGJmL0TfdHcPAycRYWhNhaCnktT3Vku9k8YpFT7lNnBGKWwar1TAFCsXOAqb9DQkVNx9Rfj3a2Z2H3AQsMrMBkaGv14LT18BDI18fEh4bAXBEFj0+JyUmy45Vc3+GgVM4xXXKYtSzbLGqPucipntAGzj7q+Hrx8Bvg0cAayJTNT3c/d/M7OjgQvZOlH/I3c/KJyonw/sH371AoKJ+rXlrt+IORXNo+SDljzng2qWVaeZ51T6A/cFK4X5AHCnu//WzJ4G7jGzs4FlQGGzxiyCQFlKsKT4LAB3X2tmVwJPh+d9u6dAaRTNo+SDqgXkQ9yaZcWfUdjEo82P1aiwp6Klw62j2iXPCpzGi7tfJqqVwqaZeyoiuRVnIUAx9W6aQ6n5mXJho1pm76dQEamDckueqxlKi1LwpCtO2GjobCsNf1UjxvCXJuelVnE2dGrBQHOoZugMshU4Tb2jvpGqDpUK630VF4ts5UKRkh7VSGtuPe2jgexUBlColFB1qFRY70uT89JItdZIU/CkL2uVmhUqJdQUKqAVX5JptQ6pgQInDVmo1KzVXyLyPnFqpFW7Ui1KwVOZPC0GUE8lLk3Oi2jxQAM1eh+Nhr9KSDNUNDkvovmceosbNiMH9WXy5z5S9XU0/NUg6p1Iq6tmA2iBNoJWrtJNm2lTqIhIXdQynxN3LqdYKwdRuQrOaVKoiEjTqKWXU0yLChpDoSIiTS/ukz2jNNzWGAqVGnW34ktEGq8ew20KnvdTqNRIz0oRya60FhVEtVrwKFQSoBVfIvlS6ybRglZcYKBQERGpQlLBU6yaIGqmEFKoiIikJK0FBlFxQ2iffvtw+UGXV9SWaihU4ipUJxYRSVGlQVRNbyhNCpW4jpqy5aVWfIlIs6imN5SmbRrdgCwqrPgCtOJLRCRCPZUqacWXiMj7qaciIiKJUaiIiEhiFCoiIpIYzanEpBVfIiI9U08lJq34EhHpmXoqFdCKLxGR8tRTERGRxChUREQkMQoVERFJTOZDxczGmtkSM1tqZpMa3R4RkVaW6VAxs17Aj4GjgJHAqWY2srGtEhFpXZkOFeAgYKm7v+jum4CZwPgGt0lEpGVlfUnxYGB55OdOYEzxSWY2EZgIMGzYsKoutN2+2uwoItKTrIdKLO4+FZgK0N7e7tV8x4Arrki0TSIieZT14a8VwNDIz0PCYyIi0gBZD5WngRFmNtzMtgVOAR5ocJtERFpWpoe/3P0dM7sQeBjoBdzu7s81uFkiIi0r06EC4O6zgFmNboeIiGR/+EtERJqIQkVERBKjUBERkcQoVEREJDHmXtVewMwys9XAsio/vhvwtwSbkyWtfO/Q2vffyvcOrX3/0Xvf09137+kDLRcqtTCzDndvb3Q7GqGV7x1a+/5b+d6hte+/mnvX8JeIiCRGoSIiIolRqFRmaqMb0ECtfO/Q2vffyvcOrX3/Fd+75lRERCQx6qmIiEhiFCoiIpIYhUoMZjbWzJaY2VIzm9To9tSbmb1sZovMbKGZdTS6PWkzs9vN7DUzezZyrJ+ZPWJmfw7/3qWRbUxLiXv/ppmtCH//C81sXCPbmBYzG2pms81ssZk9Z2YXh8dz/7svc+8V/+41p9IDM+sF/DfwGYLHFT8NnOruixvasDoys5eBdndviQ1gZnYYsB64w91Hhcf+A1jr7lPC/7DYxd0vb2Q701Di3r8JrHf37zWybWkzs4HAQHdfYGY7AfOB44Azyfnvvsy9n0SFv3v1VHp2ELDU3V90903ATGB8g9skKXL3x4C1RYfHAzPC1zMI/oHLnRL33hLcfaW7Lwhfvw48DwymBX73Ze69YgqVng0Glkd+7qTK/7EzzIHfmdl8M5vY6MY0SH93Xxm+fhXo38jGNMCFZvZMODyWu+GfYmbWBnwcmEeL/e6L7h0q/N0rVCSOQ919f+Ao4IJwiKRleTBm3ErjxjcDewH7ASuB7ze0NSkzsx2Be4FL3L0r+l7ef/fd3HvFv3uFSs9WAEMjPw8Jj7UMd18R/v0acB/BkGCrWRWOOxfGn19rcHvqxt1Xufu77r4ZuJUc//7NrDfBv1R/5u6/DA+3xO++u3uv5nevUOnZ08AIMxtuZtsCpwAPNLhNdWNmO4QTd5jZDsBngWfLfyqXHgDOCF+fAdzfwLbUVeFfqKHjyenv38wMuA143t2vi7yV+999qXuv5nev1V8xhMvorgd6Abe7+9WNbVH9mNmHCHonAB8A7sz7/ZvZXcDhBGW/VwGTgV8B9wDDCB6dcJK7525Cu8S9H04w/OHAy8A5kTmG3DCzQ4G5wCJgc3j4CoK5hVz/7svc+6lU+LtXqIiISGI0/CUiIolRqIiISGIUKiIikhiFioiIJEahIiIiiVGoiKTIzHY2s/PD14PM7BeNbpNImrSkWCRFYR2lBwsVf0Xy7gONboBIzk0B9jKzhcCfgX3dfZSZnUlQ7XYHYATwPWBb4HTgLWCcu681s72AHwO7AxuAL7r7C/W+CZG4NPwlkq5JwF/cfT/gsqL3RgH/BBwIXA1scPePA08AE8JzpgIXufsBwKXATfVotEi11FMRaZzZ4bMrXjezfwC/Do8vAj4aVow9BPh5UJoJgO3q30yR+BQqIo3zVuT15sjPmwn+2dwG+HvYyxHJBA1/iaTrdWCnaj4YPs/iJTM7EYJKsmb2sSQbJ5I0hYpIitx9DfBHM3sWuLaKr/gX4Gwz+xPwHHqUtTQ5LSkWEZHEqKciIiKJUaiIiEhiFCoiIpIYhYqIiCRGoSIiIolRqIiISGIUKiIikpj/D+CyPoxq09sZAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_output(values_exact)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mc_estimate_approx(n,tau):\n",
-    "    return sum([model.simulate(k, times, approx_tau=tau) for i in range(n)])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mse(r1,r2):\n",
-    "    return np.square(r1 - r2).mean()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[10000.,  2000., 20000.,     0.],\n",
-       "       [10860.,  3810., 18190.,   950.],\n",
-       "       [11568.,  5312., 16688.,  1744.],\n",
-       "       [12207.,  6752., 15248.,  2545.],\n",
-       "       [12724.,  8009., 13991.,  3285.],\n",
-       "       [13116.,  9079., 12921.,  3963.],\n",
-       "       [13439., 10020., 11980.,  4581.],\n",
-       "       [13663., 10819., 11181.,  5156.],\n",
-       "       [13796., 11488., 10512.,  5692.],\n",
-       "       [13904., 12045.,  9955.,  6141.],\n",
-       "       [13918., 12516.,  9484.,  6598.],\n",
-       "       [13935., 12958.,  9042.,  7023.],\n",
-       "       [13881., 13324.,  8676.,  7443.],\n",
-       "       [13842., 13700.,  8300.,  7858.],\n",
-       "       [13776., 14023.,  7977.,  8247.],\n",
-       "       [13710., 14324.,  7676.,  8614.],\n",
-       "       [13621., 14564.,  7436.,  8943.],\n",
-       "       [13518., 14796.,  7204.,  9278.],\n",
-       "       [13427., 15045.,  6955.,  9618.],\n",
-       "       [13230., 15197.,  6803.,  9967.],\n",
-       "       [13071., 15356.,  6644., 10285.],\n",
-       "       [12933., 15519.,  6481., 10586.],\n",
-       "       [12740., 15636.,  6364., 10896.],\n",
-       "       [12562., 15772.,  6228., 11210.],\n",
-       "       [12388., 15911.,  6089., 11523.],\n",
-       "       [12199., 16008.,  5992., 11809.],\n",
-       "       [12068., 16187.,  5813., 12119.],\n",
-       "       [11898., 16320.,  5680., 12422.],\n",
-       "       [11711., 16417.,  5583., 12706.],\n",
-       "       [11522., 16498.,  5502., 12976.],\n",
-       "       [11365., 16574.,  5426., 13209.],\n",
-       "       [11208., 16690.,  5310., 13482.],\n",
-       "       [11013., 16752.,  5248., 13739.],\n",
-       "       [10839., 16826.,  5174., 13987.],\n",
-       "       [10649., 16869.,  5131., 14220.],\n",
-       "       [10459., 16950.,  5050., 14491.],\n",
-       "       [10288., 17024.,  4976., 14736.],\n",
-       "       [10110., 17111.,  4889., 15001.],\n",
-       "       [ 9915., 17160.,  4840., 15245.],\n",
-       "       [ 9711., 17212.,  4788., 15501.],\n",
-       "       [ 9579., 17322.,  4678., 15743.],\n",
-       "       [ 9378., 17332.,  4668., 15954.],\n",
-       "       [ 9234., 17430.,  4570., 16196.],\n",
-       "       [ 9082., 17484.,  4516., 16402.],\n",
-       "       [ 8918., 17530.,  4470., 16612.],\n",
-       "       [ 8721., 17564.,  4436., 16843.],\n",
-       "       [ 8534., 17589.,  4411., 17055.],\n",
-       "       [ 8363., 17613.,  4387., 17250.],\n",
-       "       [ 8215., 17684.,  4316., 17469.],\n",
-       "       [ 8104., 17766.,  4234., 17662.],\n",
-       "       [ 7972., 17834.,  4166., 17862.],\n",
-       "       [ 7815., 17854.,  4146., 18039.],\n",
-       "       [ 7703., 17952.,  4048., 18249.],\n",
-       "       [ 7583., 18006.,  3994., 18423.],\n",
-       "       [ 7407., 18012.,  3988., 18605.],\n",
-       "       [ 7299., 18093.,  3907., 18794.],\n",
-       "       [ 7193., 18201.,  3799., 19008.],\n",
-       "       [ 7049., 18227.,  3773., 19178.],\n",
-       "       [ 6937., 18303.,  3697., 19366.],\n",
-       "       [ 6816., 18357.,  3643., 19541.],\n",
-       "       [ 6692., 18414.,  3586., 19722.],\n",
-       "       [ 6585., 18503.,  3497., 19918.],\n",
-       "       [ 6437., 18517.,  3483., 20080.],\n",
-       "       [ 6346., 18581.,  3419., 20235.],\n",
-       "       [ 6264., 18670.,  3330., 20406.],\n",
-       "       [ 6134., 18680.,  3320., 20546.],\n",
-       "       [ 6009., 18729.,  3271., 20720.],\n",
-       "       [ 5920., 18793.,  3207., 20873.],\n",
-       "       [ 5789., 18818.,  3182., 21029.],\n",
-       "       [ 5651., 18826.,  3174., 21175.],\n",
-       "       [ 5521., 18861.,  3139., 21340.],\n",
-       "       [ 5447., 18942.,  3058., 21495.],\n",
-       "       [ 5337., 18983.,  3017., 21646.],\n",
-       "       [ 5218., 19016.,  2984., 21798.],\n",
-       "       [ 5117., 19039.,  2961., 21922.],\n",
-       "       [ 5036., 19086.,  2914., 22050.],\n",
-       "       [ 4959., 19155.,  2845., 22196.],\n",
-       "       [ 4877., 19206.,  2794., 22329.],\n",
-       "       [ 4801., 19276.,  2724., 22475.],\n",
-       "       [ 4674., 19294.,  2706., 22620.],\n",
-       "       [ 4580., 19300.,  2700., 22720.],\n",
-       "       [ 4461., 19323.,  2677., 22862.],\n",
-       "       [ 4379., 19380.,  2620., 23001.],\n",
-       "       [ 4320., 19438.,  2562., 23118.],\n",
-       "       [ 4288., 19527.,  2473., 23239.],\n",
-       "       [ 4204., 19558.,  2442., 23354.],\n",
-       "       [ 4122., 19595.,  2405., 23473.],\n",
-       "       [ 4048., 19639.,  2361., 23591.],\n",
-       "       [ 3980., 19693.,  2307., 23713.],\n",
-       "       [ 3902., 19705.,  2295., 23803.],\n",
-       "       [ 3854., 19775.,  2225., 23921.],\n",
-       "       [ 3775., 19814.,  2186., 24039.],\n",
-       "       [ 3708., 19836.,  2164., 24128.],\n",
-       "       [ 3633., 19863.,  2137., 24230.],\n",
-       "       [ 3579., 19905.,  2095., 24326.],\n",
-       "       [ 3501., 19924.,  2076., 24423.],\n",
-       "       [ 3434., 19957.,  2043., 24523.],\n",
-       "       [ 3375., 19998.,  2002., 24623.],\n",
-       "       [ 3322., 20034.,  1966., 24712.],\n",
-       "       [ 3245., 20046.,  1954., 24801.]])"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model.simulate(k, times)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[10000.,  2000., 20000.,     0.],\n",
-       "       [10843.,  3798., 18202.,   955.],\n",
-       "       [11578.,  5414., 16586.,  1836.],\n",
-       "       [12160.,  6773., 15227.,  2613.],\n",
-       "       [12623.,  7957., 14043.,  3334.],\n",
-       "       [13040.,  8983., 13017.,  3943.],\n",
-       "       [13335.,  9904., 12096.,  4569.],\n",
-       "       [13599., 10693., 11307.,  5094.],\n",
-       "       [13765., 11394., 10606.,  5629.],\n",
-       "       [13861., 11953., 10047.,  6092.],\n",
-       "       [13939., 12501.,  9499.,  6562.],\n",
-       "       [13952., 12961.,  9039.,  7009.],\n",
-       "       [13988., 13429.,  8571.,  7441.],\n",
-       "       [13911., 13747.,  8253.,  7836.],\n",
-       "       [13840., 14051.,  7949.,  8211.],\n",
-       "       [13747., 14344.,  7656.,  8597.],\n",
-       "       [13659., 14656.,  7344.,  8997.],\n",
-       "       [13482., 14823.,  7177.,  9341.],\n",
-       "       [13313., 15005.,  6995.,  9692.],\n",
-       "       [13147., 15168.,  6832., 10021.],\n",
-       "       [12972., 15323.,  6677., 10351.],\n",
-       "       [12838., 15516.,  6484., 10678.],\n",
-       "       [12624., 15602.,  6398., 10978.],\n",
-       "       [12500., 15815.,  6185., 11315.],\n",
-       "       [12324., 15933.,  6067., 11609.],\n",
-       "       [12207., 16075.,  5925., 11868.],\n",
-       "       [12018., 16164.,  5836., 12146.],\n",
-       "       [11794., 16224.,  5776., 12430.],\n",
-       "       [11579., 16320.,  5680., 12741.],\n",
-       "       [11383., 16410.,  5590., 13027.],\n",
-       "       [11219., 16534.,  5466., 13315.],\n",
-       "       [11040., 16605.,  5395., 13565.],\n",
-       "       [10869., 16684.,  5316., 13815.],\n",
-       "       [10705., 16774.,  5226., 14069.],\n",
-       "       [10535., 16862.,  5138., 14327.],\n",
-       "       [10342., 16909.,  5091., 14567.],\n",
-       "       [10150., 16971.,  5029., 14821.],\n",
-       "       [ 9972., 17037.,  4963., 15065.],\n",
-       "       [ 9758., 17033.,  4967., 15275.],\n",
-       "       [ 9596., 17121.,  4879., 15525.],\n",
-       "       [ 9425., 17195.,  4805., 15770.],\n",
-       "       [ 9294., 17292.,  4708., 15998.],\n",
-       "       [ 9138., 17338.,  4662., 16200.],\n",
-       "       [ 9019., 17420.,  4580., 16401.],\n",
-       "       [ 8845., 17488.,  4512., 16643.],\n",
-       "       [ 8705., 17562.,  4438., 16857.],\n",
-       "       [ 8559., 17624.,  4376., 17065.],\n",
-       "       [ 8412., 17681.,  4319., 17269.],\n",
-       "       [ 8277., 17774.,  4226., 17497.],\n",
-       "       [ 8126., 17827.,  4173., 17701.],\n",
-       "       [ 7978., 17861.,  4139., 17883.],\n",
-       "       [ 7855., 17966.,  4034., 18111.],\n",
-       "       [ 7709., 18002.,  3998., 18293.],\n",
-       "       [ 7584., 18081.,  3919., 18497.],\n",
-       "       [ 7466., 18168.,  3832., 18702.],\n",
-       "       [ 7295., 18200.,  3800., 18905.],\n",
-       "       [ 7151., 18255.,  3745., 19104.],\n",
-       "       [ 7019., 18304.,  3696., 19285.],\n",
-       "       [ 6887., 18340.,  3660., 19453.],\n",
-       "       [ 6776., 18432.,  3568., 19656.],\n",
-       "       [ 6672., 18510.,  3490., 19838.],\n",
-       "       [ 6527., 18529.,  3471., 20002.],\n",
-       "       [ 6425., 18590.,  3410., 20165.],\n",
-       "       [ 6312., 18635.,  3365., 20323.],\n",
-       "       [ 6170., 18660.,  3340., 20490.],\n",
-       "       [ 6040., 18684.,  3316., 20644.],\n",
-       "       [ 5909., 18721.,  3279., 20812.],\n",
-       "       [ 5828., 18780.,  3220., 20952.],\n",
-       "       [ 5741., 18851.,  3149., 21110.],\n",
-       "       [ 5629., 18889.,  3111., 21260.],\n",
-       "       [ 5539., 18959.,  3041., 21420.],\n",
-       "       [ 5391., 18950.,  3050., 21559.],\n",
-       "       [ 5311., 19023.,  2977., 21712.],\n",
-       "       [ 5186., 19052.,  2948., 21866.],\n",
-       "       [ 5062., 19063.,  2937., 22001.],\n",
-       "       [ 4958., 19093.,  2907., 22135.],\n",
-       "       [ 4866., 19131.,  2869., 22265.],\n",
-       "       [ 4761., 19178.,  2822., 22417.],\n",
-       "       [ 4689., 19228.,  2772., 22539.],\n",
-       "       [ 4601., 19268.,  2732., 22667.],\n",
-       "       [ 4568., 19352.,  2648., 22784.],\n",
-       "       [ 4475., 19395.,  2605., 22920.],\n",
-       "       [ 4393., 19430.,  2570., 23037.],\n",
-       "       [ 4302., 19458.,  2542., 23156.],\n",
-       "       [ 4227., 19529.,  2471., 23302.],\n",
-       "       [ 4146., 19559.,  2441., 23413.],\n",
-       "       [ 4033., 19563.,  2437., 23530.],\n",
-       "       [ 3946., 19590.,  2410., 23644.],\n",
-       "       [ 3860., 19618.,  2382., 23758.],\n",
-       "       [ 3803., 19675.,  2325., 23872.],\n",
-       "       [ 3750., 19732.,  2268., 23982.],\n",
-       "       [ 3716., 19810.,  2190., 24094.],\n",
-       "       [ 3660., 19867.,  2133., 24207.],\n",
-       "       [ 3601., 19896.,  2104., 24295.],\n",
-       "       [ 3516., 19915.,  2085., 24399.],\n",
-       "       [ 3450., 19939.,  2061., 24489.],\n",
-       "       [ 3380., 19967.,  2033., 24587.],\n",
-       "       [ 3333., 20019.,  1981., 24686.],\n",
-       "       [ 3279., 20065.,  1935., 24786.],\n",
-       "       [ 3210., 20098.,  1902., 24888.]])"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model.simulate(k, times, approx_tau=0.0125)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "empirical_mean = sum([model.simulate(k, times) for i in range(30)])/30"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_output(empirical_mean)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "exact_mse = 0\n",
-    "for i in range(25):\n",
-    "    exact = model.simulate(k, times)\n",
-    "    exact_mse += mse(exact, empirical_mean)/25"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running for tau = 0.0125\n",
-      "Running for tau = 0.025\n",
-      "Running for tau = 0.05\n",
-      "Running for tau = 0.1\n",
-      "Running for tau = 0.25\n",
-      "Running for tau = 0.5\n",
-      "Running for tau = 1\n"
-     ]
-    }
-   ],
-   "source": [
-    "taus = [0.0125, 0.025, 0.05, 0.1, 0.25, 0.5, 1]\n",
-    "approx_mses = []\n",
-    "\n",
-    "for tau in taus:\n",
-    "    amse = 0\n",
-    "    print(\"Running for tau = \" + str(tau))\n",
-    "    for i in range(1000):\n",
-    "        sim = model.simulate(k, times, approx_tau=tau)\n",
-    "        amse = mse(empirical_mean, sim)/1000\n",
-    "    approx_mses.append(amse)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1c7017d8>]"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot([0]+taus[:4], [exact_mse]+approx_mses[:4], 'bo')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "interpreter": {
-   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
-  },
-  "kernelspec": {
-   "display_name": "Python 3.8.0 32-bit",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.0"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/pints/toy/stochastic/__init__.py b/pints/toy/stochastic/__init__.py
index 602bda884..9259fe154 100644
--- a/pints/toy/stochastic/__init__.py
+++ b/pints/toy/stochastic/__init__.py
@@ -6,8 +6,5 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 from ._markov_jump_model import MarkovJumpModel  # noqa
 from ._michaelis_menten_model import MichaelisMentenModel # noqa
diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py
index 58ab3e2b3..d67cd1b0d 100644
--- a/pints/toy/stochastic/_markov_jump_model.py
+++ b/pints/toy/stochastic/_markov_jump_model.py
@@ -5,8 +5,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
 import numpy as np
 from scipy.interpolate import interp1d
 import pints
@@ -19,15 +17,7 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
     r"""
     A general purpose Markov Jump model used for any systems of reactions
     that proceed through jumps. We simulate a population of N different species
-    reacting through M different mechanisms.
-
-    A model has three parameters:
-        - x_0 - an N-vector specifying the initial population of each
-            of the N species
-        - V - an NxM matrix consisting of stochiometric vectors v_i specifying
-            the changes to the state, x,  from reaction i taking place
-        - a - a function from the current state, x, and reaction rates, k,
-            to a vector of the rates of each reaction taking place
+    reacting through M different mechanisms
 
     Simulations are performed using Gillespie's algorithm [1]_, [2]_:
 
@@ -50,16 +40,23 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
     .. math::
         x(t + \tau) = x(t) + V[i]
 
-    4. Return to step (1) until no reaction can take place
+    4. Return to step (1) until no reaction can take place or the process
 
-    The model has one parameter, the rate constant :math:`k`.
+    has gone past the maximum time.
 
     Extends :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`.
 
     Parameters
     ----------
-    initial_molecule_count
-        The initial molecule count :math:`A(0)`.
+    x_0
+        An N-vector specifying the initial population of each
+        of the N species.
+    V
+        An NxM matrix consisting of stochiometric vectors v_i specifying
+        the changes to the state, x,  from reaction i taking place.
+    propensities
+        A function from the current state, x, and reaction rates, k,
+        to a vector of the rates of each reaction taking place.
 
     References
     ----------
@@ -72,11 +69,11 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
            Journal of Computational Physics
            https://doi.org/10.1016/0021-9991(76)90041-3
     """
-    def __init__(self, x0, V, a):
+    def __init__(self, x0, V, propensities):
         super(MarkovJumpModel, self).__init__()
         self._x0 = np.asarray(x0)
         self._V = V
-        self._a = a
+        self._propensities = propensities
         if any(self._x0 < 0):
             raise ValueError('Initial molecule count cannot be negative.')
 
@@ -88,68 +85,36 @@ def simulate_raw(self, rates, max_time):
         """
         Returns raw times, mol counts when reactions occur
         """
-        # parameters = np.asarray(parameters)
-        # if len(parameters) != self.n_parameters():
-        #     raise ValueError('This model should have only 1 parameter.')
-        # k = parameters[0]
-
-        current_rates = self._a(self._x0, rates)
-        a_0 = sum(current_rates)
+        # Setting the current propensities and summing them up
+        current_propensities = self._propensities(self._x0, rates)
+        prop_sum = sum(current_propensities)
 
         # Initial time and count
         t = 0
         x = np.array(self._x0)
 
-        # Run gillespie SSA, calculating time until next
+        # Run Gillespie SSA, calculating time until next
         # reaction, deciding which reaction, and applying it
         mol_count = [np.array(x)]
         time = [t]
-        while a_0 > 0 and t <= max_time:
+        while prop_sum > 0 and t <= max_time:
             r_1, r_2 = random.random(), random.random()
-            t += -np.log(r_1) / (a_0)
+            t += -np.log(r_1) / (prop_sum)
             s = 0
             r = 0
-            while s <= r_2 * a_0:
-                s += current_rates[r]
+            while s <= r_2 * prop_sum:
+                s += current_propensities[r]
                 r += 1
             r -= 1
             x = np.add(x, self._V[r])
 
-            current_rates = self._a(x, rates)
-            a_0 = sum(current_rates)
+            current_propensities = self._propensities(x, rates)
+            prop_sum = sum(current_propensities)
 
             time.append(t)
             mol_count.append(np.array(x))
         return time, mol_count
 
-    def simulate_approx(self, rates, max_time, tau):
-        assert tau > 0, "cannot tau-leap with negative tau"
-        current_rates = np.array(self._a(self._x0, rates))
-        # Initial time and count
-        t = 0
-        x = self._x0.copy()
-        N = len(rates)
-        # Run gillespie SSA, calculating time until next
-        # reaction, deciding which reaction, and applying it
-        mol_count = [x.copy()]
-        time = [t]
-        while any(current_rates > 0) and t <= max_time:
-            # Estimate number of each reaction in [t, t+tau)
-            k = [np.random.poisson(current_rates[i] * tau) for i in range(N)]
-
-            # Apply the reactions
-            for r in range(N):
-                x += np.array(self._V[r]) * k[r]
-
-            # Update rates
-            current_rates = np.array(self._a(x, rates))
-
-            # Advance Time
-            t += tau
-            time.append(t)
-            mol_count.append(x.copy())
-        return time, mol_count
-
     def interpolate_mol_counts(self, time, mol_count, output_times):
         """
         Takes raw times and inputs and mol counts and outputs interpolated
@@ -165,22 +130,14 @@ def interpolate_mol_counts(self, time, mol_count, output_times):
         values = interp_func(output_times)
         return values
 
-    def simulate(self, parameters, times, approx_tau=None):
+    def simulate(self, parameters, times):
         """ See :meth:`pints.ForwardModel.simulate()`. """
         times = np.asarray(times)
         if np.any(times < 0):
             raise ValueError('Negative times are not allowed.')
-        if approx_tau is None:
-            # run Gillespie
-            time, mol_count = self.simulate_raw(parameters, max(times))
-        else:
-            if (not approx_tau) or approx_tau <= 0:
-                ValueError("You must provide a positive value for approx_tau\
-                 to use tau-leaping approximation")
-            # Run Euler tau-leaping
-            time, mol_count = self.simulate_approx(parameters, max(times),
-                                                   approx_tau)
-        # interpolate
+        # Run Gillespie
+        time, mol_count = self.simulate_raw(parameters, max(times))
+        # Interpolate
         values = self.interpolate_mol_counts(np.asarray(time),
                                              np.asarray(mol_count), times)
         return values
diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py
index 396a51981..c9b3c85f8 100644
--- a/pints/toy/stochastic/_michaelis_menten_model.py
+++ b/pints/toy/stochastic/_michaelis_menten_model.py
@@ -5,9 +5,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 from . import MarkovJumpModel
 
 
@@ -16,18 +13,27 @@ class MichaelisMentenModel(MarkovJumpModel):
     Simulates the Michaelis Menten Dynamics using Gillespie.
 
     This system of reaction involves 4 chemical species with
-    inital counts x_0, and reactions:
+    inital counts ``initial_molecule_count``, and reactions:
 
         - X1+X2 -> X3 with rate k1
         - X3 -> X1+X2 with rate k2
         - X3 -> X2+X4 with rate k3
+
+    Parameters
+    ----------
+    initial_molecule_count : Array of size 3 of integers
+        Sets the initial molecule count.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Michaelis-Menten_kinetics
     """
-    def __init__(self, x_0):
-        mat = [[-1, -1, 1, 0],
-               [1, 1, -1, 0],
-               [0, 1, -1, 1]]
-        super(MichaelisMentenModel, self).__init__(x_0,
-                                                   mat, self._propensities)
+    def __init__(self, initial_molecule_count):
+        V = [[-1, -1, 1, 0],
+             [1, 1, -1, 0],
+             [0, 1, -1, 1]]
+        super(MichaelisMentenModel, self).__init__(initial_molecule_count,
+                                                   V, self._propensities)
 
     @staticmethod
     def _propensities(xs, ks):

From 97d737d0d053642381eabc2773a3c3ebe3edc154 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sat, 20 Nov 2021 22:54:53 +0000
Subject: [PATCH 05/25] added ipynb to readme

---
 examples/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/README.md b/examples/README.md
index dcd063b8a..ee17072f1 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -117,6 +117,7 @@ relevant code.
 - [SIR Epidemiology model](./toy/model-sir.ipynb)
 - [Stochastic Degradation model](./toy/model-stochastic-degradation.ipynb)
 - [Stochastic Logistic model](./toy/model-stochastic-logistic-growth.ipynb)
+- [Michaelis Menten model](./toy/model-michaelis-menten.ipynb)
 
 ### Distributions
 - [Annulus](./toy/distribution-annulus.ipynb)

From 1850b2b8d8ec842e93026769c4fa001073de16fe Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sat, 20 Nov 2021 23:50:20 +0000
Subject: [PATCH 06/25] added small tests for coverage

---
 pints/tests/test_toy_markov_jump_model.py     | 42 ++++++++++++++++++
 .../tests/test_toy_michaelis_menten_model.py  | 44 +++++++++++++++++++
 2 files changed, 86 insertions(+)
 create mode 100644 pints/tests/test_toy_markov_jump_model.py
 create mode 100644 pints/tests/test_toy_michaelis_menten_model.py

diff --git a/pints/tests/test_toy_markov_jump_model.py b/pints/tests/test_toy_markov_jump_model.py
new file mode 100644
index 000000000..2071f5ee8
--- /dev/null
+++ b/pints/tests/test_toy_markov_jump_model.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+#
+# Tests if the Markov Jump model works.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import unittest
+import numpy as np
+from pints.toy import MichaelisMentenModel
+
+
+class TestMarkovJumpModel(unittest.TestCase):
+    """
+    Tests if the Markov Jump model works.
+    """
+    def test_errors(self):
+        # Negative values for the initial population should
+        # raise an error
+        x_0 = [-1, 0, 1]
+        model = MichaelisMentenModel(x_0)
+        self.assertRaises(ValueError, MichaelisMentenModel, x_0)
+
+        # Negative times should raise an error
+        x_0 = [1e4, 2e3, 2e4, 0]
+        model = MichaelisMentenModel(x_0)
+        times = [-1, 0, 1]
+        k = [1e-5, 0.2, 0.2]
+        self.assertRaises(ValueError, model.simulate, k, times)
+
+    def test_simulation(self):
+        x_0 = [1e4, 2e3, 2e4, 0]
+        model = MichaelisMentenModel(x_0)
+        times = np.linspace(0, 1, 100)
+        k = [1e-5, 0.2, 0.2]
+        values = model.simulate(k, times)
+        self.assertEqual(len(values), 100)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pints/tests/test_toy_michaelis_menten_model.py b/pints/tests/test_toy_michaelis_menten_model.py
new file mode 100644
index 000000000..1274121e9
--- /dev/null
+++ b/pints/tests/test_toy_michaelis_menten_model.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+#
+# Tests if the Michaelis Menten (toy) model works.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import unittest
+import numpy as np
+import pints
+import pints.toy
+from pints.toy import MichaelisMentenModel
+
+
+class TestMichaelisMentenModel(unittest.TestCase):
+    """
+    Tests if the Michaelis Menten (toy) model works.
+    """
+    def test_n_parameters(self):
+        x_0 = [1e4, 2e3, 2e4, 0]
+        model = MichaelisMentenModel(x_0)
+        self.assertEqual(model.n_parameters, 3)
+
+    def test_simulation_length(self):
+        x_0 = [1e4, 2e3, 2e4, 0]
+        model = MichaelisMentenModel(x_0)
+        times = np.linspace(0, 1, 100)
+        k = [1e-5, 0.2, 0.2]
+        values = model.simulate(k, times)
+        self.assertEqual(len(values), 100)
+
+    def test_propensities(self):
+        x_0 = [1e4, 2e3, 2e4, 0]
+        k = [1e-5, 0.2, 0.2]
+        model = pints.toy.stochastic.MichaelisMentenModel(x_0)
+        self.assertTrue(
+            np.allclose(
+                model._propensities(x_0, k),
+                np.array([200.0, 4000.0, 4000.0])))
+
+
+if __name__ == '__main__':
+    unittest.main()

From b080f09d4721810c08ae1453c47b04edb7636e78 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sun, 21 Nov 2021 22:20:24 +0000
Subject: [PATCH 07/25] Added degradation model(for testing) + tests

---
 examples/toy/model-degradation.ipynb       | 131 +++++++++++++++++++++
 pints/tests/test_toy_degradation_model.py  |  42 +++++++
 pints/tests/test_toy_markov_jump_model.py  |  86 ++++++++++----
 pints/toy/stochastic/__init__.py           |   1 +
 pints/toy/stochastic/_degradation_model.py |  41 +++++++
 pints/toy/stochastic/_markov_jump_model.py |   6 +
 6 files changed, 284 insertions(+), 23 deletions(-)
 create mode 100644 examples/toy/model-degradation.ipynb
 create mode 100644 pints/tests/test_toy_degradation_model.py
 create mode 100644 pints/toy/stochastic/_degradation_model.py

diff --git a/examples/toy/model-degradation.ipynb b/examples/toy/model-degradation.ipynb
new file mode 100644
index 000000000..ffc4d623f
--- /dev/null
+++ b/examples/toy/model-degradation.ipynb
@@ -0,0 +1,131 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Degradation model\n",
+    "\n",
+    "This example shows how the degradation model can be used.\n",
+    "This model describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react.\n",
+    "The substance degrades starting from an initial concentration, $n_0$, to 0 following a rate constant, $k$, according to the following model ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n",
+    "   $$A \\xrightarrow{\\text{k}} \\emptyset$$\n",
+    "\n",
+    "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pints\n",
+    "import pints.toy.stochastic"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Specify the initial concentration, and select time points at which to record concentration values, and rate constant value (k):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_0 = 20\n",
+    "model = pints.toy.stochastic.DegradationModel(n_0)\n",
+    "\n",
+    "times = np.linspace(0, 100, 100)\n",
+    "k = [0.1]\n",
+    "\n",
+    "values = model.simulate(k, times)\n",
+    "\n",
+    "plt.step(times, values)\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in range(10):\n",
+    "    values = model.simulate(k, times)\n",
+    "    plt.step(times, values)\n",
+    "    \n",
+    "plt.title('stochastic degradation across different iterations')\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 32-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pints/tests/test_toy_degradation_model.py b/pints/tests/test_toy_degradation_model.py
new file mode 100644
index 000000000..7f73b602c
--- /dev/null
+++ b/pints/tests/test_toy_degradation_model.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+#
+# Tests if the degradation (toy) model works.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import unittest
+import numpy as np
+from pints.toy.stochastic import DegradationModel
+
+
+class TestDegradationModel(unittest.TestCase):
+    """
+    Tests if the degradation (toy) model works.
+    """
+    def test_n_parameters(self):
+        x_0 = 20
+        model = DegradationModel(x_0)
+        self.assertEqual(model.n_parameters(), 1)
+
+    def test_simulation_length(self):
+        x_0 = 20
+        model = DegradationModel(x_0)
+        times = np.linspace(0, 1, 100)
+        k = [0.1]
+        values = model.simulate(k, times)
+        self.assertEqual(len(values), 100)
+
+    def test_propensities(self):
+        x_0 = 20
+        k = [0.1]
+        model = DegradationModel(x_0)
+        self.assertTrue(
+            np.allclose(
+                model._propensities([x_0], k),
+                np.array([2.0])))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pints/tests/test_toy_markov_jump_model.py b/pints/tests/test_toy_markov_jump_model.py
index 2071f5ee8..905c9c418 100644
--- a/pints/tests/test_toy_markov_jump_model.py
+++ b/pints/tests/test_toy_markov_jump_model.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Tests if the Markov Jump model works.
+# Tests if the markov jump model works.
 #
 # This file is part of PINTS (https://github.com/pints-team/pints/) which is
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
@@ -8,34 +8,74 @@
 #
 import unittest
 import numpy as np
-from pints.toy import MichaelisMentenModel
+from pints.toy.stochastic import DegradationModel
 
 
 class TestMarkovJumpModel(unittest.TestCase):
     """
-    Tests if the Markov Jump model works.
+    Tests if the markov jump model works using
+    the degradation model.
     """
+    def test_start_with_zero(self):
+        # Test the special case where the initial molecule count is zero
+        model = DegradationModel(0)
+        times = [0, 1, 2, 100, 1000]
+        parameters = [0.1]
+        values = model.simulate(parameters, times)
+        self.assertEqual(len(values), len(times))
+        self.assertTrue(np.all(values == np.zeros(5)))
+
+    def test_start_with_twenty(self):
+        # Run small simulation
+        model = DegradationModel(20)
+        times = [0, 1, 2, 100, 1000]
+        parameters = [0.1]
+        values = model.simulate(parameters, times)
+        self.assertEqual(len(values), len(times))
+        self.assertEqual(values[0], 20)
+        self.assertEqual(values[-1], 0)
+        self.assertTrue(np.all(values[1:] <= values[:-1]))
+
+    def test_simulate(self):
+        times = np.linspace(0, 100, 101)
+        model = DegradationModel(20)
+        time, mol_count = model.simulate_raw([0.1], 100)
+        values = model.interpolate_mol_counts(time, mol_count, times)
+        self.assertTrue(len(time), len(mol_count))
+        # Test output of Gillespie algorithm
+        expected = np.array([[x] for x in range(20, -1, -1)])
+        self.assertTrue(np.all(mol_count == expected))
+
+        # Check simulate function returns expected values
+        self.assertTrue(np.all(values[np.where(times < time[1])] == 20))
+
+        # Check interpolation function works as expected
+        temp_time = np.array([np.random.uniform(time[0], time[1])])
+        self.assertEqual(
+            model.interpolate_mol_counts(time, mol_count, temp_time)[0],
+            20)
+        temp_time = np.array([np.random.uniform(time[1], time[2])])
+        self.assertEqual(
+            model.interpolate_mol_counts(time, mol_count, temp_time)[0],
+            19)
+
     def test_errors(self):
-        # Negative values for the initial population should
-        # raise an error
-        x_0 = [-1, 0, 1]
-        model = MichaelisMentenModel(x_0)
-        self.assertRaises(ValueError, MichaelisMentenModel, x_0)
-
-        # Negative times should raise an error
-        x_0 = [1e4, 2e3, 2e4, 0]
-        model = MichaelisMentenModel(x_0)
-        times = [-1, 0, 1]
-        k = [1e-5, 0.2, 0.2]
-        self.assertRaises(ValueError, model.simulate, k, times)
-
-    def test_simulation(self):
-        x_0 = [1e4, 2e3, 2e4, 0]
-        model = MichaelisMentenModel(x_0)
-        times = np.linspace(0, 1, 100)
-        k = [1e-5, 0.2, 0.2]
-        values = model.simulate(k, times)
-        self.assertEqual(len(values), 100)
+        model = DegradationModel(20)
+        # parameters, times cannot be negative
+        times = np.linspace(0, 100, 101)
+        parameters = [-0.1]
+        self.assertRaises(ValueError, model.simulate, parameters, times)
+
+        times_2 = np.linspace(-10, 10, 21)
+        parameters_2 = [0.1]
+        self.assertRaises(ValueError, model.simulate, parameters_2, times_2)
+
+        # this model should have 1 parameter
+        parameters_3 = [0.1, 1]
+        self.assertRaises(ValueError, model.simulate, parameters_3, times)
+
+        # Initial value can't be negative
+        self.assertRaises(ValueError, DegradationModel, -1)
 
 
 if __name__ == '__main__':
diff --git a/pints/toy/stochastic/__init__.py b/pints/toy/stochastic/__init__.py
index 9259fe154..a42910890 100644
--- a/pints/toy/stochastic/__init__.py
+++ b/pints/toy/stochastic/__init__.py
@@ -8,3 +8,4 @@
 #
 from ._markov_jump_model import MarkovJumpModel  # noqa
 from ._michaelis_menten_model import MichaelisMentenModel # noqa
+from ._degradation_model import DegradationModel # noqa
diff --git a/pints/toy/stochastic/_degradation_model.py b/pints/toy/stochastic/_degradation_model.py
new file mode 100644
index 000000000..6e3c648df
--- /dev/null
+++ b/pints/toy/stochastic/_degradation_model.py
@@ -0,0 +1,41 @@
+#
+# Stochastic degradation toy model.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from . import MarkovJumpModel
+
+
+class DegradationModel(MarkovJumpModel):
+    r"""
+    Stochastic degradation model of a single chemical reaction starting from
+    an initial molecule count :math:`A(0)` and degrading to 0 with a fixed rate
+    :math:`k`:
+
+    .. math::
+        A \xrightarrow{k} 0
+
+    Extends :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`.
+
+    Parameters
+    ----------
+    initial_molecule_count
+        The initial molecule count :math:`A(0)`.
+    """
+    def __init__(self, initial_molecule_count=20):
+        V = [[-1]]
+        init_list = [initial_molecule_count]
+        super(DegradationModel, self).__init__(init_list,
+                                               V, self._propensities)
+
+    @staticmethod
+    def _propensities(xs, ks):
+        return [
+            xs[0] * ks[0],
+        ]
+
+    def n_parameters(self):
+        """ See :meth:`pints.ForwardModel.n_parameters()`. """
+        return 1
diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py
index d67cd1b0d..973911e7c 100644
--- a/pints/toy/stochastic/_markov_jump_model.py
+++ b/pints/toy/stochastic/_markov_jump_model.py
@@ -85,6 +85,10 @@ def simulate_raw(self, rates, max_time):
         """
         Returns raw times, mol counts when reactions occur
         """
+        if len(rates) != self.n_parameters():
+            raise ValueError('This model should have only ',
+                             str(self.n_parameters()),
+                             ' parameter(s).')
         # Setting the current propensities and summing them up
         current_propensities = self._propensities(self._x0, rates)
         prop_sum = sum(current_propensities)
@@ -135,6 +139,8 @@ def simulate(self, parameters, times):
         times = np.asarray(times)
         if np.any(times < 0):
             raise ValueError('Negative times are not allowed.')
+        if np.all(self._x0 == 0):
+            return np.zeros(times.shape)
         # Run Gillespie
         time, mol_count = self.simulate_raw(parameters, max(times))
         # Interpolate

From 52835a36c994754d8b8a7238c42563277b8c3078 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sun, 21 Nov 2021 22:35:15 +0000
Subject: [PATCH 08/25] small fixes

---
 examples/README.md                             | 1 +
 pints/tests/test_toy_michaelis_menten_model.py | 6 ++----
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index ee17072f1..11d362420 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -118,6 +118,7 @@ relevant code.
 - [Stochastic Degradation model](./toy/model-stochastic-degradation.ipynb)
 - [Stochastic Logistic model](./toy/model-stochastic-logistic-growth.ipynb)
 - [Michaelis Menten model](./toy/model-michaelis-menten.ipynb)
+- [Degradation model](./toy/model-degradation.ipynb)
 
 ### Distributions
 - [Annulus](./toy/distribution-annulus.ipynb)
diff --git a/pints/tests/test_toy_michaelis_menten_model.py b/pints/tests/test_toy_michaelis_menten_model.py
index 1274121e9..7667438f0 100644
--- a/pints/tests/test_toy_michaelis_menten_model.py
+++ b/pints/tests/test_toy_michaelis_menten_model.py
@@ -8,9 +8,7 @@
 #
 import unittest
 import numpy as np
-import pints
-import pints.toy
-from pints.toy import MichaelisMentenModel
+from pints.toy.stochastic import MichaelisMentenModel
 
 
 class TestMichaelisMentenModel(unittest.TestCase):
@@ -33,7 +31,7 @@ def test_simulation_length(self):
     def test_propensities(self):
         x_0 = [1e4, 2e3, 2e4, 0]
         k = [1e-5, 0.2, 0.2]
-        model = pints.toy.stochastic.MichaelisMentenModel(x_0)
+        model = MichaelisMentenModel(x_0)
         self.assertTrue(
             np.allclose(
                 model._propensities(x_0, k),

From 50984002af4f382f892923b6ad93f217f1236da3 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sun, 21 Nov 2021 22:42:26 +0000
Subject: [PATCH 09/25] small test fix

---
 pints/tests/test_toy_michaelis_menten_model.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pints/tests/test_toy_michaelis_menten_model.py b/pints/tests/test_toy_michaelis_menten_model.py
index 7667438f0..35a6e6493 100644
--- a/pints/tests/test_toy_michaelis_menten_model.py
+++ b/pints/tests/test_toy_michaelis_menten_model.py
@@ -18,7 +18,7 @@ class TestMichaelisMentenModel(unittest.TestCase):
     def test_n_parameters(self):
         x_0 = [1e4, 2e3, 2e4, 0]
         model = MichaelisMentenModel(x_0)
-        self.assertEqual(model.n_parameters, 3)
+        self.assertEqual(model.n_parameters(), 3)
 
     def test_simulation_length(self):
         x_0 = [1e4, 2e3, 2e4, 0]

From cfc6c2b42f8cbdaa568b6c6cd4cad9440f787778 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Sun, 21 Nov 2021 23:07:54 +0000
Subject: [PATCH 10/25] moved n_parameters to markovjumpmodel

---
 pints/toy/stochastic/_degradation_model.py      | 4 ----
 pints/toy/stochastic/_michaelis_menten_model.py | 4 ----
 2 files changed, 8 deletions(-)

diff --git a/pints/toy/stochastic/_degradation_model.py b/pints/toy/stochastic/_degradation_model.py
index 6e3c648df..34555f2bd 100644
--- a/pints/toy/stochastic/_degradation_model.py
+++ b/pints/toy/stochastic/_degradation_model.py
@@ -35,7 +35,3 @@ def _propensities(xs, ks):
         return [
             xs[0] * ks[0],
         ]
-
-    def n_parameters(self):
-        """ See :meth:`pints.ForwardModel.n_parameters()`. """
-        return 1
diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py
index c9b3c85f8..ffff14205 100644
--- a/pints/toy/stochastic/_michaelis_menten_model.py
+++ b/pints/toy/stochastic/_michaelis_menten_model.py
@@ -42,7 +42,3 @@ def _propensities(xs, ks):
             xs[2] * ks[1],
             xs[2] * ks[2]
         ]
-
-    def n_parameters(self):
-        """ See :meth:`pints.ForwardModel.n_parameters()`. """
-        return 3

From 6d3b874fe18f073fdf2b1e11d7a8513b29a810fb Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 18:42:48 +0000
Subject: [PATCH 11/25] partial change(for testing docs)

---
 docs/source/toy/stochastic/index.rst               | 14 ++++++++++++++
 docs/source/toy/stochastic/markov_jump_model.rst   |  7 +++++++
 .../stochastic/stochastic_degradation_model.rst    |  7 +++++++
 docs/source/toy/stochastic_degradation_model.rst   |  2 +-
 4 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 docs/source/toy/stochastic/index.rst
 create mode 100644 docs/source/toy/stochastic/markov_jump_model.rst
 create mode 100644 docs/source/toy/stochastic/stochastic_degradation_model.rst

diff --git a/docs/source/toy/stochastic/index.rst b/docs/source/toy/stochastic/index.rst
new file mode 100644
index 000000000..4c31a27f4
--- /dev/null
+++ b/docs/source/toy/stochastic/index.rst
@@ -0,0 +1,14 @@
+***********************
+Stochastic Toy Problems
+***********************
+
+The `stochastic` module provides toy :class:`models<pints.toy.stochastic.MarkovJumpModel>`,
+:class:`distributions<pints.LogPrior>` and
+:class:`error measures<pints.ErrorMeasure>` that can be used for tests and in
+examples.
+
+
+.. toctree::
+
+    markov_jump_model
+    stochastic_degradation_model
diff --git a/docs/source/toy/stochastic/markov_jump_model.rst b/docs/source/toy/stochastic/markov_jump_model.rst
new file mode 100644
index 000000000..c7d2f0e37
--- /dev/null
+++ b/docs/source/toy/stochastic/markov_jump_model.rst
@@ -0,0 +1,7 @@
+*****************
+Markov Jump Model
+*****************
+
+.. currentmodule:: pints.toy.stochastic
+
+.. autoclass:: MarkovJumpModel
diff --git a/docs/source/toy/stochastic/stochastic_degradation_model.rst b/docs/source/toy/stochastic/stochastic_degradation_model.rst
new file mode 100644
index 000000000..b493e7b62
--- /dev/null
+++ b/docs/source/toy/stochastic/stochastic_degradation_model.rst
@@ -0,0 +1,7 @@
+****************************
+Stochastic degradation model
+****************************
+
+.. currentmodule:: pints.toy.stochastic
+
+.. autoclass:: DegradationModel
diff --git a/docs/source/toy/stochastic_degradation_model.rst b/docs/source/toy/stochastic_degradation_model.rst
index 048613ed6..8cc0edcf6 100644
--- a/docs/source/toy/stochastic_degradation_model.rst
+++ b/docs/source/toy/stochastic_degradation_model.rst
@@ -4,4 +4,4 @@ Stochastic degradation model
 
 .. currentmodule:: pints.toy
 
-.. autoclass:: StochasticDegradationModel
+.. autoclass:: pints.toy.stochastic.DegradationModel

From acc6b9d666efc6f35d3b8ba65fdabd3ec4c412b9 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 18:46:24 +0000
Subject: [PATCH 12/25] fix 1

---
 examples/README.md                            |   3 +-
 examples/toy/model-degradation.ipynb          | 131 -------------
 .../toy/model-stochastic-degradation.ipynb    |  32 ++--
 ...> model-stochastic-michaelis-menten.ipynb} |   0
 pints/tests/test_toy_degradation_model.py     |  42 ----
 .../test_toy_stochastic_degradation_model.py  |  90 +++------
 ..._toy_stochastic_michaelis_menten_model.py} |   0
 pints/toy/__init__.py                         |   3 +-
 pints/toy/_stochastic_degradation_model.py    | 181 ------------------
 pints/toy/stochastic/_degradation_model.py    |  50 +++++
 10 files changed, 96 insertions(+), 436 deletions(-)
 delete mode 100644 examples/toy/model-degradation.ipynb
 rename examples/toy/{model-michaelis-menten.ipynb => model-stochastic-michaelis-menten.ipynb} (100%)
 delete mode 100644 pints/tests/test_toy_degradation_model.py
 rename pints/tests/{test_toy_michaelis_menten_model.py => test_toy_stochastic_michaelis_menten_model.py} (100%)
 delete mode 100644 pints/toy/_stochastic_degradation_model.py

diff --git a/examples/README.md b/examples/README.md
index 11d362420..4d475b390 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -117,8 +117,7 @@ relevant code.
 - [SIR Epidemiology model](./toy/model-sir.ipynb)
 - [Stochastic Degradation model](./toy/model-stochastic-degradation.ipynb)
 - [Stochastic Logistic model](./toy/model-stochastic-logistic-growth.ipynb)
-- [Michaelis Menten model](./toy/model-michaelis-menten.ipynb)
-- [Degradation model](./toy/model-degradation.ipynb)
+- [Michaelis Menten model](./toy/model-stochastic-michaelis-menten.ipynb)
 
 ### Distributions
 - [Annulus](./toy/distribution-annulus.ipynb)
diff --git a/examples/toy/model-degradation.ipynb b/examples/toy/model-degradation.ipynb
deleted file mode 100644
index ffc4d623f..000000000
--- a/examples/toy/model-degradation.ipynb
+++ /dev/null
@@ -1,131 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Degradation model\n",
-    "\n",
-    "This example shows how the degradation model can be used.\n",
-    "This model describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react.\n",
-    "The substance degrades starting from an initial concentration, $n_0$, to 0 following a rate constant, $k$, according to the following model ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n",
-    "   $$A \\xrightarrow{\\text{k}} \\emptyset$$\n",
-    "\n",
-    "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "import pints\n",
-    "import pints.toy.stochastic"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Specify the initial concentration, and select time points at which to record concentration values, and rate constant value (k):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "n_0 = 20\n",
-    "model = pints.toy.stochastic.DegradationModel(n_0)\n",
-    "\n",
-    "times = np.linspace(0, 100, 100)\n",
-    "k = [0.1]\n",
-    "\n",
-    "values = model.simulate(k, times)\n",
-    "\n",
-    "plt.step(times, values)\n",
-    "plt.xlabel('time')\n",
-    "plt.ylabel('concentration (A(t))')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for i in range(10):\n",
-    "    values = model.simulate(k, times)\n",
-    "    plt.step(times, values)\n",
-    "    \n",
-    "plt.title('stochastic degradation across different iterations')\n",
-    "plt.xlabel('time')\n",
-    "plt.ylabel('concentration (A(t))')\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "interpreter": {
-   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
-  },
-  "kernelspec": {
-   "display_name": "Python 3.8.0 32-bit",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.0"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/toy/model-stochastic-degradation.ipynb b/examples/toy/model-stochastic-degradation.ipynb
index 3b1aab2d4..d26577819 100644
--- a/examples/toy/model-stochastic-degradation.ipynb
+++ b/examples/toy/model-stochastic-degradation.ipynb
@@ -4,20 +4,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Stochastic degradation model\n",
+    "# Stochastic Degradation model\n",
     "\n",
     "This example shows how the stochastic degradation model can be used.\n",
     "This model describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react.\n",
     "The substance degrades starting from an initial concentration, $n_0$, to 0 following a rate constant, $k$, according to the following model ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n",
     "   $$A \\xrightarrow{\\text{k}} \\emptyset$$\n",
     "\n",
-    "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)\n",
-    "   1. Sample a random value $r$ from a uniform distribution: $r \\sim \\text{uniform}(0,1)$\n",
-    "   2. Calculate the time ($\\tau$) until the next single reaction as follows (Erban et al., 2007):\n",
-    "   $$ \\tau = \\frac{1}{A(t)k} \\ln{\\big[\\frac{1}{r}\\big]} $$\n",
-    "   3. Update the molecule count at time t + $\\tau$ as: $ A(t + \\tau) = A(t) - 1 $\n",
-    "   4. Return to step (1) until molecule count reaches zero.\n",
-    "   "
+    "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)."
    ]
   },
   {
@@ -46,7 +40,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZ1klEQVR4nO3de7SddX3n8fcHBC94ASRSCMRQRTvRpdGechltB0EpMNhYlwpBFG8T72KXbRfWWVK1dnSs2jqokEIUZwTxhqKCmqGsQSuiAZFLUEEUSYwkXiDxUjXynT/2c3BzeHbOzsnZe5/s836ttdd+nt9z++71wPnmeX63VBWSJE21y6gDkCTNTSYISVIrE4QkqZUJQpLUygQhSWp1n1EHMJv22WefWrx48ajDkKSdxlVXXfXjqlrQtm2sEsTixYtZs2bNqMOQpJ1Gklt7bfMVkySplQlCktTKBCFJamWCkCS1MkFIkloNLEEkOTDJZUnWJrkhyalN+d5JVie5qfneq8fxpzT73JTklEHFKUlqN8gniK3A66pqCXAY8MokS4DTgEur6mDg0mb9HpLsDZwOHAocApzeK5FIkgZjYAmiqjZU1dXN8hbgRmAhsAw4t9ntXOAZLYf/ObC6qn5aVT8DVgPHDCrWN33mBt70mRsGdXpJ2ikNpaNcksXAE4ArgX2rakOz6UfAvi2HLARu61pf15S1nXsFsAJg0aJFM4pv7Q83z+g4SRpnA6+kTvJA4BPAa6vqHn+JqzNb0Q7NWFRVK6tqoqomFixo7S0uSZqBgSaIJLvRSQ4frqpPNsW3J9mv2b4fsLHl0PXAgV3rBzRlkqQhGWQrpgDnADdW1bu6Nl0ETLZKOgX4dMvhXwCOTrJXUzl9dFMmSRqSQT5BPAl4HnBkkmuaz3HA24CnJbkJeGqzTpKJJGcDVNVPgbcAX28+b27KJElDMrBK6qr6MpAem49q2X8N8JKu9VXAqsFEJ0majj2pJUmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWg1swqAkq4DjgY1V9dim7ALg0c0uewJ3VNXSlmO/D2wBfgdsraqJQcUpSWo3sAQBfBA4A/jQZEFVnTC5nOSdwJ3bOP4pVfXjgUUnSdqmQU45enmSxW3bkgR4DnDkoK4vSdoxo6qD+FPg9qq6qcf2Ar6Y5KokK7Z1oiQrkqxJsmbTpk2zHqgkzVejShDLgfO3sf3JVfVE4FjglUn+rNeOVbWyqiaqamLBggWzHackzVtDTxBJ7gM8E7ig1z5Vtb753ghcCBwynOgkSZNG8QTxVOBbVbWubWOSPZI8aHIZOBq4fojxSZIYbDPX84EjgH2SrANOr6pzgBOZ8nopyf7A2VV1HLAvcGGnHpv7AOdV1ecHFeektRs2c8JZV9yrfNnShZx06KJBX16S5pxBtmJa3qP8BS1lPwSOa5ZvAR4/qLjaLFu6sLV87YbNACYISfPSIPtB7DROOnRRaxJoe6KQpPnCoTYkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktTJBSJJamSAkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktRpYgkiyKsnGJNd3lf19kvVJrmk+x/U49pgk305yc5LTBhWjJKm3QT5BfBA4pqX83VW1tPlcPHVjkl2B9wLHAkuA5UmWDDBOSVKLQU45enmSxTM49BDg5mbqUZJ8BFgGrJ3F8PrWPVe181NLmk9GUQfxqiTXNq+g9mrZvhC4rWt9XVPWKsmKJGuSrNm0adOsBrps6UKW7PdgoJMoPn3N+lk9vyTNZcNOEO8HHgEsBTYA79zRE1bVyqqaqKqJBQsW7Ojp7uGkQxdxwUsP54KXHn53opCk+WLaV0xJ7gccD/wpsD/wK+B64HNVdcP2XKyqbu86778Cn23ZbT1wYNf6AU2ZJGmItvkEkeRNwL8DhwNXAmcBHwW2Am9LsjrJ4/q9WJL9ulb/kk6imerrwMFJDkqyO3AicFG/15AkzY7pniC+VlWn99j2riQPA1prbZOcDxwB7JNkHXA6cESSpUAB3wde2uy7P3B2VR1XVVuTvAr4ArArsGp7n1QkSTtumwmiqj43zfaNwMYe25a3FJ/TY98fAsd1rV8M3KsJrCRpePqpgzgAWA48mSl1EMAlVXXXQCOUJI3ENhNEkg/QaWL6WeDtdJ4W7gc8ik4nuDckOa2qLh90oJKk4ZruCeKdVdVWkXw98MmmEtmeY5I0hrbZimkyOSQ5deq2JKdW1W+q6uZBBTfXTPaqPuGsKzjvyh+MOhxJGqh+O8qd0lL2glmMY86zV7Wk+Wa6OojlwEnAQUm6+yI8CPjpIAOba046dNHd4zBNjs0kSeNsujqIr9AZEmMf7jksxhbg2kEFJUkavekSxA+q6lY6PalbJUlV1eyGJUkatenqIC5L8uok92iplGT3JEcmOZf2+glJ0k5uuieIY4AXAecnOQi4A7g/ncTyReCfq+obA41QkjQS0w218R/A+4D3JdmNTl3Er6rqjiHEJkkaob7ng6iq31bVBuC3SU5Oss1xmiRJO7e+EkRT5/CXST5Gp1XTUcCZA41MkjRS0/WDOJrOQH1HA5cBHwL+pKpeOITYJEkjNN0TxOeBPwSeXFUnV9VnAEdvlaR5YLoE8UTgCuD/NrPHvZjOJD7TSrIqycYk13eVvSPJt5Jcm+TCJHv2OPb7Sa5Lck2SNX3+FknSLJpusL5rquq0qnoEnRnhlgK7JbkkyYppzv1BOs1ku60GHltVjwO+A7x+G8c/paqWVtXENNeRJA3A9rRi+kpVvRo4AHg3cNg0+1/OlPGaquqLVbW1Wf1qcy5J0hy0zQSRZPHUsqq6q/lD/6J0zPSP/IuAS3psK+CLSa6a7kklyYoka5Ks2bRp0wxDkSRNNV1P6nck2QX4NHAVsInOjHKPBI4Ankrn1dO67blokjcAW4EP99jlyVW1PsnDgNVJvtVr1rqqWgmsBJiYmHBMKEmaJdP1pH52kiXAc+n8i38/4JfAjcDFwD82va37luQFwPHAUb0G+auq9c33xiQXAocATmsqSUM03RMEVbUWeMNsXCzJMcDfAv+lqn7ZY589gF2qakuzfDTw5tm4viSpf31XUm+vJOfTaSL76CTrmiayZ9CZbGh104T1zGbf/ZNc3By6L/DlJN8EvgZ8rqo+P6g4JUntpn2CmKmqWt5SfE6PfX8IHNcs3wI8flBxSZL6M7AnCEnSzq3vJ4gkC4GHdx/Tq2WRJGnn11eCSPJ24ARgLfC7priwZZEkja1+nyCeATy6qn49wFgkSXNIv3UQtwC7DTIQSdLc0u8TxC+Ba5JcCtz9FFFVrxlIVJKkkes3QVzUfCRJ80RfCaKqzk2yO/CopujbVfXbwYUlSRq1flsxHQGcC3wfCHBgklPmczPXtRs2c8JZVwCwbOlCTjp00YgjkqTZ1e8rpncCR1fVtwGSPAo4H/jjQQU2ly1buvDu5bUbNgOYICSNnX4TxG6TyQGgqr6TZN62ajrp0EV3J4TJpwhJGjf9Jog1Sc4G/k+z/lzAuaIlaYz1myBeDrwSmGzW+iXgfQOJSJI0J/TbiunXwLuajyRpHthmgkjy0ap6TpLr6Iy9dA9V9biBRSZJGqnpniBObb6PH3QgkqS5ZZtjMVXVhmbxFVV1a/cHeMV0J0+yKsnGJNd3le2dZHWSm5rvvXoce0qzz01JTtmeHyVJ2nH9Dtb3tJayY/s47oPAMVPKTgMuraqDgUub9XtIsjdwOnAocAhweq9EIkkajG0miCQvb+ofHp3k2q7P94Brpzt509P6p1OKl9HplU3z/YyWQ/8cWF1VP62qnwGruXeimTMme1WfcNYVnHflD0YdjiTNiunqIM4DLgH+B/f8l/6Wqpr6h79f+3a9uvoRsG/LPguB27rW1zVl95JkBbACYNGi4fdmtle1pHG1zQRRVXcCdwLLAZI8DLgf8MAkD6yqHfrnclVVknu1jtrOc6wEVgJMTEzs0Llmwl7VksZVX3UQSZ6e5Cbge8D/ozNo3yUzvObtSfZrzrsfsLFln/XAgV3rBzRlkqQh6beS+h+Aw4DvVNVBwFHAV2d4zYuAyVZJpwCfbtnnC8DRSfZqKqePbsokSUPSb4L4bVX9BNglyS5VdRkwMd1BSc4HrqBTyb0uyYuBtwFPa55Intqsk2SiGe+Jpn7jLcDXm8+bd6DOQ5I0A/2OxXRHkgcClwMfTrIR+MV0B1XV8h6bjmrZdw3wkq71VcCqPuOTJM2yfp8gltGZl/qvgM8D3wWePqigJEmjN+0TRJJdgc9W1VOAu/h9HwZJ0hib9gmiqn4H3JXkIUOIR5I0R/RbB/Fz4Lokq+mqe6iq1/Q+ZH7qnqu6m/NWS9rZ9JsgPtl8ug29U9pc192rups9rCXtjPpNEHtW1b90FyQ5tdfO81V3r+pu9rCWtDPqtxVT23DbL5jFOCRJc8x0M8otB04CDkpyUdemB3HvUVolSWNkuldMXwE2APsA7+wq30Ifw31LknZe043meitwK3D4cMKRJM0V/Y7m+sxm6s87k2xOsiXJ5kEHJ0kanX5bMf1P4OlVdeMgg5EkzR39tmK63eQgSfNLv08Qa5JcAHwK+PVkYVVN7TynHnr1sAZ7WUuam/pNEA+mM5rr0V1lxb17V6tFrx7WYC9rSXNXXwmiql446EDGWa8e1mAva0lzV7+tmB6V5NIk1zfrj0vy32dywSSPTnJN12dzktdO2eeIpsXU5D5vnMm1JEkz1+8rpn8F/gY4C6Cqrk1yHp25qrdLVX0bWAp3zzWxHriwZdcvVdXx23t+SdLs6LcV0wOq6mtTyrbOwvWPAr7bdMiTJM0h/SaIHyd5BM0Q30meRWcIjh11InB+j22HJ/lmkkuSPKbXCZKsSLImyZpNmzbNQkiSJOj/FdMrgZXAHyVZD3wPOHlHLpxkd+AvgNe3bL4aeHhV/TzJcXSa1x7cdp6qWtnExsTEhHNUSNIs6bcV0y3AU5PsAexSVVtm4drHAldX1e0t19vctXxxkvcl2aeqfjwL15Uk9aHfVkz/mGTPqvpFVW1JsleS7a6gnmI5PV4vJfmDJGmWD2ni/MkOXk+StB36rYM4tqrumFypqp8Bx830os2TyNPo6miX5GVJXtasPgu4Psk3gfcAJ1aVr48kaYj6rYPYNcl9q+rXAEnuD9x3phetql8AD51SdmbX8hnAGTM9vyRpx/WbID4MXJrkA836C4FzBxOSJGku6LeS+u1JrqXTbwHgLVX1hcGFJUkatX6fIKiqS4BLBhiLJGkOcUY5SVIrZ5STJLVyRjlJUitnlJMktXJGOUlSK2eUmwO2NV/1JOetljRs/bZiOiDJhUk2Np9PJDlg0MHNB8uWLmTJfg/e5j5rN2zm09esH1JEktTR7yumDwDnAc9u1k9uyp42iKDmk23NVz3JeasljUK/rZgWVNUHqmpr8/kgsGCAcUmSRqzfBPGTJCcn2bX5nIzDb0vSWOs3QbwIeA7wIzpTjT6LzoB9kqQx1W8rplvpTA8qSZon+m3FdG6SPbvW90qyakcunOT7Sa5Lck2SNS3bk+Q9SW5Ocm2SJ+7I9SRJ26ffVkyPmzqjXJInzML1n7KNeaaPBQ5uPocC72++JUlD0G+C2CXJXs1UoyTZezuOnallwIeaqUa/mmTPJPtV1YYBX3dO6qcz3aDYSU+an/r9I/9O4IokH2vWnw28dQevXcAXkxRwVlWtnLJ9IXBb1/q6puweCSLJCmAFwKJF4/lHbNnShSO79toNnVHdTRDS/NNvJfWHmnqCI5uiZ1bV2h289pOran2ShwGrk3yrqi7f3pM0iWUlwMTERO1gTHNSP53pBsVOetL8tT0zyq0FdjQpdJ9vffO9McmFwCFAd4JYDxzYtX5AUyZJGoJ++0HMqiR7JHnQ5DKdUWKvn7LbRcDzm9ZMhwF3ztf6B0kahUFXNPeyL3BhkskYzquqzyd5GUBVnQlcDBwH3ExnqHE75knSEI0kQVTVLcDjW8rP7Fou4JXDjEuS9HsjecUkSZr7TBCSpFYmCElSq1FVUmsn0qsXtz2spfFmgtA29erFbQ9rafyZILRNvXpx28NaGn/WQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZT8Izdio5sm2B7c0HCYIzcio5sm2B7c0PCYIzcio5sm2B7c0PEOvg0hyYJLLkqxNckOSU1v2OSLJnUmuaT5vHHackjTfjeIJYivwuqq6upmX+qokq6tq7ZT9vlRVx48gPkkSI3iCqKoNVXV1s7wFuBEYzQttSVJPI23mmmQx8ATgypbNhyf5ZpJLkjxmG+dYkWRNkjWbNm0aVKiSNO+MLEEkeSDwCeC1VbV5yuargYdX1eOB/wV8qtd5qmplVU1U1cSCBQsGFq8kzTcjSRBJdqOTHD5cVZ+cur2qNlfVz5vli4Hdkuwz5DAlaV4bRSumAOcAN1bVu3rs8wfNfiQ5hE6cPxlelJKkUbRiehLwPOC6JNc0ZX8HLAKoqjOBZwEvT7IV+BVwYlXVCGLVHDSTHtz2vpa239ATRFV9Gcg0+5wBnDGciLQzmUkPbntfSzNjT2rtVGbSg9ve19LMOJqrJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFb2g9C80E/va3tbS/dkgtDY66f3tb2tpXszQWjs9dP72t7W0r1ZByFJamWCkCS1MkFIklqZICRJrUwQkqRWo5qT+pgk305yc5LTWrbfN8kFzfYrkyweQZiSNK+NYk7qXYH3AscCS4DlSZZM2e3FwM+q6pHAu4G3DzdKSdIo+kEcAtxcVbcAJPkIsAxY27XPMuDvm+WPA2ckifNSa5BmMte1NBcs2f/BnP70x8z6eUeRIBYCt3WtrwMO7bVPVW1NcifwUODHU0+WZAWwAmDRInvBamZmMte1NO52+p7UVbUSWAkwMTHhE4ZmZCZzXUvjbhSV1OuBA7vWD2jKWvdJch/gIcBPhhKdJAkYTYL4OnBwkoOS7A6cCFw0ZZ+LgFOa5WcB/2b9gyQN19BfMTV1Cq8CvgDsCqyqqhuSvBlYU1UXAecA/zvJzcBP6SQRSdIQjaQOoqouBi6eUvbGruX/AJ497LgkSb9nT2pJUisThCSplQlCktTKBCFJapVxaj2aZBNw6wwP34eWntpjzt88/ubb7wV/8/Z6eFUtaNswVgliRyRZU1UTo45jmPzN42++/V7wN88mXzFJklqZICRJrUwQv7dy1AGMgL95/M233wv+5lljHYQkqZVPEJKkViYISVKreZ8gkhyT5NtJbk5y2qjjGYQkBya5LMnaJDckObUp3zvJ6iQ3Nd97jTrW2ZZk1yTfSPLZZv2gJFc29/uCZsj5sZFkzyQfT/KtJDcmOXzc73OSv2r+u74+yflJ7jdu9znJqiQbk1zfVdZ6X9Pxnua3X5vkiTO97rxOEEl2Bd4LHAssAZYnWTLaqAZiK/C6qloCHAa8svmdpwGXVtXBwKXN+rg5Fbixa/3twLur6pHAz4AXjySqwfkX4PNV9UfA4+n89rG9z0kWAq8BJqrqsXSmEDiR8bvPHwSOmVLW674eCxzcfFYA75/pRed1ggAOAW6uqluq6jfAR4BlI45p1lXVhqq6ulneQuePxkI6v/XcZrdzgWeMJMABSXIA8F+Bs5v1AEcCH292GavfnOQhwJ/RmU+FqvpNVd3BmN9nOtMW3L+ZffIBwAbG7D5X1eV05sbp1uu+LgM+VB1fBfZMst9MrjvfE8RC4Lau9XVN2dhKshh4AnAlsG9VbWg2/QjYd1RxDcg/A38L3NWsPxS4o6q2Nuvjdr8PAjYBH2heq52dZA/G+D5X1Xrgn4Af0EkMdwJXMd73eVKv+zprf9fme4KYV5I8EPgE8Nqq2ty9rZnSdWzaPCc5HthYVVeNOpYhug/wROD9VfUE4BdMeZ00hvd5Lzr/Yj4I2B/Yg3u/ihl7g7qv8z1BrAcO7Fo/oCkbO0l2o5McPlxVn2yKb5989Gy+N44qvgF4EvAXSb5P59XhkXTez+/ZvIqA8bvf64B1VXVls/5xOgljnO/zU4HvVdWmqvot8Ek6936c7/OkXvd11v6uzfcE8XXg4KbFw+50KrcuGnFMs655934OcGNVvatr00XAKc3yKcCnhx3boFTV66vqgKpaTOe+/ltVPRe4DHhWs9u4/eYfAbcleXRTdBSwljG+z3ReLR2W5AHNf+eTv3ls73OXXvf1IuD5TWumw4A7u15FbZd535M6yXF03lXvCqyqqreONqLZl+TJwJeA6/j9+/i/o1MP8VFgEZ1h0p9TVVMrwnZ6SY4A/rqqjk/yh3SeKPYGvgGcXFW/HmF4syrJUjqV8rsDtwAvpPMPwbG9z0neBJxAp7XeN4CX0HnnPjb3Ocn5wBF0hvW+HTgd+BQt97VJlGfQedX2S+CFVbVmRted7wlCktRuvr9ikiT1YIKQJLUyQUiSWpkgJEmtTBCSpFYmCGmGmpFTX9Es75/k49MdI+1MbOYqzVAzrtVnm1FEpbFzn+l3kdTD24BHJLkGuAn4T1X12CQvoDOy5h50hlz+Jzod154H/Bo4runQ9Ag6w80voNOh6b9V1beG/SOkXnzFJM3cacB3q2op8DdTtj0WeCbwJ8BbgV82A+hdATy/2Wcl8Oqq+mPgr4H3DSNoqV8+QUiDcVkz98aWJHcCn2nKrwMe14ys+5+Bj3VGRgDgvsMPU+rNBCENRve4P3d1rd9F5/+7XejMWbB0yHFJffMVkzRzW4AHzeTAZj6O7yV5Ntw9j/DjZzM4aUeZIKQZqqqfAP/eTCT/jhmc4rnAi5N8E7iBMZzuVjs3m7lKklr5BCFJamWCkCS1MkFIklqZICRJrUwQkqRWJghJUisThCSp1f8H7mxI0309ZmIAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -59,7 +53,7 @@
    ],
    "source": [
     "n_0 = 20\n",
-    "model = pints.toy.StochasticDegradationModel(n_0)\n",
+    "model = pints.toy.stochastic.DegradationModel(n_0)\n",
     "\n",
     "times = np.linspace(0, 100, 100)\n",
     "k = [0.1]\n",
@@ -86,7 +80,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -101,14 +95,10 @@
     "for i in range(10):\n",
     "    values = model.simulate(k, times)\n",
     "    plt.step(times, values)\n",
-    "\n",
-    "mean = model.mean(k, times)\n",
     "    \n",
-    "plt.plot(times, mean, label = 'deterministic mean of A(t)')\n",
     "plt.title('stochastic degradation across different iterations')\n",
     "plt.xlabel('time')\n",
     "plt.ylabel('concentration (A(t))')\n",
-    "plt.legend(loc = 'upper right')\n",
     "plt.show()"
    ]
   },
@@ -127,7 +117,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -154,8 +144,11 @@
   }
  ],
  "metadata": {
+  "interpreter": {
+   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
+  },
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3.8.0 32-bit",
    "language": "python",
    "name": "python3"
   },
@@ -169,8 +162,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.7"
-  }
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/examples/toy/model-michaelis-menten.ipynb b/examples/toy/model-stochastic-michaelis-menten.ipynb
similarity index 100%
rename from examples/toy/model-michaelis-menten.ipynb
rename to examples/toy/model-stochastic-michaelis-menten.ipynb
diff --git a/pints/tests/test_toy_degradation_model.py b/pints/tests/test_toy_degradation_model.py
deleted file mode 100644
index 7f73b602c..000000000
--- a/pints/tests/test_toy_degradation_model.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-#
-# Tests if the degradation (toy) model works.
-#
-# This file is part of PINTS (https://github.com/pints-team/pints/) which is
-# released under the BSD 3-clause license. See accompanying LICENSE.md for
-# copyright notice and full license details.
-#
-import unittest
-import numpy as np
-from pints.toy.stochastic import DegradationModel
-
-
-class TestDegradationModel(unittest.TestCase):
-    """
-    Tests if the degradation (toy) model works.
-    """
-    def test_n_parameters(self):
-        x_0 = 20
-        model = DegradationModel(x_0)
-        self.assertEqual(model.n_parameters(), 1)
-
-    def test_simulation_length(self):
-        x_0 = 20
-        model = DegradationModel(x_0)
-        times = np.linspace(0, 1, 100)
-        k = [0.1]
-        values = model.simulate(k, times)
-        self.assertEqual(len(values), 100)
-
-    def test_propensities(self):
-        x_0 = 20
-        k = [0.1]
-        model = DegradationModel(x_0)
-        self.assertTrue(
-            np.allclose(
-                model._propensities([x_0], k),
-                np.array([2.0])))
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py
index d5d34a5ba..55e3059a7 100755
--- a/pints/tests/test_toy_stochastic_degradation_model.py
+++ b/pints/tests/test_toy_stochastic_degradation_model.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Tests if the stochastic degradation (toy) model works.
+# Tests if the degradation (toy) model works.
 #
 # This file is part of PINTS (https://github.com/pints-team/pints/) which is
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
@@ -8,109 +8,81 @@
 #
 import unittest
 import numpy as np
-import pints
-import pints.toy
-from pints.toy import StochasticDegradationModel
+from pints.toy.stochastic import DegradationModel
 
 
-class TestStochasticDegradationModel(unittest.TestCase):
+class TestDegradationModel(unittest.TestCase):
     """
-    Tests if the stochastic degradation (toy) model works.
+    Tests if the degradation (toy) model works.
     """
-    def test_start_with_zero(self):
-        # Test the special case where the initial molecule count is zero
-        model = StochasticDegradationModel(0)
-        times = [0, 1, 2, 100, 1000]
-        parameters = [0.1]
-        values = model.simulate(parameters, times)
-        self.assertEqual(len(values), len(times))
-        self.assertTrue(np.all(values == np.zeros(5)))
-
-    def test_start_with_twenty(self):
-        # Run small simulation
-        model = pints.toy.StochasticDegradationModel(20)
-        times = [0, 1, 2, 100, 1000]
-        parameters = [0.1]
-        values = model.simulate(parameters, times)
-        self.assertEqual(len(values), len(times))
-        self.assertEqual(values[0], 20)
-        self.assertEqual(values[-1], 0)
-        self.assertTrue(np.all(values[1:] <= values[:-1]))
+    def test_n_parameters(self):
+        x_0 = 20
+        model = DegradationModel(x_0)
+        self.assertEqual(model.n_parameters(), 1)
+
+    def test_simulation_length(self):
+        x_0 = 20
+        model = DegradationModel(x_0)
+        times = np.linspace(0, 1, 100)
+        k = [0.1]
+        values = model.simulate(k, times)
+        self.assertEqual(len(values), 100)
+
+    def test_propensities(self):
+        x_0 = 20
+        k = [0.1]
+        model = DegradationModel(x_0)
+        self.assertTrue(
+            np.allclose(
+                model._propensities([x_0], k),
+                np.array([2.0])))
 
     def test_suggested(self):
-        model = pints.toy.StochasticDegradationModel(20)
+        model = DegradationModel(20)
         times = model.suggested_times()
         parameters = model.suggested_parameters()
         self.assertTrue(len(times) == 101)
         self.assertTrue(parameters > 0)
 
-    def test_simulate(self):
-        times = np.linspace(0, 100, 101)
-        model = StochasticDegradationModel(20)
-        time, mol_count = model.simulate_raw([0.1])
-        values = model.interpolate_mol_counts(time, mol_count, times)
-        self.assertTrue(len(time), len(mol_count))
-        # Test output of Gillespie algorithm
-        self.assertTrue(np.all(mol_count == np.array(range(20, -1, -1))))
-
-        # Check simulate function returns expected values
-        self.assertTrue(np.all(values[np.where(times < time[1])] == 20))
-
-        # Check interpolation function works as expected
-        temp_time = np.array([np.random.uniform(time[0], time[1])])
-        self.assertEqual(
-            model.interpolate_mol_counts(time, mol_count, temp_time)[0],
-            20)
-        temp_time = np.array([np.random.uniform(time[1], time[2])])
-        self.assertEqual(
-            model.interpolate_mol_counts(time, mol_count, temp_time)[0],
-            19)
-
     def test_mean_variance(self):
         # test mean
-        model = pints.toy.StochasticDegradationModel(10)
+        model = DegradationModel(10)
         v_mean = model.mean([1], [5, 10])
         self.assertEqual(v_mean[0], 10 * np.exp(-5))
         self.assertEqual(v_mean[1], 10 * np.exp(-10))
 
-        model = pints.toy.StochasticDegradationModel(20)
+        model = DegradationModel(20)
         v_mean = model.mean([5], [7.2])
         self.assertEqual(v_mean[0], 20 * np.exp(-7.2 * 5))
 
         # test variance
-        model = pints.toy.StochasticDegradationModel(10)
+        model = DegradationModel(10)
         v_var = model.variance([1], [5, 10])
         self.assertEqual(v_var[0], 10 * (np.exp(5) - 1.0) / np.exp(10))
         self.assertAlmostEqual(v_var[1], 10 * (np.exp(10) - 1.0) / np.exp(20))
 
-        model = pints.toy.StochasticDegradationModel(20)
+        model = DegradationModel(20)
         v_var = model.variance([2.0], [2.0])
         self.assertAlmostEqual(v_var[0], 20 * (np.exp(4) - 1.0) / np.exp(8))
 
     def test_errors(self):
-        model = pints.toy.StochasticDegradationModel(20)
+        model = DegradationModel(20)
         # parameters, times cannot be negative
         times = np.linspace(0, 100, 101)
         parameters = [-0.1]
-        self.assertRaises(ValueError, model.simulate, parameters, times)
         self.assertRaises(ValueError, model.mean, parameters, times)
         self.assertRaises(ValueError, model.variance, parameters, times)
 
         times_2 = np.linspace(-10, 10, 21)
         parameters_2 = [0.1]
-        self.assertRaises(ValueError, model.simulate, parameters_2, times_2)
         self.assertRaises(ValueError, model.mean, parameters_2, times_2)
         self.assertRaises(ValueError, model.variance, parameters_2, times_2)
 
         # this model should have 1 parameter
         parameters_3 = [0.1, 1]
-        self.assertRaises(ValueError, model.simulate, parameters_3, times)
         self.assertRaises(ValueError, model.mean, parameters_3, times)
         self.assertRaises(ValueError, model.variance, parameters_3, times)
 
-        # Initial value can't be negative
-        self.assertRaises(ValueError, pints.toy.StochasticDegradationModel, -1)
-
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/pints/tests/test_toy_michaelis_menten_model.py b/pints/tests/test_toy_stochastic_michaelis_menten_model.py
similarity index 100%
rename from pints/tests/test_toy_michaelis_menten_model.py
rename to pints/tests/test_toy_stochastic_michaelis_menten_model.py
diff --git a/pints/toy/__init__.py b/pints/toy/__init__.py
index 7181d9129..efeb66181 100644
--- a/pints/toy/__init__.py
+++ b/pints/toy/__init__.py
@@ -32,5 +32,4 @@
 from ._simple_egg_box import SimpleEggBoxLogPDF
 from ._sir_model import SIRModel
 from ._twisted_gaussian_banana import TwistedGaussianLogPDF
-from ._stochastic_degradation_model import StochasticDegradationModel
-from ._stochastic_logistic_model import StochasticLogisticModel
+from .stochastic import *
\ No newline at end of file
diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py
deleted file mode 100644
index b8bd2f7d6..000000000
--- a/pints/toy/_stochastic_degradation_model.py
+++ /dev/null
@@ -1,181 +0,0 @@
-#
-# Stochastic degradation toy model.
-#
-# This file is part of PINTS (https://github.com/pints-team/pints/) which is
-# released under the BSD 3-clause license. See accompanying LICENSE.md for
-# copyright notice and full license details.
-#
-import numpy as np
-from scipy.interpolate import interp1d
-import pints
-
-from . import ToyModel
-
-
-class StochasticDegradationModel(pints.ForwardModel, ToyModel):
-    r"""
-    Stochastic degradation model of a single chemical reaction starting from
-    an initial molecule count :math:`A(0)` and degrading to 0 with a fixed rate
-    :math:`k`:
-
-    .. math::
-        A \xrightarrow{k} 0
-
-    Simulations are performed using Gillespie's algorithm [1]_, [2]_:
-
-    1. Sample a random value :math:`r` from a uniform distribution
-
-    .. math::
-        r \sim U(0,1)
-
-    2. Calculate the time :math:`\tau` until the next single reaction as
-
-    .. math::
-        \tau = \frac{-\ln(r)}{A(t) k}
-
-    3. Update the molecule count :math:`A` at time :math:`t + \tau` as:
-
-    .. math::
-        A(t + \tau) = A(t) - 1
-
-    4. Return to step (1) until the molecule count reaches 0
-
-    The model has one parameter, the rate constant :math:`k`.
-
-    Extends :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`.
-
-    Parameters
-    ----------
-    initial_molecule_count
-        The initial molecule count :math:`A(0)`.
-
-    References
-    ----------
-    .. [1] A Practical Guide to Stochastic Simulations of Reaction Diffusion
-           Processes. Erban, Chapman, Maini (2007).
-           arXiv:0704.1908v2 [q-bio.SC]
-           https://arxiv.org/abs/0704.1908
-
-    .. [2] A general method for numerically simulating the stochastic time
-           evolution of coupled chemical reactions. Gillespie (1976).
-           Journal of Computational Physics
-           https://doi.org/10.1016/0021-9991(76)90041-3
-    """
-    def __init__(self, initial_molecule_count=20):
-        super(StochasticDegradationModel, self).__init__()
-        self._n0 = float(initial_molecule_count)
-        if self._n0 < 0:
-            raise ValueError('Initial molecule count cannot be negative.')
-
-    def n_parameters(self):
-        """ See :meth:`pints.ForwardModel.n_parameters()`. """
-        return 1
-
-    def simulate_raw(self, parameters):
-        """
-        Returns raw times, mol counts when reactions occur
-        """
-        parameters = np.asarray(parameters)
-        if len(parameters) != self.n_parameters():
-            raise ValueError('This model should have only 1 parameter.')
-        k = parameters[0]
-
-        if k <= 0:
-            raise ValueError('Rate constant must be positive.')
-
-        # Initial time and count
-        t = 0
-        a = self._n0
-
-        # Run stochastic degradation algorithm, calculating time until next
-        # reaction and decreasing molecule count by 1 at that time
-        mol_count = [a]
-        time = [t]
-        while a > 0:
-            r = np.random.uniform(0, 1)
-            t += -np.log(r) / (a * k)
-            a = a - 1
-            time.append(t)
-            mol_count.append(a)
-        return time, mol_count
-
-    def interpolate_mol_counts(self, time, mol_count, output_times):
-        """
-        Takes raw times and inputs and mol counts and outputs interpolated
-        values at output_times
-        """
-        # Interpolate as step function, decreasing mol_count by 1 at each
-        # reaction time point
-        interp_func = interp1d(time, mol_count, kind='previous')
-
-        # Compute molecule count values at given time points using f1
-        # at any time beyond the last reaction, molecule count = 0
-        values = interp_func(output_times[np.where(output_times <= time[-1])])
-        zero_vector = np.zeros(
-            len(output_times[np.where(output_times > time[-1])])
-        )
-        values = np.concatenate((values, zero_vector))
-        return values
-
-    def simulate(self, parameters, times):
-        """ See :meth:`pints.ForwardModel.simulate()`. """
-        times = np.asarray(times)
-        if np.any(times < 0):
-            raise ValueError('Negative times are not allowed.')
-        if self._n0 == 0:
-            return np.zeros(times.shape)
-
-        # run Gillespie
-        time, mol_count = self.simulate_raw(parameters)
-
-        # interpolate
-        values = self.interpolate_mol_counts(time, mol_count, times)
-        return values
-
-    def mean(self, parameters, times):
-        r"""
-        Returns the deterministic mean of infinitely many stochastic
-        simulations, which follows :math:`A(0) \exp(-kt)`.
-        """
-        parameters = np.asarray(parameters)
-        if len(parameters) != self.n_parameters():
-            raise ValueError('This model should have only 1 parameter.')
-        k = parameters[0]
-
-        if k <= 0:
-            raise ValueError('Rate constant must be positive.')
-
-        times = np.asarray(times)
-        if np.any(times < 0):
-            raise ValueError('Negative times are not allowed.')
-
-        mean = self._n0 * np.exp(-k * times)
-        return mean
-
-    def variance(self, parameters, times):
-        r"""
-        Returns the deterministic variance of infinitely many stochastic
-        simulations, which follows :math:`\exp(-2kt)(-1 + \exp(kt))A(0)`.
-        """
-        parameters = np.asarray(parameters)
-        if len(parameters) != self.n_parameters():
-            raise ValueError('This model should have only 1 parameter.')
-        k = parameters[0]
-
-        if k <= 0:
-            raise ValueError('Rate constant must be positive.')
-
-        times = np.asarray(times)
-        if np.any(times < 0):
-            raise ValueError('Negative times are not allowed.')
-
-        variance = np.exp(-2 * k * times) * (-1 + np.exp(k * times)) * self._n0
-        return variance
-
-    def suggested_parameters(self):
-        """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """
-        return np.array([0.1])
-
-    def suggested_times(self):
-        """ See "meth:`pints.toy.ToyModel.suggested_times()`."""
-        return np.linspace(0, 100, 101)
diff --git a/pints/toy/stochastic/_degradation_model.py b/pints/toy/stochastic/_degradation_model.py
index 34555f2bd..d20d32ffe 100644
--- a/pints/toy/stochastic/_degradation_model.py
+++ b/pints/toy/stochastic/_degradation_model.py
@@ -7,6 +7,8 @@
 #
 from . import MarkovJumpModel
 
+import numpy as np
+
 
 class DegradationModel(MarkovJumpModel):
     r"""
@@ -35,3 +37,51 @@ def _propensities(xs, ks):
         return [
             xs[0] * ks[0],
         ]
+
+    def mean(self, parameters, times):
+        r"""
+        Returns the deterministic mean of infinitely many stochastic
+        simulations, which follows :math:`A(0) \exp(-kt)`.
+        """
+        parameters = np.asarray(parameters)
+        if len(parameters) != self.n_parameters():
+            raise ValueError('This model should have only 1 parameter.')
+        k = parameters[0]
+
+        if k <= 0:
+            raise ValueError('Rate constant must be positive.')
+
+        times = np.asarray(times)
+        if np.any(times < 0):
+            raise ValueError('Negative times are not allowed.')
+
+        mean = self._x0 * np.exp(-k * times)
+        return mean
+
+    def variance(self, parameters, times):
+        r"""
+        Returns the deterministic variance of infinitely many stochastic
+        simulations, which follows :math:`\exp(-2kt)(-1 + \exp(kt))A(0)`.
+        """
+        parameters = np.asarray(parameters)
+        if len(parameters) != self.n_parameters():
+            raise ValueError('This model should have only 1 parameter.')
+        k = parameters[0]
+
+        if k <= 0:
+            raise ValueError('Rate constant must be positive.')
+
+        times = np.asarray(times)
+        if np.any(times < 0):
+            raise ValueError('Negative times are not allowed.')
+
+        variance = np.exp(-2 * k * times) * (-1 + np.exp(k * times)) * self._x0
+        return variance
+
+    def suggested_parameters(self):
+        """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """
+        return np.array([0.1])
+
+    def suggested_times(self):
+        """ See "meth:`pints.toy.ToyModel.suggested_times()`."""
+        return np.linspace(0, 100, 101)

From 24d1aa8f7d4aee6abb5859fae65e8efadad6d725 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 18:52:49 +0000
Subject: [PATCH 13/25] finished docs

---
 docs/source/toy/index.rst                                  | 1 -
 .../toy/stochastic/stochastic_michaelis_menten_model.rst   | 7 +++++++
 docs/source/toy/stochastic_degradation_model.rst           | 7 -------
 3 files changed, 7 insertions(+), 8 deletions(-)
 create mode 100644 docs/source/toy/stochastic/stochastic_michaelis_menten_model.rst
 delete mode 100644 docs/source/toy/stochastic_degradation_model.rst

diff --git a/docs/source/toy/index.rst b/docs/source/toy/index.rst
index 69a63255b..36e0e9ca9 100644
--- a/docs/source/toy/index.rst
+++ b/docs/source/toy/index.rst
@@ -37,6 +37,5 @@ Some toy classes provide extra functionality defined in the
     simple_egg_box_logpdf
     simple_harmonic_oscillator_model
     sir_model
-    stochastic_degradation_model
     stochastic_logistic_model
     twisted_gaussian_logpdf
diff --git a/docs/source/toy/stochastic/stochastic_michaelis_menten_model.rst b/docs/source/toy/stochastic/stochastic_michaelis_menten_model.rst
new file mode 100644
index 000000000..b3f43353e
--- /dev/null
+++ b/docs/source/toy/stochastic/stochastic_michaelis_menten_model.rst
@@ -0,0 +1,7 @@
+*********************************
+Stochastic Michaelis Menten model
+*********************************
+
+.. currentmodule:: pints.toy.stochastic
+
+.. autoclass:: MichaelisMentenModel
diff --git a/docs/source/toy/stochastic_degradation_model.rst b/docs/source/toy/stochastic_degradation_model.rst
deleted file mode 100644
index 8cc0edcf6..000000000
--- a/docs/source/toy/stochastic_degradation_model.rst
+++ /dev/null
@@ -1,7 +0,0 @@
-****************************
-Stochastic degradation model
-****************************
-
-.. currentmodule:: pints.toy
-
-.. autoclass:: pints.toy.stochastic.DegradationModel

From 0a1ffdd97bc856e10d658b72abd1fec1108804fe Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 18:56:13 +0000
Subject: [PATCH 14/25] fix for docs

---
 pints/toy/__init__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pints/toy/__init__.py b/pints/toy/__init__.py
index efeb66181..5b455d5c8 100644
--- a/pints/toy/__init__.py
+++ b/pints/toy/__init__.py
@@ -32,4 +32,5 @@
 from ._simple_egg_box import SimpleEggBoxLogPDF
 from ._sir_model import SIRModel
 from ._twisted_gaussian_banana import TwistedGaussianLogPDF
-from .stochastic import *
\ No newline at end of file
+from ._stochastic_logistic_model import StochasticLogisticModel
+from .stochastic import *

From 14ed81af7fa866361b3649f19cbf1909f4ef40ed Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 19:01:53 +0000
Subject: [PATCH 15/25] final fix for docs

---
 docs/source/index.rst                | 1 +
 docs/source/toy/stochastic/index.rst | 1 +
 2 files changed, 2 insertions(+)

diff --git a/docs/source/index.rst b/docs/source/index.rst
index 38d9e9e23..543eb98ba 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -39,6 +39,7 @@ Contents
     optimisers/index
     noise_model_diagnostics
     toy/index
+    toy/stochastic/index
     transformations
     utilities
 
diff --git a/docs/source/toy/stochastic/index.rst b/docs/source/toy/stochastic/index.rst
index 4c31a27f4..586945bd2 100644
--- a/docs/source/toy/stochastic/index.rst
+++ b/docs/source/toy/stochastic/index.rst
@@ -12,3 +12,4 @@ examples.
 
     markov_jump_model
     stochastic_degradation_model
+    stochastic_michaelis_menten_model

From 4122bcbdf596425e74ab977c91edcfa2c3abdf66 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 19:05:26 +0000
Subject: [PATCH 16/25] fix for run-tests.py

---
 run-tests.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/run-tests.py b/run-tests.py
index 94b67ec03..e8a98a591 100755
--- a/run-tests.py
+++ b/run-tests.py
@@ -207,6 +207,7 @@ def doctest_rst_and_public_interface():
         'pints.plot',
         'pints.residuals_diagnostics',
         'pints.toy',
+        'pints.toy.stochastic',
     ]
 
     doc_symbols = get_all_documented_symbols()

From f158670190c2b48b0cf518f38c4e8df7383e80c2 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 19:10:52 +0000
Subject: [PATCH 17/25] more fixes for run-tests.py

---
 run-tests.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/run-tests.py b/run-tests.py
index e8a98a591..5635df424 100755
--- a/run-tests.py
+++ b/run-tests.py
@@ -196,6 +196,7 @@ def doctest_rst_and_public_interface():
     import pints.plot
     import pints.residuals_diagnostics
     import pints.toy
+    import pints.toy.stochastic
 
     # If any modules other than these are exposed it may indicate that a module
     # has been inadvertently exposed in a public context, or that a new module
@@ -218,6 +219,7 @@ def doctest_rst_and_public_interface():
     check_exposed_symbols(pints.plot, [], doc_symbols)
     check_exposed_symbols(pints.residuals_diagnostics, [], doc_symbols)
     check_exposed_symbols(pints.toy, [], doc_symbols)
+    check_exposed_symbols(pints.toy.stochastic, [], doc_symbols)
 
     print('All classes and methods are documented in an RST file, and all '
           'public interfaces are clean.')

From c4edd3f208a49c982026d39f7a226faa524204f1 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 19:16:47 +0000
Subject: [PATCH 18/25] more doc fixes

---
 examples/toy/model-stochastic-degradation.ipynb | 2 +-
 pints/toy/__init__.py                           | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/toy/model-stochastic-degradation.ipynb b/examples/toy/model-stochastic-degradation.ipynb
index d26577819..0256cbf7e 100644
--- a/examples/toy/model-stochastic-degradation.ipynb
+++ b/examples/toy/model-stochastic-degradation.ipynb
@@ -23,7 +23,7 @@
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
     "import pints\n",
-    "import pints.toy"
+    "import pints.toy.stochastic"
    ]
   },
   {
diff --git a/pints/toy/__init__.py b/pints/toy/__init__.py
index 5b455d5c8..7fc8b1d37 100644
--- a/pints/toy/__init__.py
+++ b/pints/toy/__init__.py
@@ -33,4 +33,3 @@
 from ._sir_model import SIRModel
 from ._twisted_gaussian_banana import TwistedGaussianLogPDF
 from ._stochastic_logistic_model import StochasticLogisticModel
-from .stochastic import *

From 362567df31ca4ee03ae8b01a9bd5a6d68996484a Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 19:22:11 +0000
Subject: [PATCH 19/25] testing error source

---
 run-tests.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/run-tests.py b/run-tests.py
index 5635df424..c43137be3 100755
--- a/run-tests.py
+++ b/run-tests.py
@@ -219,7 +219,7 @@ def doctest_rst_and_public_interface():
     check_exposed_symbols(pints.plot, [], doc_symbols)
     check_exposed_symbols(pints.residuals_diagnostics, [], doc_symbols)
     check_exposed_symbols(pints.toy, [], doc_symbols)
-    check_exposed_symbols(pints.toy.stochastic, [], doc_symbols)
+    # check_exposed_symbols(pints.toy.stochastic, [], doc_symbols)
 
     print('All classes and methods are documented in an RST file, and all '
           'public interfaces are clean.')

From 4b12e0e17bb0c126ac22f79dd64aebdb1ff29f1f Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 19:24:25 +0000
Subject: [PATCH 20/25] attempt to fix

---
 run-tests.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/run-tests.py b/run-tests.py
index c43137be3..c7111cebf 100755
--- a/run-tests.py
+++ b/run-tests.py
@@ -218,8 +218,8 @@ def doctest_rst_and_public_interface():
     check_exposed_symbols(pints.noise, [], doc_symbols)
     check_exposed_symbols(pints.plot, [], doc_symbols)
     check_exposed_symbols(pints.residuals_diagnostics, [], doc_symbols)
-    check_exposed_symbols(pints.toy, [], doc_symbols)
-    # check_exposed_symbols(pints.toy.stochastic, [], doc_symbols)
+    check_exposed_symbols(pints.toy, [pints.toy.stochastic], doc_symbols)
+    check_exposed_symbols(pints.toy.stochastic, [], doc_symbols)
 
     print('All classes and methods are documented in an RST file, and all '
           'public interfaces are clean.')

From 5403208b5aec0277ebd6303319e30ca6c80248bf Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Wed, 24 Nov 2021 20:24:49 +0000
Subject: [PATCH 21/25] attempt to fix run-tests

---
 run-tests.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/run-tests.py b/run-tests.py
index c7111cebf..aeb3a7744 100755
--- a/run-tests.py
+++ b/run-tests.py
@@ -218,7 +218,7 @@ def doctest_rst_and_public_interface():
     check_exposed_symbols(pints.noise, [], doc_symbols)
     check_exposed_symbols(pints.plot, [], doc_symbols)
     check_exposed_symbols(pints.residuals_diagnostics, [], doc_symbols)
-    check_exposed_symbols(pints.toy, [pints.toy.stochastic], doc_symbols)
+    check_exposed_symbols(pints.toy, ['pints.toy.stochastic'], doc_symbols)
     check_exposed_symbols(pints.toy.stochastic, [], doc_symbols)
 
     print('All classes and methods are documented in an RST file, and all '

From 7f69fda5708d0ab5fb5dab5b5cc6b6cc3ae5354f Mon Sep 17 00:00:00 2001
From: Michael Clerx <MichaelClerx@users.noreply.github.com>
Date: Mon, 13 Dec 2021 10:50:08 +0000
Subject: [PATCH 22/25] Apply suggestions from code review

---
 pints/toy/stochastic/_markov_jump_model.py      | 2 +-
 pints/toy/stochastic/_michaelis_menten_model.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py
index 973911e7c..65789de76 100644
--- a/pints/toy/stochastic/_markov_jump_model.py
+++ b/pints/toy/stochastic/_markov_jump_model.py
@@ -1,5 +1,5 @@
 #
-# Stochastic degradation toy model.
+# Markov jump model.
 #
 # This file is part of PINTS (https://github.com/pints-team/pints/) which is
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py
index ffff14205..644f9cc55 100644
--- a/pints/toy/stochastic/_michaelis_menten_model.py
+++ b/pints/toy/stochastic/_michaelis_menten_model.py
@@ -1,5 +1,5 @@
 #
-# Stochastic degradation toy model.
+# Stochastic michaelis-menten toy model.
 #
 # This file is part of PINTS (https://github.com/pints-team/pints/) which is
 # released under the BSD 3-clause license. See accompanying LICENSE.md for

From a0d4f24d95c293ae5d8f7bbfbe25cfff6cbb1b7b Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Tue, 18 Jan 2022 22:36:15 +0000
Subject: [PATCH 23/25] addressed most comments, left some documentation

---
 examples/README.md                            |   6 +-
 .../toy/model-stochastic-degradation.ipynb    |   4 +-
 .../model-stochastic-michaelis-menten.ipynb   | 144 +++++++++++++++---
 pints/toy/stochastic/_markov_jump_model.py    |   4 +-
 4 files changed, 135 insertions(+), 23 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index 4d475b390..1a3961d2b 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -103,7 +103,7 @@ relevant code.
 
 ## Toy problems
 
-### Models
+### Deterministic Models
 - [Beeler-Reuter action potential model](./toy/model-beeler-reuter-ap.ipynb)
 - [Constant model](./toy/model-constant.ipynb)
 - [Fitzhugh-Nagumo model](./toy/model-fitzhugh-nagumo.ipynb)
@@ -115,9 +115,11 @@ relevant code.
 - [Repressilator model](./toy/model-repressilator.ipynb)
 - [Simple Harmonic Oscillator model](./toy/model-simple-harmonic-oscillator.ipynb)
 - [SIR Epidemiology model](./toy/model-sir.ipynb)
+
+### Stochastic Models
 - [Stochastic Degradation model](./toy/model-stochastic-degradation.ipynb)
 - [Stochastic Logistic model](./toy/model-stochastic-logistic-growth.ipynb)
-- [Michaelis Menten model](./toy/model-stochastic-michaelis-menten.ipynb)
+- [Stochastic Michaelis Menten model](./toy/model-stochastic-michaelis-menten.ipynb)
 
 ### Distributions
 - [Annulus](./toy/distribution-annulus.ipynb)
diff --git a/examples/toy/model-stochastic-degradation.ipynb b/examples/toy/model-stochastic-degradation.ipynb
index 0256cbf7e..30d94eaaf 100644
--- a/examples/toy/model-stochastic-degradation.ipynb
+++ b/examples/toy/model-stochastic-degradation.ipynb
@@ -70,7 +70,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $\n"
+    "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, has a mean which tends towards the following deterministic function as the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $.\n"
    ]
   },
   {
@@ -106,7 +106,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The deterministic mean (from above) is plotted with the deterministic standard deviation. \n",
+    "We now plot the analytic mean and standard deviation of this process.\n",
     "The deterministic variance of this model is given by: $e^{-2kt}(-1 + e^{kt})n_0$"
    ]
   },
diff --git a/examples/toy/model-stochastic-michaelis-menten.ipynb b/examples/toy/model-stochastic-michaelis-menten.ipynb
index 677f67de7..ce1c2732c 100644
--- a/examples/toy/model-stochastic-michaelis-menten.ipynb
+++ b/examples/toy/model-stochastic-michaelis-menten.ipynb
@@ -12,7 +12,7 @@
    "metadata": {},
    "source": [
     "This example shows how the the Michaelis Menten model can be used.\n",
-    "The Michaelis Menten model is a stochastic model, more details can be found [here](https://en.wikipedia.org/wiki/Michaelis-Menten_kinetics).\n",
+    "The Michaelis Menten model is a stochastic model, and more details about the determinstic analogue can be found [here](https://en.wikipedia.org/wiki/Michaelis-Menten_kinetics).\n",
     "\n",
     "Its reactions are:\n",
     "$$X_1 + X_2 \\xrightarrow{} X_3$$\n",
@@ -24,7 +24,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -38,12 +38,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Specify initial concentration, time points at which to record concentration values, and rate constant value (k)"
+    "Specify initial concentration, time points at which to record concentration values, and rate constant value (k)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -58,17 +58,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The main option is to use the model's ```simulate``` function. This function, given a set of parameters and times, computes the appropriate times and values using Gillispie's algorithm and then uses interpolation to find the values at the exact times requested."
+    "The main option is to use the model's ```simulate``` function. This function, given a set of parameters and times, computes the appropriate times and counts of molecules using Gillespie's algorithm and then uses interpolation to find the values at the exact times requested. Since Gillespie's algorithm returns only the times at which the molecule count is changed, these times may not correspond to the times at which we requested the molecule count. Therefore, the interpolation is used by the ```simulate``` function to extend the molecule counts to the times requested."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -80,12 +80,12 @@
     }
    ],
    "source": [
-    "values = model.simulate(k, times)\n",
+    "first_values = model.simulate(k, times)\n",
     "\n",
-    "plt.step(times, values[:,0], label = 'X1')\n",
-    "plt.step(times, values[:,1], label = 'X2')\n",
-    "plt.step(times, values[:,2], label = 'X3')\n",
-    "plt.step(times, values[:,3], label = 'X4')\n",
+    "plt.step(times, first_values[:,0], label = 'X1')\n",
+    "plt.step(times, first_values[:,1], label = 'X2')\n",
+    "plt.step(times, first_values[:,2], label = 'X3')\n",
+    "plt.step(times, first_values[:,3], label = 'X4')\n",
     "plt.legend()\n",
     "plt.xlabel('time')\n",
     "plt.ylabel('concentration (A(t))'),\n",
@@ -96,17 +96,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Another option for simulating the model is by using the ```simulate_raw``` function. This gives the pure Gillispie's algorithm simulations times and values, without interpolating them. Although more precise, these simulations are similar to the ones given by ```simulate```."
+    "Another option for simulating the model is by using the ```simulate_raw``` function. This gives the pure Gillespie's algorithm simulations of molecule counts, without interpolating them. Although more precise, these simulations are similar to the ones given by ```simulate```."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -135,17 +135,57 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Given the stochastic nature of this model we can use multiple simulations to make sure that the runs are covering the same model with the same parameters. Our simulations are close, suggesting we are obtaining accurate simulations."
+    "Given the stochastic nature of this model we can use multiple simulations to make sure that the runs are covering the same model with the same parameters. Our simulations are close, suggesting that there is not a large amount of stochasticity in these models for these initial values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "times = np.linspace(0, 24, 100)\n",
+    "\n",
+    "for i in range(3):\n",
+    "    values = model.simulate(k, times)\n",
+    "    plt.step(times, values[:,0])\n",
+    "    plt.step(times, values[:,1])\n",
+    "    plt.step(times, values[:,2])\n",
+    "    plt.step(times, values[:,3])\n",
+    "\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))'),\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To obtain higher stochasticity, we can use a model with smaller initial molecule counts to get more stochasticity, as in the example below."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAbsUlEQVR4nO3de5RV5Znn8e+PggKhQEBKChEEb0GMBhOiycSxjSYG8RZdXmIS2xBnyHQubWb1JSSZGc1KutWkzWVmJd2aKKIrRo2tLYoajaOdRI1JkdCgeEtQVKa4KLcqSigonvnj7NJjUVVnn6L2OdTZv89aZ9XZ79777GdzFvXUe9nvq4jAzMzya0i1AzAzs+pyIjAzyzknAjOznHMiMDPLOScCM7OcG1rtANKYMGFCTJs2rdphmJkNKkuXLn09IhpLHTcoEsG0adNobm6udhhmZoOKpNVpjnPTkJlZzjkRmJnlnBOBmVnOORGYmeWcE4GZWc45EZiZ5ZwTgZlZzg2K5wgGuzVrfsbadfdWOwwzG2RGNxzFkUf+z8yv4xpBBaxddy9tbSurHYaZWY9cI6iQhoaZvO+9t1Y7DDOzPbhGYGaWc64R9EO5bf5tbStpaJiZYUS14danXuGeZWuqHYbZPmPmQWO44qyjM7+OawT9UG6bf0PDTJomnpVhRLXhnmVrWNmytdphmOWOawT95Db/bMycNIbbP/fBaodhlitOBL34/b//Mxs339/jvrr9XqbzzWnc/egfWN+6ndfbOiocXW06fMcuRg4fyt3X/qHaoZjtEyZMaeA/X3hk5tdx01AvNm6+H414qcd9nW9OY+emEwF4va2D9h27KhlazRo5fCgTGuqrHYZZ7rhG0IfYPp2PndN3p/Bt1z0JDHdzhpkNWq4RmJnlXC5rBH21/3fRiJeI7dN73Fc8zHFly1ZmThoz4DGamVVKLmsEfbX/d4nt0xk/dm6P+4qHOc6cNIZzZk0e8BjNzCollzUCSNf+3xcPczSzWpHLGoGZmb2tpmsEz/x6DS/8bh0A20fdz4gDngBg1OhX2NY6lYuue7Jfn+t+ATOrJZnWCCS9LGmFpGWSmpOy8ZIelvRi8nNcVtd/4XfreP21NgBGHPAE+41+BYBtrVN5aXP/m3XcL2BmtaQSNYIPR8TrRdsLgEci4mpJC5Ltr2R18QkHN3Du37yXW+4TbbsO4ZILlmR1KTOzQakaTUPnACcn7xcBj5FRIug44HrqR73CLfeJcfWr2dRxSBaXMTMb1LLuLA7gIUlLJc1PyiZGREvyfi0wsacTJc2X1CypecOGDf26+O76OjqTO9zUcQgNvQwHNTPLM0VEdh8uTY6INZIOBB4GvgQsjoixRcdsiog++wlmz54dzc3NmcVpZlaLJC2NiNmljsu0RhARa5Kf64G7geOBdZImJUFOAtZnGYOZmfUts0QgaZSk0V3vgdOAp4HFwKXJYZcC92QVg5mZlZZlZ/FE4G5JXde5NSIelPR74A5JlwGrgQszjMHMzErILBFExCrgPT2UvwGcmtV1zcysPJ5iwsws55wIzMxyzonAzCznnAjMzHLOicDMLOecCMzMcs6JwMws55wIzMxyzonAzCznnAjMzHLOicDMLOecCMzMcs6JwMws55wIzMxyzonAzCznnAjMzHLOicDMLOecCMzMcs6JwMws55wIzMxyzonAzCznnAjMzHLOicDMLOecCMzMcs6JwMws55wIzMxyzonAzCznMk8Ekuok/VHSfcn2dElPSfqTpNsl1Wcdg5mZ9a5kIpA0QtL5kn4g6eeSbpb095KOTnmNy4Fni7avAb4XEYcDm4DLyg/bzMwGSp+JQNI3gMeBDwJPAdcBdwC7gKslPSzp2D7OPxg4A/hJsi3gFODO5JBFwMf37hbMzGxvDC2x/3cRcUUv+74r6UBgah/nfx/4e2B0sn0AsDkidiXbrwGTezpR0nxgPsDUqX1dwszM9kafNYKIWFJi//qIaO5pn6QzgfURsbQ/gUXE9RExOyJmNzY29ucjzMwshVI1gq7mnYuBE4GDgDeBp4ElwAMRsbuXUz8EnC1pLjACGAP8ABgraWhSKzgYWLPXd2FmZv1Wqo9gIXAjsINCJ+/FwOeBXwJzgN9IOqmncyPiqxFxcERMAz4B/N+I+BTwKHB+ctilwD0DcB9mZtZPpWoE10bE0z2UPw3clQz9LLcB/yvAbZK+BfwRuKHM883MbACV6iN4GkDS5d33Sbo8Ijoi4k+lLhIRj0XEmcn7VRFxfEQcHhEXRMSO/gZvZmZ7L+0DZZf2UPaZAYzDzMyqpM+mIUkXA58EpktaXLRrNLAxy8DMzKwySvURPAG0ABOAa4vKW4HlWQVlZmaVUyoRvBIRqyk8WdwjSYqIGNiwzMysUkr1ETwq6UuS3jEySFK9pFMkLaLn/gMzMxskStUI5gCfBX4maTqwGdiPQgJ5CPh+RPwx0wjNzCxTfSaCiNgO/Aj4kaRhFPoK3oyIzRWIzczMKiD1egQRsTMiWoCdkj4tqc95iMzMbHBIlQiSPoFzJf2cwiiiU4F/yTQyMzOriFLPEZxGYX6h0yjMEXQz8P6ImFeB2MzMrAJK1QgeBA4FToyIT0fEvUBvs42amdkgVGrU0HspzBz6S0mrgNuAusyjMjOziik16dyyiFgQEYcBVwCzgGGSHkhWEDMzs0GunFFDT0TElygsJvM94AOZRWVmZhVTamGaad3LImJ3RDwUEZ9VwcGZRWdmZpkr1UfwHUlDKKwithTYQGHZycOBk4GPUGgyei3DGM3MLEOlniy+QNJM4FMUppqYBLQDzwL3A/+YPH1sZmaDVMnF6yNiJfD1CsRiZmZVkLqz2MzMapMTgZlZzjkRmJnlXMk+gi6SJgOHFJ8TEb/KIigzM6ucVIlA0jXARcBKoDMpDsCJwMxskEtbI/g48K6I2JFhLGZmVgVp+whWAcOyDMTMzKojbY2gHVgm6RHgrVpBRPx1JlGZmVnFpE0Ei5OXmZnVmFSJICIWSaoHjkyKno+InX2dI2kEhc7k4cl17oyIKyRNp7CuwQEU5i+6JCI6+nsDZma2d9KuWXwy8CLwQ+BHwAuSTipx2g7glIh4D4V1DOZI+gBwDfC9iDgc2ARc1q/IzcxsQKTtLL4WOC0i/iIiTgI+RmFNgl5FQVuyOSx5BXAKcGdSvojCiCQzM6uStIlgWEQ837URES+QYhSRpDpJy4D1wMPAn4HNEbErOeQ1YHIv586X1CypecOGDSnDNDOzcqVNBM2SfiLp5OT1Y6C51EkR0RkRsyisanY8MCNtYBFxfUTMjojZjY2NaU8zM7MypR019FfAF4Cu4aK/ptBXkEpEbJb0KPBBYKykoUmt4GBgTRnxmpnZAEs7amgH8N3klYqkRmBnkgT2Az5KoaP4UeB8CiOHLqWw+pmZmVVJn4lA0h0RcaGkFRQ6et8hIo7t4/RJwCJJdRSaoO6IiPskrQRuk/Qt4I/ADf0P38zM9lapGsHlyc8zy/3giFgOHNdD+SoK/QVmZrYP6LOzOCJakrefj4jVxS/g89mHZ2ZmWUs7auijPZSdPpCBmJlZdZTqI/grCn/5HyppedGu0cDjWQZmZmaVUaqP4FbgAeAqYEFReWtEbMwsKjMzq5g+E0FEbAG2ABcDSDoQGAE0SGqIiFeyD9HMzLKUdtK5syS9CLwE/DvwMoWagpmZDXJpO4u/BXwAeCEipgOnAr/NLCozM6uYtIlgZ0S8AQyRNCQiHgVmZxiXmZlVSNq5hjZLaqCw0MxPJa0HtmUXlpmZVUraGsE5FNYt/u/AgxSmkz4rq6DMzKxyStYIkrmC7ouIDwO7KSwmY2ZmNaJkjSAiOoHdkvavQDxmZlZhafsI2oAVkh6mqG8gIv6691PMzGwwSJsI7kpexfaYltrMzAaftIlgbET8oLhA0uW9HWxmZoNH2lFDl/ZQ9pkBjMPMzKqk1OyjFwOfBKZLWly0azTgSefMzGpAqaahJ4AWYAJwbVF5K7C8xzPMzGxQKTX76GpgNfDByoRjZmaVlnb20fMkvShpi6Stklolbc06ODMzy17aUUPfBs6KiGezDMbMzCov7aihdU4CZma1KW2NoFnS7cC/ATu6CiOi+0NmZmY2yKRNBGMozD56WlFZsOfTxmZmNsikSgQRMS/rQMzMrDrSjho6UtIjkp5Oto+V9D+yDc3MzCohbWfxj4GvAjsBImI58ImsgjIzs8pJmwhGRsTvupXt6usESVMkPSpppaRnuiapkzRe0sPJcwkPSxrXn8DNzGxgpE0Er0s6jGTqaUnnU5h6oi+7gL+JiJnAB4AvSJoJLAAeiYgjgEeSbTMzq5K0o4a+AFwPzJC0BngJ+HRfJ0REC0myiIhWSc8Ckymsf3xyctgi4DHgK+UGbmZmAyPtqKFVwEckjQKGRERrOReRNA04DngKmJgkCYC1wMRezpkPzAeYOnVqOZczM7MypB019I+SxkbEtuSv+3GSvpXy3AbgX4EvR8Q75ieKiKCXlc4i4vqImB0RsxsbG9NcyszM+iFtH8HpEbG5ayMiNgFzS50kaRiFJPDToqeQ10malOyfBKwvK2IzMxtQaRNBnaThXRuS9gOG93E8kgTcADwbEd8t2rWYt1c8uxS4J324ZmY20NJ2Fv8UeETSwmR7HoWO3r58CLgEWCFpWVL2NeBq4A5Jl1FY6+DCsiI2M7MBlbaz+BpJy4FTk6JvRsQvSpzzG0C97D61l3IzM6uwtDUCIuIB4IEMYzEzsyrwCmVmZjnnFcrMzHLOK5SZmeWcVygzM8s5r1BmZpZzXqHMzCznUiUCSQcD/4fCQ2IAvwYuj4jXsgrM+u+W//c6d63blPr4bZs20b5lc3YBDaTOjsLLLAcO79jMTZd8NvPrpO0sXkhhaoiDkte9SZntg+5at4ln2t5MfXz7ls10bE9/fFV1dsDu3dWOwqympO0jaIyI4l/8N0n6cgbx2AA5umE/7j7uiFTH3r74BgAuuuLqLEMaGAvPKPyct6S6cZjVkLQ1gjckfVpSXfL6NPBGloGZmVllpK0RfJZCH8H3KIwWeoLCxHOWQpo2+4Fsp1/TMJbJbZvf+ku/lA0vv0TjtOkDcu290rwQVtzZ9zFrV0DTMZWJxywn0o4aWg2cnXEsNaurzf7ohv16Paarnb5+RO/HpDW5bTPvW7869fGN06Zz1IdO3uvr7rUVd5b+Rd90DBxzfuViMsuBtKOGFlEYJbQ52R4HXBsR2Xdn14hSbfaDqp0+S03HuP3frMLS9hEc28MKZcdlEpGZmVVU2j6CIZLGJQkASePLOLe29dKufdXO97Nk/2MBWDN2EpM3t3D7dV/u9WM2tELjaN4eFZNHbv83q4q0NYJrgSclfVPSNyl0Fn87u7AGka527W6W7H8sr+4/CYDJm1t43+rlfX5M42g46qBMIhw83P5vVhVpO4tvltQMnJIUnRcRK7MLa5DpqV377oeY8mYrv7novKTgvD1OMzPbF5SzQtlKwL/8gavuuJElMbawMWIeDBkCdz/0jmNeHTmGKe1eu8fM9n1pm4asyJIY+1azD0OGQF39HsdMad/KGWOGVzgyM7PyucO3n6ZsaSlq9jEzG7xcIzAzyznXCFIM/+zu1f0nMWVLS9aRmZlVhGsEKYZ/djdlSwtnaHPGgZmZVYZrBJBy+KeZWW3KZSK45YnF3LVlFwDbRl9Ce2e9h3+aWW7lsmnori27eGbogQC0d9bT0bnnP4OHf5pZXmRWI5B0I3AmsD4i3p2UjQduB6YBLwMXds1fVGlH71rP3aefx+3fWAB41k8zy68sawQ3AXO6lS0AHomII4BHkm0zM6uizGoEEfErSdO6FZ8DnJy8XwQ8BnwlqxiKFfcLLK9rYtKmtdz+jQX7zupcZmZVUuk+gokR0TUAfy0wsbcDJc2X1CypecOGDXt94eJ+gUmb1nLki88A+9DqXGZmVVK1UUMREZKij/3XA9cDzJ49u9fjyuF+ATOzPVW6RrBO0iSA5Of6Cl/fzMy6qXSNYDFwKXB18vOeLC+2/JcP8uzjjwGwYcbxAO4XMDPrJrMagaSfAU8C75L0mqTLKCSAj0p6EfhIsp2ZZx9/jA0vv7RHufsFzMzeluWooYt72XVqVtfsSeO06Vx0xdXc9sBdgPsFzMy6q+kpJv738BN5fVcdX71qMZ0aybjG9mqHZGa2z6npRFCnoUiF92rdxfbdO6obkJnZPqim5xq6c+xB/GrCQaz66tmMbXidEXIiMDPrrqYTgZmZlVbTTUMAO1vaWH/dcpraxgOw/rrlAIyc1UjDCT0vPGNmlic1nQhGzmqkp+7hnS1ttIMTgZkZNZ4IGk6Y9NYv+7VX/QGAAz939lu1AjMzq/FE0N2W1tHMuuommtrGcwYjucjNRGZm+eksPvXoMew/uhWAP+/ezZKk0WhnSxvty/Z+dlMzs8EqNzWCa88+D84uvJ911U2sxc1EZmaQoxqBmZn1LDc1gu6K+wuG7x5G3ZV7zoh91oyJzPvEMVWIrrKam5tZsWJFtcMws26ampo4/fTTM79OLmsExf0Fm+q2sGPIzj2OeWF7B/c+t67SoVXFihUrWLt2bbXDMLMqyWWNoLi/YN6D8wBYOGfhO44578pfVjqsqmpqamLevHnVDsPMqiCXNQIzM3tbLmsE3T2/8fm3agZd2neey6uddcz5+uIez/nAIUO4cv6ZAxZDNdvp165dS1NTU1WuXa5Nt9/B1vvuq3YYZhUx/KgZNH3ta5lfJ/c1grmHzuVd49+1R/nUA1qYUtfZ4zmvdtbx29W7BzSOarbTNzU1ccwxg6NTfOt997H9ueeqHYZZTcl9jeCCIy/ggiMv2HPHnN7P6a2WsLfcTp/OiBkzOOSWm6sdhlnNyH0i6E9TQ33Tufx5SD1n/93dAAghvbNy1a6dHKq1zIpXUn3mxvp6xnd0sPqSvywrlp40jH6ZUaNf2+vP2Rc1jm1nyMiRsPCMaodilr2mY+D07JfXzX3TUH+aGk7atprDdncAEAFB7HHMag3jP3RA6s8c39HBoa1tZcXRm1GjX6O+fsuAfNa+ZsjIkdQdkP7f1cxKy32NAMpvavjb5AW9Dz896et3AkP5b1ddMzBBliP5a3nEvCWVv7aZDTq5rxGYmeVdLmsExf0C2597jhEzZpR1fvFQz4kbJ9K+q50Fzyx4xzGns5VT6pay/H99B4AxQ4Kx2rMJqdi2+u201ve0lE55prZv4ZWR+3PNg4Ov43nuoXN77rw3s8zkskZQ3C8wYsYMxpxZ3vMAxUM9x+83npFDR+5xzMeHPcHRWg3AdsTW3erzM+s7hzGqY0RZcfTmlZH789sJUwbksyrp+Y3Pc/+q+6sdhlnu5LJGAHs/BLHkUM+FK4DJHDtvCRdd9yQAt3/ug70e3jUd9ozPHdvvmIrNAD4zIJ9UOd0f6jOzyshNItj2L1+k7qXCX5vFQxBbW1tp21beaJ1TOjqor6+HhXf2ftDaFYWhX4mVLVvfSgg92dmyjdjRiXqYBbU/PjZqJOeOaUh9/L6ySltPT3l35+Yjs4GVm0RQ99L9DBu6iZ27xr1jCGLbtjY6un6xp1RfX0/DqBK/ZJuOgWPOB+CcWZNLfuaQhmEM1LPKL3QUhramTQQ7W9poh6ongrmHzi15zPMbnwdwIjAbQFVJBJLmAD8A6oCfRET2T0wAO3eNY8Q1q95R9uDCwrDPLJ/o/eQJU/nkCVMz+/zuumoeB6ZsZtpXVmnr9SnvIm4+Mht4Fe8sllQH/BA4HZgJXCxpZqXjMDOzgmrUCI4H/hQRqwAk3QacA6wc6Au9eOWHGdXZAsABw7fyRkzgFwvf+eDXYJp5sxyl+iSKDXT/RJbad57L7uhkzq+zme/JbF9ycEMnP/nquZlfpxqJYDLwatH2a8AJ3Q+SNB+YDzB16t43q7wRE/jzfrP2KB9MM2+mlaZPothA9k9kbdiQoewcLMGaDRKK6PshpwG/oHQ+MCci/kuyfQlwQkR8sbdzZs+eHc3NzZUK0cysJkhaGhGzSx1XjQfK1gDFTzsdnJSZmVkVVCMR/B44QtJ0SfXAJwA3+JqZVUnF+wgiYpekLwK/oDB89MaIeKbScZiZWUFVniOIiPsBTypjZrYPyOWkc2Zm9jYnAjOznHMiMDPLOScCM7Ocq/gDZf0haQOwup+nTwBeH8BwBpM83zvk+/7zfO+Q7/svvvdDIqKx1AmDIhHsDUnNaZ6sq0V5vnfI9/3n+d4h3/ffn3t305CZWc45EZiZ5VweEsH11Q6givJ875Dv+8/zvUO+77/se6/5PgIzM+tbHmoEZmbWBycCM7Ocq+lEIGmOpOcl/UnSgmrHU0mSXpa0QtIySTW/qo+kGyWtl/R0Udl4SQ9LejH5Oa6aMWall3u/UtKa5PtfJmluNWPMiqQpkh6VtFLSM5IuT8pr/rvv497L/u5rto9AUh3wAvBRCsth/h64OCIGfG3kfZGkl4HZEZGLh2oknQS0ATdHxLuTsm8DGyPi6uQPgXER8ZVqxpmFXu79SqAtIv6pmrFlTdIkYFJE/EHSaGAp8HHgM9T4d9/HvV9Imd99LdcIjgf+FBGrIqIDuA04p8oxWUYi4lfAxm7F5wCLkveLKPwnqTm93HsuRERLRPwhed8KPEthXfSa/+77uPey1XIimAy8WrT9Gv38RxqkAnhI0lJJ86sdTJVMjIiW5P1aYGI1g6mCL0panjQd1VzTSHeSpgHHAU+Rs+++271Dmd99LSeCvDsxIt4LnA58IWk+yK0otIHWZjtoz/4ZOAyYBbQA11Y1moxJagD+FfhyRGwt3lfr330P9172d1/LiWANMKVo++CkLBciYk3ycz1wN4WmsrxZl7SjdrWnrq9yPBUTEesiojMidgM/poa/f0nDKPwi/GlE3JUU5+K77+ne+/Pd13Ii+D1whKTpkuqBTwCLqxxTRUgalXQeIWkUcBrwdN9n1aTFwKXJ+0uBe6oYS0V1/RJMnEuNfv+SBNwAPBsR3y3aVfPffW/33p/vvmZHDQEkw6a+D9QBN0bEP1Q3osqQdCiFWgAU1qW+tdbvXdLPgJMpTMG7DrgC+DfgDmAqhWnML4yImutU7eXeT6bQNBDAy8DnitrMa4akE4FfAyuA3Unx1yi0ldf0d9/HvV9Mmd99TScCMzMrrZabhszMLAUnAjOznHMiMDPLOScCM7OccyIwM8s5JwKzbiSNlfT55P1Bku6sdkxmWfLwUbNuknlb7uuaydOs1g2tdgBm+6CrgcMkLQNeBI6KiHdL+gyFWSxHAUcA/wTUA5cAO4C5EbFR0mHAD4FGoB34rxHxXKVvwiwtNw2Z7WkB8OeImAX8Xbd97wbOA94P/APQHhHHAU8Cf5kccz3wpYh4H/C3wI8qEbRZf7lGYFaeR5O531slbQHuTcpXAMcmM0H+J+DnhalgABhe+TDN0nMiMCvPjqL3u4u2d1P4/zQE2JzUJswGBTcNme2pFRjdnxOT+eBfknQBFGaIlPSegQzObKA5EZh1ExFvAI8ni8F/px8f8SngMkn/ATyDl0i1fZyHj5qZ5ZxrBGZmOedEYGaWc04EZmY550RgZpZzTgRmZjnnRGBmlnNOBGZmOff/AUJLyBVlC5bGAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -157,6 +197,9 @@
     }
    ],
    "source": [
+    "x_0 = [50, 8, 8, 0]\n",
+    "model = pints.toy.stochastic.MichaelisMentenModel(x_0)\n",
+    "\n",
     "times = np.linspace(0, 24, 100)\n",
     "\n",
     "for i in range(3):\n",
@@ -170,6 +213,71 @@
     "plt.ylabel('concentration (A(t))'),\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For the higher molecule counts version, we will compute the ODE solutions and compare them to our results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pend(y, t):\n",
+    "    x1, x2, x3, x4 = y\n",
+    "    dydt = [-k[0] * x1 * x2 + k[1] * x3, -k[0] * x1 * x2 + k[1] * x3 + k[2] * x3, k[0] * x1 * x2 - k[1] * x3 - k[2] * x3, k[2] * x3]\n",
+    "    return dydt\n",
+    "\n",
+    "x_0 = [1e4, 2e3, 2e4, 0]\n",
+    "times = np.linspace(0, 24, 100)\n",
+    "\n",
+    "from scipy.integrate import odeint\n",
+    "sol = odeint(pend, x_0, times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(times, sol[:, 0])\n",
+    "plt.plot(times, first_values[:, 0])\n",
+    "plt.plot(times, sol[:, 1])\n",
+    "plt.plot(times, first_values[:, 1])\n",
+    "plt.plot(times, sol[:, 2])\n",
+    "plt.plot(times, first_values[:, 2])\n",
+    "plt.plot(times, sol[:, 3])\n",
+    "plt.plot(times, first_values[:, 3])\n",
+    "plt.xlabel('t')\n",
+    "plt.grid()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our model's simulations are indistinguishable close to the ODE solutions suggesting that our simulations are accurate."
+   ]
   }
  ],
  "metadata": {
diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py
index 973911e7c..b668a962d 100644
--- a/pints/toy/stochastic/_markov_jump_model.py
+++ b/pints/toy/stochastic/_markov_jump_model.py
@@ -17,7 +17,7 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
     r"""
     A general purpose Markov Jump model used for any systems of reactions
     that proceed through jumps. We simulate a population of N different species
-    reacting through M different mechanisms
+    reacting through M different reaction equations.
 
     Simulations are performed using Gillespie's algorithm [1]_, [2]_:
 
@@ -57,6 +57,8 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
     propensities
         A function from the current state, x, and reaction rates, k,
         to a vector of the rates of each reaction taking place.
+    a_0
+        What is this
 
     References
     ----------

From 99a56b349c661c169c4ff39862a347f2c3032c36 Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Tue, 18 Jan 2022 23:36:40 +0000
Subject: [PATCH 24/25] added explanation for markov jump model

---
 pints/toy/stochastic/_markov_jump_model.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py
index b668a962d..b26fa0a82 100644
--- a/pints/toy/stochastic/_markov_jump_model.py
+++ b/pints/toy/stochastic/_markov_jump_model.py
@@ -31,9 +31,19 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
     .. math::
         \tau = \frac{-\ln(r)}{a_0}
 
+    where a_0 is the sum of the propensities at the current time.
+
     3. Decide which reaction, i, takes place using r_1 * a_0 and iterating
 
-    through propensities
+    through propensities. Since r_1 is a a value between 0 and 1 and a_0 is
+
+    the sum of all propensities, we can find k for which
+
+    s_k / a_0 <= r_2 < s_(k+1) / a_0 where s_j is the sum of the first j
+
+    propensities at time t. We then choose i as the reaction corresponding
+
+    to propensity k.
 
     4. Update the state :math:`x` at time :math:`t + \tau` as:
 
@@ -57,8 +67,6 @@ class MarkovJumpModel(pints.ForwardModel, ToyModel):
     propensities
         A function from the current state, x, and reaction rates, k,
         to a vector of the rates of each reaction taking place.
-    a_0
-        What is this
 
     References
     ----------

From d14667dd08bd31f256b9f50a6e79afed920f2ebb Mon Sep 17 00:00:00 2001
From: phumtutum <victor.popa2000@gmail.com>
Date: Tue, 18 Jan 2022 23:45:53 +0000
Subject: [PATCH 25/25] license to 2022 + changelog

---
 CHANGELOG.md | 1 +
 LICENSE.md   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index db8dc7a67..769d34b3d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@ All notable changes to this project will be documented in this file.
 ## [Unreleased]
 
 ### Added
+- [#1417](https://github.com/pints-team/pints/pull/1417) Added a module `toy.stochastic` for stochastic models. In particular, `toy.stochastic.MarkovJumpModel` implements Gillespie's algorithm for easier future implementation of stochastic models.
 - [#1383](https://github.com/pints-team/pints/pull/1383) Added a method `toy.TwistedGaussianDistribution.untwist` that turns samples from this distribution into samples from a multivariate Gaussian.
 - [#1322](https://github.com/pints-team/pints/pull/1322) Added a method `sample_initial_points` that allows users to generate random points with finite metrics (either log-probabilities or error measures) to use as starting points for sampling or optimisation.
 - [#1243](https://github.com/pints-team/pints/pull/1243) Added testing for Python 3.9.
diff --git a/LICENSE.md b/LICENSE.md
index 46162e5d2..f8bc744d6 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2017-2021, University of Oxford (University of Oxford means the
+Copyright (c) 2017-2022, University of Oxford (University of Oxford means the
 Chancellor, Masters and Scholars of the University of Oxford, having an
 administrative office at Wellington Square, Oxford OX1 2JD, UK).
 All rights reserved.