Repository: pints-team/pints

Issue:
Implement No-U-Turn Sampler (NUTS)
This is actually the algorithm (not HMC, although they are similar) that powers Stan and Pymc3. Look at the latest papers on Stan/Pymc3 to see what variants they implement.

Discussion:

Patch:
diff --git a/docs/source/mcmc_samplers/dual_averaging.rst b/docs/source/mcmc_samplers/dual_averaging.rst
new file mode 100644
index 00000000..2ea1d29a
--- /dev/null
+++ b/docs/source/mcmc_samplers/dual_averaging.rst
@@ -0,0 +1,14 @@
+**************
+Dual Averaging
+**************
+
+Dual averaging is not a sampling method, but is a method of adaptivly tuning the 
+Hamintonian Monte Carlo (HMC) step size and mass matrix for the particular log-posterior 
+being sampled. Pint's NUTS sampler uses dual averaging, but we have defined the dual 
+averaging method separately so that in the future it can be used in HMC and other 
+HMC-derived samplers.
+
+
+.. currentmodule:: pints
+
+.. autoclass:: DualAveragingAdaption
diff --git a/docs/source/mcmc_samplers/index.rst b/docs/source/mcmc_samplers/index.rst
index 14a57796..09b89bba 100644
--- a/docs/source/mcmc_samplers/index.rst
+++ b/docs/source/mcmc_samplers/index.rst
@@ -17,6 +17,7 @@ interface, that can be used to sample from an unknown
     differential_evolution_mcmc
     dram_ac_mcmc
     dream_mcmc
+    dual_averaging
     emcee_hammer_mcmc
     haario_ac_mcmc
     haario_bardenet_ac_mcmc
@@ -24,10 +25,11 @@ interface, that can be used to sample from an unknown
     mala_mcmc
     metropolis_mcmc
     monomial_gamma_hamiltonian_mcmc
+    nuts_mcmc
     population_mcmc
     rao_blackwell_ac_mcmc
     relativistic_mcmc
     slice_doubling_mcmc
     slice_rank_shrinking_mcmc
     slice_stepout_mcmc
-    summary_mcmc
\ No newline at end of file
+    summary_mcmc
diff --git a/docs/source/mcmc_samplers/nuts_mcmc.rst b/docs/source/mcmc_samplers/nuts_mcmc.rst
new file mode 100644
index 00000000..31c4f4f8
--- /dev/null
+++ b/docs/source/mcmc_samplers/nuts_mcmc.rst
@@ -0,0 +1,7 @@
+**********************
+No-U-Turn MCMC Sampler
+**********************
+
+.. currentmodule:: pints
+
+.. autoclass:: NoUTurnMCMC
diff --git a/examples/README.md b/examples/README.md
index e6b504ce..10ddba17 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -67,6 +67,7 @@ relevant code.
 - [Hamiltonian MCMC](./sampling/hamiltonian-mcmc.ipynb)
 - [MALA MCMC](./sampling/mala-mcmc.ipynb)
 - [Monomial-Gamma HMC MCMC](./sampling/monomial-gamma-hmc.ipynb)
+- [No-U-Turn MCMC](./sampling/nuts-mcmc.ipynb)
 - [Relativistic MCMC](./sampling/relativistic-mcmc.ipynb)
 - [Slice Sampling: Rank Shrinking MCMC](./sampling/slice-rank-shrinking-mcmc.ipynb)
 
@@ -123,7 +124,6 @@ relevant code.
 - [Simple Egg Box](./toy/distribution-simple-egg-box.ipynb)
 - [Twisted Gaussian Banana](./toy/distribution-twisted-gaussian.ipynb)
 
-
 ## Miscellaneous
 - [Automatic differentiation using autograd](./toy/automatic-differentiation-using-autograd.ipynb)
 - [The example shown on the landing page](./sampling/readme-example.ipynb)
diff --git a/examples/sampling/nuts-mcmc.ipynb b/examples/sampling/nuts-mcmc.ipynb
new file mode 100644
index 00000000..9f65b78c
--- /dev/null
+++ b/examples/sampling/nuts-mcmc.ipynb
@@ -0,0 +1,366 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Inference: No-U-Turn (NUTS) MCMC\n",
+    "\n",
+    "This example shows you how to perform Bayesian inference on a time-series problem, using [No-U-Turn Monte Carlo](http://pints.readthedocs.io/en/latest/mcmc_samplers/nuts_mcmc.html) (NUTS). NUTS is a variant on the original [Hamiltonian MCMC](https://pints.readthedocs.io/en/latest/mcmc_samplers/hamiltonian_mcmc.html), but features a number of adaptive features that aims to reduce the number of hyper-paramters to zero. Dual averaging is used to adapt the step size $\\epsilon$ and mass matrix $M$. More importantly, the NUTS algorithm makes an optimal choice for the number of steps per iteration ($L$), which depends on the local position of the particle in parameter space. If the particle is in a relatively flat (low) region, then a higher $L$ is optimal to move away from this uninteresting area towards regions of higher density. If it is in a region with more curvature, choosing a high value for $L$ can be inefficient because the particle may start to re-explore parts of space already visited; it   may execute ``U-Turns''.                     \n",
+    "\n",
+    "NUTS is the default sampler for packages such as [Stan](https://mc-stan.org/), [PyMC3](https://docs.pymc.io/) and [Pyro](http://pyro.ai/), so including this sampler in Pints is useful for comparison with these libraries. However, it must be noted that the exact implementation will differ slightly between each library, so care must be taken when interpreting results. Out goal with the Pints implementation was to reproduce the Stan version of NUTS as best we could."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, we set up a problem using the logistic growth toy problem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import pints\n",
+    "import pints.toy as toy\n",
+    "import pints.plot\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Load a forward model\n",
+    "model = toy.LogisticModel()\n",
+    "\n",
+    "# Create some toy data\n",
+    "real_parameters = np.array([0.015, 500])\n",
+    "times = np.linspace(0, 1000, 50)\n",
+    "org_values = model.simulate(real_parameters, times)\n",
+    "\n",
+    "# Add noise\n",
+    "np.random.seed(1)\n",
+    "noise = 10\n",
+    "values = org_values + np.random.normal(0, noise, org_values.shape)\n",
+    "\n",
+    "plt.plot(times, values, '.')\n",
+    "plt.plot(times, org_values)\n",
+    "plt.xlabel('time')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we set up and run a sampling routine using No-U-Turn MCMC. In the initialisation of the No-U-Turn algorithm the sampler tries to find a reasonable value for `epsilon`, the leapfrog step size, which results in many overflows seen from evaluating the logistic model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running...\n",
+      "Using No-U-Turn MCMC\n",
+      "Generating 3 chains.\n",
+      "Running in sequential mode.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:76: RuntimeWarning: overflow encountered in exp\n",
+      "  exp = np.exp(-r * times)\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:83: RuntimeWarning: overflow encountered in square\n",
+      "  dvalues_dp[:, 0] = k * times * c * exp / (c * exp + 1)**2\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:83: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  dvalues_dp[:, 0] = k * times * c * exp / (c * exp + 1)**2\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:85: RuntimeWarning: overflow encountered in square\n",
+      "  (self._p0 * (c * exp + 1)**2) + 1 / (c * exp + 1)\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:85: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  (self._p0 * (c * exp + 1)**2) + 1 / (c * exp + 1)\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:83: RuntimeWarning: overflow encountered in multiply\n",
+      "  dvalues_dp[:, 0] = k * times * c * exp / (c * exp + 1)**2\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iter. Eval. Accept.   Steps. Accept.   Steps. Accept.   Steps. Time m:s\n",
+      "0     3192   0.496    176     0.5      512     0.633    64       0:00.5\n",
+      "1     3204                    0.4      2                         0:00.5\n",
+      "2     3300                    0.485    16                        0:00.5\n",
+      "3     3327                    0.45     5                         0:00.5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:79: RuntimeWarning: overflow encountered in multiply\n",
+      "  values = k / (1 + c * exp)\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:84: RuntimeWarning: overflow encountered in multiply\n",
+      "  dvalues_dp[:, 1] = -k * exp / \\\n",
+      "/home/mrobins/git/pints2/pints/toy/_logistic_model.py:85: RuntimeWarning: overflow encountered in multiply\n",
+      "  (self._p0 * (c * exp + 1)**2) + 1 / (c * exp + 1)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100   126969  0.793    426     0.84     53      0.786    198      0:20.8\n",
+      "200   179361  0.77     249     0.91     19      0.85     11       0:30.0\n",
+      "300   190402  0.777    110                                        0:31.9\n",
+      "400   197360  0.786    69                                         0:33.2\n",
+      "500   202265  0.775    49                                         0:34.1\n",
+      "600   207797  0.891    55                                         0:35.1\n",
+      "700   212357  0.879    46                                         0:35.9\n",
+      "800   216369  0.877    40                                         0:36.6\n",
+      "900   221287  0.867    49                                         0:37.5\n",
+      "1000  226549  0.877224 53                                         0:38.5\n",
+      "1100  232111  0.898    56                                         0:39.5\n",
+      "1200  237443  0.876    53                                         0:40.5\n",
+      "1300  242477  0.887    50                                         0:41.4\n",
+      "1400  247635  0.867    52                                         0:42.3\n",
+      "1500  252744  0.887    52                                         0:43.2\n",
+      "Halting: Maximum number of iterations (1500) reached.\n",
+      "Done!\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x288 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "R-hat:\n",
+      "[1.0014611395392252, 1.0045424184040066]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create an object with links to the model and time series\n",
+    "problem = pints.SingleOutputProblem(model, times, values)\n",
+    "\n",
+    "# Create a log-likelihood function\n",
+    "log_likelihood = pints.GaussianKnownSigmaLogLikelihood(problem, noise)\n",
+    "\n",
+    "# Create a uniform prior over the parameters\n",
+    "log_prior = pints.UniformLogPrior(\n",
+    "    [0.01, 450],\n",
+    "    [0.02, 560]\n",
+    ")\n",
+    "\n",
+    "# Create a posterior log-likelihood (log(likelihood * prior))\n",
+    "log_posterior = pints.LogPosterior(log_likelihood, log_prior)\n",
+    "\n",
+    "# Choose starting points for 3 mcmc chains\n",
+    "xs = [\n",
+    "    real_parameters * 1.01,\n",
+    "    real_parameters * 0.9,\n",
+    "    real_parameters * 1.1,\n",
+    "]\n",
+    "\n",
+    "# Create mcmc routine\n",
+    "nuts_mcmc = pints.MCMCController(log_posterior, len(xs), xs, method=pints.NoUTurnMCMC)\n",
+    "nuts_mcmc.set_max_iterations(1500)\n",
+    "\n",
+    "# Set up modest logging\n",
+    "nuts_mcmc.set_log_to_screen(True)\n",
+    "nuts_mcmc.set_log_interval(100)\n",
+    "\n",
+    "# Run!\n",
+    "print('Running...')\n",
+    "nuts_chains = nuts_mcmc.run()\n",
+    "print('Done!')\n",
+    "\n",
+    "# Discard warm-up\n",
+    "nuts_chains = nuts_chains[:, 400:]\n",
+    "\n",
+    "pints.plot.trace(nuts_chains)\n",
+    "plt.show()\n",
+    "\n",
+    "# Check convergence using rhat criterion\n",
+    "print('R-hat:')\n",
+    "print(pints.rhat_all_params(nuts_chains))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can do the same using Hamiltonian MCMC.\n",
+    "Note that this implementation of HMC does not use dual-averaging for the step size, nor does it use an adaptive mass matrix like the NUTS implementation, so we expect HMC to be much less efficient than the tuned NUTS sampler."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running...\n",
+      "Using Hamiltonian Monte Carlo\n",
+      "Generating 3 chains.\n",
+      "Running in sequential mode.\n",
+      "Iter. Eval. Accept.   Accept.   Accept.   Time m:s\n",
+      "0     3      0         0         0          0:00.0\n",
+      "1     63     0.333     0.333     0.333      0:00.0\n",
+      "2     123    0.5       0.5       0.5        0:00.0\n",
+      "3     183    0.6       0.6       0.6        0:00.0\n",
+      "100   6003   0.971     0.971     0.98       0:00.7\n",
+      "200   12003  0.975     0.980198  0.990099   0:01.4\n",
+      "300   18003  0.98      0.986755  0.993      0:02.0\n",
+      "400   24003  0.983     0.985     0.995      0:02.7\n",
+      "500   30003  0.986     0.988     0.996      0:03.4\n",
+      "600   36003  0.986711  0.986711  0.993      0:04.1\n",
+      "700   42003  0.988604  0.988604  0.994302   0:04.7\n",
+      "800   48003  0.99      0.989     0.994      0:05.4\n",
+      "900   54003  0.991     0.99      0.993      0:06.1\n",
+      "1000  60003  0.989022  0.991018  0.994012   0:06.8\n",
+      "1100  66003  0.99      0.991833  0.995      0:07.4\n",
+      "1200  72003  0.991     0.993     0.995      0:08.1\n",
+      "1300  78003  0.992     0.993     0.995      0:08.8\n",
+      "1400  84003  0.992     0.994     0.996      0:09.4\n",
+      "1500  89943  0.991     0.993     0.995      0:10.1\n",
+      "Halting: Maximum number of iterations (1500) reached.\n",
+      "Done!\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x288 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "R-hat:\n",
+      "[1.0016799579469862, 1.0069853595188742]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create mcmc routine\n",
+    "h_mcmc = pints.MCMCController(log_posterior, len(xs), xs, method=pints.HamiltonianMCMC)\n",
+    "h_mcmc.set_max_iterations(1500)\n",
+    "\n",
+    "# Set up modest logging\n",
+    "h_mcmc.set_log_to_screen(True)\n",
+    "h_mcmc.set_log_interval(100)\n",
+    "\n",
+    "# Run!\n",
+    "print('Running...')\n",
+    "h_chains = h_mcmc.run()\n",
+    "print('Done!')\n",
+    "\n",
+    "# Discard warm up\n",
+    "h_chains = h_chains[:, 400:]\n",
+    "\n",
+    "pints.plot.trace(h_chains)\n",
+    "plt.show()\n",
+    "\n",
+    "# Check convergence using rhat criterion\n",
+    "print('R-hat:')\n",
+    "print(pints.rhat_all_params(h_chains))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Both samplers converge according to the R-hat measure, and both sets of chains are clearly mixing well and sampling the posterior correctly. However, the adaptive stepping in the NUTS sampler is resulting in an **order of magnitude** less function evaluations.\n",
+    "\n",
+    "We can check the Estimated Sample Size (ESS) for both methods as well, which shows that NUTS also gives a slightly more consistent ESS across the two parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NUTS Minimum ESS:\n",
+      "[269.20479477  96.96671531]\n",
+      "\n",
+      "Hamiltonian Minimum ESS:\n",
+      "[366.66666667  47.98495251]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Check convergence using rhat criterion\n",
+    "print('NUTS Minimum ESS:')\n",
+    "print(np.min([pints.effective_sample_size(nuts_chains[i,:,:]) for i in range(nuts_chains.shape[0])],axis=0))\n",
+    "print('\\nHamiltonian Minimum ESS:')\n",
+    "print(np.min([pints.effective_sample_size(h_chains[i,:,:]) for i in range(h_chains.shape[0])],axis=0))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pints/__init__.py b/pints/__init__.py
index 240d14b1..8d89a910 100644
--- a/pints/__init__.py
+++ b/pints/__init__.py
@@ -206,6 +206,7 @@ from ._mcmc._adaptive_covariance import AdaptiveCovarianceMC
 from ._mcmc._differential_evolution import DifferentialEvolutionMCMC
 from ._mcmc._dram_ac import DramACMC
 from ._mcmc._dream import DreamMCMC
+from ._mcmc._dual_averaging import DualAveragingAdaption
 from ._mcmc._emcee_hammer import EmceeHammerMCMC
 from ._mcmc._haario_ac import HaarioACMC
 from ._mcmc._haario_bardenet_ac import HaarioBardenetACMC
@@ -222,6 +223,12 @@ from ._mcmc._slice_rank_shrinking import SliceRankShrinkingMCMC
 from ._mcmc._slice_stepout import SliceStepoutMCMC
 from ._mcmc._summary import MCMCSummary
 
+if sys.hexversion >= 0x03030000:
+    from ._mcmc._nuts import NoUTurnMCMC
+else:   # pragma: no python 3 cover
+    import warnings
+    warnings.warn('No-U-Turn sampler unsupported for Python version < 3.3')
+
 
 #
 # Nested samplers
diff --git a/pints/_log_priors.py b/pints/_log_priors.py
index 74ec89be..e1ad985f 100644
--- a/pints/_log_priors.py
+++ b/pints/_log_priors.py
@@ -35,6 +35,7 @@ class BetaLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, a, b):
         # Parse input arguments
         self._a = float(a)
@@ -122,6 +123,7 @@ class CauchyLogPrior(pints.LogPrior):
     scale
         The scale of the distribution.
     """
+
     def __init__(self, location, scale):
         # Test inputs
         if float(scale) <= 0:
@@ -193,6 +195,7 @@ class ComposedLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, *priors):
         # Check if sub-priors given
         if len(priors) < 1:
@@ -298,6 +301,7 @@ class ExponentialLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, rate):
         # Parse input arguments
         self._rate = float(rate)
@@ -366,6 +370,7 @@ class GammaLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, a, b):
         # Parse input arguments
         self._a = float(a)
@@ -448,6 +453,7 @@ class GaussianLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, mean, sd):
         # Parse input arguments
         self._mean = float(mean)
@@ -514,6 +520,7 @@ class HalfCauchyLogPrior(pints.LogPrior):
     scale
         The scale of the distribution.
     """
+
     def __init__(self, location, scale):
         # Test inputs
         if float(scale) <= 0:
@@ -595,6 +602,7 @@ class InverseGammaLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, a, b):
         # Parse input arguments
         self._a = float(a)
@@ -760,6 +768,7 @@ class MultivariateGaussianLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, mean, cov):
         # Check input
         mean = pints.vector(mean)
@@ -774,6 +783,11 @@ class MultivariateGaussianLogPrior(pints.LogPrior):
         self._cov = cov
         self._n_parameters = mean.shape[0]
         self._cov_inverse = np.linalg.inv(self._cov)
+        self._cholesky_L, self._cholesky_lower = scipy.linalg.cho_factor(
+            self._cov)
+        log_det_cov = 2 * np.sum(np.log(self._cholesky_L.diagonal()))
+        self._const_factor = - 0.5 * log_det_cov \
+                             - 0.5 * len(self._mean) * np.log(2 * np.pi)
 
         # Factors needed for pseudo-cdf calculation
         self._sigma12_sigma22_inv_l = []
@@ -802,8 +816,13 @@ class MultivariateGaussianLogPrior(pints.LogPrior):
             self._mu2.append(mu2)
 
     def __call__(self, x):
-        return scipy.stats.multivariate_normal.logpdf(
-            x, mean=self._mean, cov=self._cov)
+        tmp = x - self._mean
+        return self._const_factor \
+            - 0.5 * tmp.dot(
+                scipy.linalg.cho_solve(
+                    (self._cholesky_L, self._cholesky_lower), tmp
+                )
+            )
 
     def convert_from_unit_cube(self, u):
         """
@@ -822,7 +841,9 @@ class MultivariateGaussianLogPrior(pints.LogPrior):
 
     def evaluateS1(self, x):
         """ See :meth:`LogPDF.evaluateS1()`. """
-        return self(x), -np.matmul(self._cov_inverse, x - self._mean)
+        return self(x), -scipy.linalg.cho_solve(
+            (self._cholesky_L, self._cholesky_lower), x - self._mean
+        )
 
     def mean(self):
         """ See :meth:`LogPrior.mean()`. """
@@ -1000,6 +1021,7 @@ class StudentTLogPrior(pints.LogPrior):
     scale
         The scale of the distribution.
     """
+
     def __init__(self, location, df, scale):
         # Test inputs
         if float(df) <= 0:
@@ -1087,6 +1109,7 @@ class UniformLogPrior(pints.LogPrior):
 
     Extends :class:`LogPrior`.
     """
+
     def __init__(self, lower_or_boundaries, upper=None):
         # Parse input arguments
         if upper is None:
@@ -1139,7 +1162,7 @@ class UniformLogPrior(pints.LogPrior):
                         xs[j, i] < self._boundaries.upper()[i]):
                     cdfs[j, i] = ((-self._boundaries.lower()[i] + xs[j, i]) /
                                   (-self._boundaries.lower()[i] +
-                                  self._boundaries.upper()[i]))
+                                   self._boundaries.upper()[i]))
                 elif xs[j, i] >= self._boundaries.upper()[i]:
                     cdfs[j, i] = 1.0
                 else:
diff --git a/pints/_logger.py b/pints/_logger.py
index c9543373..25af66d4 100644
--- a/pints/_logger.py
+++ b/pints/_logger.py
@@ -351,16 +351,19 @@ class Logger(object):
                 # Write data
                 for row in rows:
                     line = []
-                    i = iter(row)
+                    column = iter(row)
                     for width, dtype, f1, f2 in self._field_formats:
-                        if dtype == _FLOAT:
-                            x = '{:.17e}'.format(next(i))
+                        v = next(column)
+                        if v is None:
+                            x = ''
+                        elif dtype == _FLOAT:
+                            x = '{:.17e}'.format(v)
                         elif dtype == _TIME:
-                            x = str(next(i))
+                            x = str(v)
                         elif dtype == _TEXT:
-                            x = '"' + str(next(i)) + '"'
+                            x = '"' + str(v) + '"'
                         else:
-                            x = str(int(next(i)))
+                            x = str(int(v))
                         line.append(x)
                     f.write(','.join(line) + '\n')
 
@@ -385,19 +388,21 @@ class Logger(object):
             column = iter(row)
             formatted_row = []
             for width, dtype, f1, f2 in self._field_formats:
-                if dtype == _FLOAT:
-                    v = next(column)
+                v = next(column)
+                if v is None:
+                    x = ' ' * width
+                elif dtype == _FLOAT:
                     x = f1.format(v)
                     if len(x) > width:
                         x = f2.format(v)
                     x += ' ' * (width - len(x))
                 elif dtype == _TIME:
-                    x = self._format_time(next(column))
+                    x = self._format_time(v)
                 elif dtype == _TEXT:
-                    x = str(next(column))[:width]
+                    x = str(v)[:width]
                     x += ' ' * (width - len(x))
                 else:
-                    x = f1.format(int(next(column)))
+                    x = f1.format(int(v))
                 formatted_row.append(x)
             formatted_rows.append(formatted_row)
 
diff --git a/pints/_mcmc/__init__.py b/pints/_mcmc/__init__.py
index 649a721b..3f0b8306 100644
--- a/pints/_mcmc/__init__.py
+++ b/pints/_mcmc/__init__.py
@@ -367,6 +367,7 @@ class MCMCController(object):
         self._evaluations_in_memory = False
         self._samples = None
         self._evaluations = None
+        self._n_evaluations = None
         self._time = None
 
         # Writing chains and evaluations to disk
@@ -444,6 +445,13 @@ class MCMCController(object):
         """
         return self._samplers[0].needs_initial_phase()
 
+    def n_evaluations(self):
+        """
+        Returns the number of evaluations performed during the last run, or
+        ``None`` if the controller hasn't run yet.
+        """
+        return self._n_evaluations
+
     def parallel(self):
         """
         Returns the number of parallel worker processes this routine will be
@@ -468,7 +476,7 @@ class MCMCController(object):
 
         # Iteration and evaluation counting
         iteration = 0
-        n_evaluations = 0
+        self._n_evaluations = 0
 
         # Choose method to evaluate
         f = self._log_pdf
@@ -620,7 +628,7 @@ class MCMCController(object):
             fxs = evaluator.evaluate(xs)
 
             # Update evaluation count
-            n_evaluations += len(fxs)
+            self._n_evaluations += len(fxs)
 
             # Update chains
             if self._single_chain:
@@ -744,7 +752,7 @@ class MCMCController(object):
             # Show progress
             if logging and iteration >= next_message:
                 # Log state
-                logger.log(iteration, n_evaluations)
+                logger.log(iteration, self._n_evaluations)
                 for sampler in self._samplers:
                     sampler._log_write(logger)
                 logger.log(timer.time())
@@ -771,7 +779,7 @@ class MCMCController(object):
 
         # Log final state and show halt message
         if logging:
-            logger.log(iteration, n_evaluations)
+            logger.log(iteration, self._n_evaluations)
             for sampler in self._samplers:
                 sampler._log_write(logger)
             logger.log(self._time)
diff --git a/pints/_mcmc/_dual_averaging.py b/pints/_mcmc/_dual_averaging.py
new file mode 100644
index 00000000..98d2bd06
--- /dev/null
+++ b/pints/_mcmc/_dual_averaging.py
@@ -0,0 +1,261 @@
+#
+# Dual Averaging step size and mass matrix adaption method for NUTS and HMC
+# samplers
+#
+# 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
+
+
+class DualAveragingAdaption(object):
+    r"""
+    Dual Averaging method to adaptively tune the step size and mass matrix of a
+    Hamiltonian Monte Carlo (HMC) routine (as used e.g. in NUTS).
+
+    Implements a Dual Averaging scheme to adapt the step size ``epsilon``, as
+    per [1]_ (section 3.2.1 and algorithm 6), and estimates the inverse mass
+    matrix using the sample covariance of the accepted parameter, as suggested
+    in [2]_. The mass matrix can either be given as a fully dense matrix
+    represented as a 2D ndarray, or a diagonal matrix represented as a 1D
+    ndarray.
+
+    During iteration ``m`` of adaption, the parameter ``epsilon`` is updated
+    using the following scheme:
+
+    .. math::
+        \bar{H} = (1 - 1/(m + t_0)) \bar{H} + 1/(m + t_0)(\delta_t - \delta)
+        \text{log} \epsilon = \mu - \sqrt{m}/\gamma \bar{H}
+
+    where $\delta_t$ is the target acceptence probability set by the user and
+    $\delta$ is the acceptence probability reported by the algorithm (i.e. that
+    is provided as an argument to the :meth:`step` method.
+
+    The adaption is done using the same windowing method employed by Stan,
+    which is done over three or more windows:
+
+    - initial window: epsilon is adapted using dual averaging (*no* adaption of
+      the mass matrix).
+    - base window: epsilon continues to be adapted using dual averaging; this
+      adaption completes at the end of this window. The inverse mass matrix is
+      adaped at the end of the window by taking the sample covariance of all
+      parameter points within this window.
+    - terminal window: epsilon is adapted using dual averaging, holding the
+      mass matrix constant, and completes at the end of the window.
+
+    If the number of warmup steps requested by the user is greater than the sum
+    of these three windows, then additional base windows are added, each with a
+    size double that of the previous window.
+
+    References
+    ----------
+    .. [1] Hoffman, M. D., & Gelman, A. (2014). The No-U-Turn sampler:
+           adaptively setting path lengths in Hamiltonian Monte Carlo.
+           Journal of Machine Learning Research, 15(1), 1593-1623.
+
+    .. [2] Betancourt, M. (2018). A Conceptual Introduction to Hamiltonian
+           Monte Carlo. https://arxiv.org/abs/1701.02434.
+
+    Parameters
+    ----------
+    num_warmup_steps
+        ???
+    target_accept_prob
+        ???
+    init_epsilon
+        An initial guess for the step size epsilon
+    init_inv_mass_matrix
+        An initial guess for the inverse adapted mass matrix
+
+    """
+
+    def __init__(self, num_warmup_steps, target_accept_prob,
+                 init_epsilon, init_inv_mass_matrix):
+        # windowing constants (defaults taken from Stan)
+        self._initial_window = 75
+        self._base_window = 25
+        self._terminal_window = 50
+
+        # windowing counter
+        self._counter = 0
+
+        # dual averaging constants (defaults taken from Stan)
+        self._gamma = 0.05
+        self._t0 = 10.0
+        self._kappa = 0.75
+
+        # variables for dual averaging
+        self._epsilon = init_epsilon    # The adapted step size
+        self._mass_matrix = None        # The adapted mass matrix (set below)
+        self._inv_mass_matrix = None    # The inverse adapted mass matrix
+
+        self._mu = np.log(10 * self._epsilon)
+        self._log_epsilon_bar = np.log(1)
+        self._h_bar = 0.0
+        self._adapt_epsilon_counter = 0
+
+        self.set_inv_mass_matrix(np.copy(init_inv_mass_matrix))
+        self._target_accept_prob = target_accept_prob
+
+        minimum_warmup_steps = self._initial_window + self._terminal_window + \
+            self._base_window
+
+        if num_warmup_steps < minimum_warmup_steps:
+            raise ValueError(
+                'Number of warmup steps less than the minimum value {}'.
+                format(minimum_warmup_steps)
+            )
+
+        self._warmup_steps = num_warmup_steps
+        self._next_window = self._initial_window + self._base_window
+        self._adapting = True
+
+        self.init_sample_covariance(self._base_window)
+        self.init_adapt_epsilon(init_epsilon)
+
+    def adapt_epsilon(self, accept_prob):
+        """
+        Perform a single step of the dual averaging scheme.
+        """
+
+        if accept_prob > 1:
+            accept_prob = 1.0
+
+        self._adapt_epsilon_counter += 1
+        counter = self._adapt_epsilon_counter
+
+        eta = 1.0 / (counter + self._t0)
+
+        self._h_bar = (1 - eta) * self._h_bar \
+            + eta * (self._target_accept_prob - accept_prob)
+
+        log_epsilon = (
+            self._mu - (np.sqrt(counter) / self._gamma) * self._h_bar)
+
+        x_eta = counter**(-self._kappa)
+        self._log_epsilon_bar = x_eta * log_epsilon + \
+            (1 - x_eta) * self._log_epsilon_bar
+        self._epsilon = np.exp(log_epsilon)
+
+    def add_parameter_sample(self, sample):
+        """
+        Store the parameter samples to calculate a sample covariance matrix
+        later on.
+        """
+        self._samples[:, self._num_samples] = sample
+        self._num_samples += 1
+
+    def calculate_sample_variance(self):
+        """
+        Return the sample covariance of all the stored samples.
+        """
+        assert self._num_samples == self._samples.shape[1]
+        params = self._samples.shape[0]
+        samples = self._samples.shape[1]
+
+        if self._inv_mass_matrix.ndim == 1:
+            sample_covariance = np.var(self._samples, axis=1)
+            identity = np.ones(params)
+        else:
+            sample_covariance = np.cov(self._samples)
+            identity = np.eye(params)
+
+        # adapt the sample covariance in a similar way to Stan
+        return (samples / (samples + 5.0)) * sample_covariance \
+            + 1e-3 * (5.0 / (samples + 5.0)) * identity
+
+    def final_epsilon(self):
+        """
+        Perform the final step of the dual averaging scheme.
+        """
+        return np.exp(self._log_epsilon_bar)
+
+    def get_epsilon(self):
+        """ return the step size """
+        return self._epsilon
+
+    def get_inv_mass_matrix(self):
+        return self._inv_mass_matrix
+
+    def get_mass_matrix(self):
+        """ Return the mass matrix. """
+        return self._mass_matrix
+
+    def init_adapt_epsilon(self, epsilon):
+        """
+        Start a new dual averaging adaption for epsilon.
+        """
+        self._epsilon = epsilon
+        self._mu = np.log(10 * self._epsilon)
+        self._log_epsilon_bar = np.log(1)
+        self._h_bar = 0.0
+        self._adapt_epsilon_counter = 0
+
+    def init_sample_covariance(self, size):
+        """
+        Start a new adaption window for the inverse mass matrix.
+        """
+        n_params = self._inv_mass_matrix.shape[0]
+        self._samples = np.empty((n_params, size))
+        self._num_samples = 0
+
+    def set_inv_mass_matrix(self, inv_mass_matrix):
+        """
+        We calculate the mass matrix whenever the inverse mass matrix is set.
+        """
+        if inv_mass_matrix.ndim == 1:
+            self._mass_matrix = 1.0 / inv_mass_matrix
+            self._inv_mass_matrix = inv_mass_matrix
+        else:
+            try:
+                self._mass_matrix = np.linalg.inv(inv_mass_matrix)
+            except np.linalg.LinAlgError:
+                print('WARNING: adapted mass matrix is ill-conditioned')
+                return
+            self._inv_mass_matrix = inv_mass_matrix
+
+    def step(self, x, accept_prob):
+        """
+        Perform a single step of the adaption.
+
+        Parameters
+        ----------
+        x: ndarray
+            The next accepted mcmc parameter point.
+        accept_prob: float
+            The acceptance probability of the last NUTS/HMC mcmc step.
+
+        """
+
+        if not self._adapting:
+            return
+
+        self._counter += 1
+
+        if self._counter >= self._warmup_steps:
+            self._epsilon = self.final_epsilon()
+            self._adapting = False
+            return False
+
+        self.adapt_epsilon(accept_prob)
+        if self._counter > self._initial_window:
+            self.add_parameter_sample(x)
+
+        if self._counter >= self._next_window:
+            self.set_inv_mass_matrix(self.calculate_sample_variance())
+            if self._counter >= self._warmup_steps - self._terminal_window:
+                self._next_window = self._warmup_steps
+            else:
+                self._base_window *= 2
+                self._next_window = min(
+                    self._counter + self._base_window,
+                    self._warmup_steps - self._terminal_window
+                )
+            self.init_sample_covariance(self._next_window - self._counter)
+            return True
+            #self._epsilon = self.final_epsilon()
+
+        return False
diff --git a/pints/_mcmc/_nuts.py b/pints/_mcmc/_nuts.py
new file mode 100644
index 00000000..c57f1034
--- /dev/null
+++ b/pints/_mcmc/_nuts.py
@@ -0,0 +1,752 @@
+#
+# No-U-Turn Sampler (NUTS) MCMC method
+#
+# 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 asyncio
+import pints
+import numpy as np
+
+
+class NutsState(object):
+    """
+    Class to hold information about the current state of the NUTS hamiltonian
+    integration path.
+
+    NUTS builds up the integration path implicitly via recursion up a binary
+    tree, this class handles combining states from different subtrees (see
+    `update`). The algorithm integrates both backwards ("minus") and forwards
+    ("plus") in time, so this state must keep track of both end points of the
+    integration path.
+
+    Attributes
+    ----------
+
+    theta_minus: ndarray
+        parameter value at the backwards end of the integration path
+
+    theta_plus: ndarray
+        parameter value at the forwards end of the integration path
+
+    r_minus: ndarray
+        momentum value at the backwards end of the integration path
+
+    r_plus: ndarray
+        momentum value at the forwards end of the integration path
+
+    L_minus: float
+        logpdf value at the backwards end of the integration path
+
+    L_plus: float
+        logpdf value at the forwards end of the integration path
+
+    grad_L_minus: float
+        gradient of logpdf at the backwards end of the integration path
+
+    grad_L_plus: float
+        gradient of logpdf at the forwards end of the integration path
+
+    n: int or float
+        the weight given to each subtree
+
+    s: int
+        0 if sufficient leapfrog steps have been taken, 1 otherwise
+
+    theta: ndarray
+        the current accepted point along the path
+
+    L: float
+        the logpdf of the current accepted point
+
+    grad_L: float
+        the gradient of the logpdf at the current accepted point
+
+    alpha: float
+        the acceptance probability
+
+    n_alpha: float
+        a count of the points along this path
+
+    divergent: boolean
+        True if one of the points in the tree was divergent
+
+    """
+
+    def __init__(self, theta, r, L, grad_L, n, s, alpha, n_alpha, divergent,
+                 inv_mass_matrix):
+        self.theta_minus = np.copy(theta)
+        self.theta_plus = np.copy(theta)
+        self.r_minus = np.copy(r)
+        self.r_plus = np.copy(r)
+        self.r_sum = np.copy(r)
+        self.L_minus = np.copy(L)
+        self.L_plus = np.copy(L)
+        self.grad_L_minus = np.copy(grad_L)
+        self.grad_L_plus = np.copy(grad_L)
+        self.n = n
+        self.s = s
+        self.theta = np.copy(theta)
+        self.L = L
+        self.grad_L = np.copy(grad_L)
+        self.alpha = alpha
+        self.n_alpha = n_alpha
+        self.divergent = divergent
+        self.inv_mass_matrix = inv_mass_matrix
+
+    def update(self, other_state, direction, root):
+        """
+        if ``root == True``, this combines a depth j subtree (``self``) with a
+        depth j+1 (``other_state``) subtree, which corresponds to the higher
+        level loop in the nuts algorithm.
+
+        if ``root == False``, this combines two subtrees with depth j, which
+        occurs when the nuts algorithm is implicitly building up the tree with
+        the build_tree subroutine.
+
+        direction is the current direction of integration, either forwards
+        (``direction == 1``), or backwards (``direction = -1``).
+        """
+
+        # update the appropriate end of the tree according to what direction we
+        # are integrating
+        if direction == -1:
+            self.theta_minus = other_state.theta_minus
+            self.r_minus = other_state.r_minus
+            r_minus_plus = other_state.r_plus
+            r_plus_minus = self.r_minus
+            r_sum_minus = other_state.r_sum
+            r_sum_plus = self.r_sum
+            self.L_minus = other_state.L_minus
+            self.grad_L_minus = other_state.grad_L_minus
+        else:
+            self.theta_plus = other_state.theta_plus
+            self.r_plus = other_state.r_plus
+            r_minus_plus = self.r_plus
+            r_plus_minus = other_state.r_minus
+            r_sum_minus = self.r_sum
+            r_sum_plus = other_state.r_sum
+            self.L_plus = other_state.L_plus
+            self.grad_L_plus = other_state.grad_L_plus
+
+        # Notes: alpha and n_alpha are only accumulated within build_tree
+        # Update: perhaps not according to stan code...
+        if root:
+            self.alpha += other_state.alpha
+            self.n_alpha += other_state.n_alpha
+        else:
+            self.alpha += other_state.alpha
+            self.n_alpha += other_state.n_alpha
+
+        # propogate divergence up the tree
+        self.divergent |= other_state.divergent
+
+        self.s *= other_state.s
+
+        # check if chain is stopping
+        if self.s == 0:
+            return
+
+        # for non-root merges accumulate tree weightings before probability
+        # calculation
+        if not root:
+            self.n = np.logaddexp(self.n, other_state.n)
+
+        # accept a new point based on the weighting of the two trees
+        p = min(1, np.exp(other_state.n - self.n))
+
+        if p > 0.0 and np.random.uniform() < p:
+            self.theta = other_state.theta
+            self.L = other_state.L
+            self.grad_L = other_state.grad_L
+
+        # for root merges accumulate tree weightings after probability
+        # calculation
+        if root:
+            self.n = np.logaddexp(self.n, other_state.n)
+
+        # integrate momentum over chain
+        self.r_sum += other_state.r_sum
+
+        # test if the path has done a U-Turn, if we are stopping due to a
+        # U-turn or a divergent iteration propogate this up the tree with
+        # self.s
+        if self.inv_mass_matrix.ndim == 1:
+            r_sharp_minus = self.inv_mass_matrix * self.r_minus
+            r_sharp_plus = self.inv_mass_matrix * self.r_plus
+            r_sharp_plus_minus = self.inv_mass_matrix * r_plus_minus
+            r_sharp_minus_plus = self.inv_mass_matrix * r_minus_plus
+        else:
+            r_sharp_minus = self.inv_mass_matrix.dot(self.r_minus)
+            r_sharp_plus = self.inv_mass_matrix.dot(self.r_plus)
+            r_sharp_plus_minus = self.inv_mass_matrix.dot(r_plus_minus)
+            r_sharp_minus_plus = self.inv_mass_matrix.dot(r_minus_plus)
+
+        # test merged trees
+        self.s *= int((self.r_sum).dot(r_sharp_minus) > 0)
+        self.s *= int((self.r_sum).dot(r_sharp_plus) > 0)
+
+        # test across subtrees
+        self.s *= int((r_sum_minus + r_plus_minus).dot(r_sharp_minus) > 0)
+        self.s *= int((r_sum_minus + r_plus_minus).dot(r_sharp_plus_minus) > 0)
+
+        self.s *= int((r_sum_plus + r_minus_plus).dot(r_sharp_minus_plus) > 0)
+        self.s *= int((r_sum_plus + r_minus_plus).dot(r_sharp_plus) > 0)
+
+
+def kinetic_energy(r, inv_mass_matrix):
+    if inv_mass_matrix.ndim == 1:
+        return 0.5 * np.inner(r, inv_mass_matrix * r)
+    else:
+        return 0.5 * np.inner(r, inv_mass_matrix.dot(r))
+
+# All the functions below are written as coroutines to enable the recursive
+# nuts algorithm to be written using the ask-and-tell interface used by PINTS,
+# see main coroutine function ``nuts_sampler`` for more details
+
+
+@asyncio.coroutine
+def leapfrog(theta, L, grad_L, r, epsilon, inv_mass_matrix):
+    """
+    performs a leapfrog step using a step_size ``epsilon`` and an inverse mass
+    matrix ``inv_mass_matrix``.
+
+    The inverse mass matrix can be a 2 dimensional ndarray, in which case it is
+    interpreted as a dense matrix, or a 1 dimensional ndarray, in which case it
+    is interpreted as a diagonal matrix.
+    """
+    r_new = r + 0.5 * epsilon * grad_L
+    if inv_mass_matrix.ndim == 1:
+        theta_new = theta + epsilon * inv_mass_matrix * r_new
+    else:
+        theta_new = theta + epsilon * inv_mass_matrix.dot(r_new)
+    L_new, grad_L_new = (yield theta_new)
+    r_new += 0.5 * epsilon * grad_L_new
+    return L_new, grad_L_new, theta_new, r_new
+
+
+@asyncio.coroutine
+def build_tree(state, v, j, adaptor, hamiltonian0, hamiltonian_threshold):
+    """
+    Implicitly build up a subtree of depth ``j`` for the NUTS sampler.
+    """
+    if j == 0:
+        # Base case - take one leapfrog in the direction v
+        if v == -1:
+            theta = state.theta_minus
+            r = state.r_minus
+            L = state.L_minus
+            grad_L = state.grad_L_minus
+        else:
+            theta = state.theta_plus
+            r = state.r_plus
+            L = state.L_plus
+            grad_L = state.grad_L_plus
+
+        L_dash, grad_L_dash, theta_dash, r_dash = \
+            yield from leapfrog(theta, L, grad_L, r, v * adaptor.get_epsilon(),
+                                adaptor.get_inv_mass_matrix())
+        hamiltonian_dash = L_dash \
+            - kinetic_energy(r_dash, adaptor.get_inv_mass_matrix())
+
+        comparison = hamiltonian_dash - hamiltonian0
+        n_dash = comparison
+        alpha_dash = min(1.0, np.exp(comparison))
+
+        divergent = -comparison > hamiltonian_threshold
+        s_dash = int(not divergent)
+
+        n_alpha_dash = 1
+        return NutsState(
+            theta_dash, r_dash, L_dash, grad_L_dash, n_dash, s_dash,
+            alpha_dash, n_alpha_dash, divergent,
+            adaptor.get_inv_mass_matrix()
+        )
+
+    else:
+        # Recursion - implicitly build the left and right subtrees
+        state_dash = yield from  \
+            build_tree(state, v, j - 1, adaptor, hamiltonian0,
+                       hamiltonian_threshold)
+
+        if state_dash.s == 1:
+            state_double_dash = yield from \
+                build_tree(state_dash, v, j - 1, adaptor, hamiltonian0,
+                           hamiltonian_threshold)
+            state_dash.update(state_double_dash, direction=v, root=False)
+
+        return state_dash
+
+
+@asyncio.coroutine
+def find_reasonable_epsilon(theta, L, grad_L, inv_mass_matrix):
+    """
+    Pick a reasonable value of epsilon close to when the acceptance
+    probability of the Langevin proposal crosses 0.5. This is based on
+    Algorithm 4 in [1]_ (with scaled mass matrix as per section 4.2).
+
+    Note: inv_mass_matrix can be a 1-d ndarray and in this case is interpreted
+    as a diagonal matrix, or can be given as a fully dense 2-d ndarray.
+    """
+
+    # intialise at epsilon = 1.0 (shouldn't matter where we start)
+    epsilon = 1.0
+
+    # randomly sample momentum
+    if inv_mass_matrix.ndim == 1:
+        r = np.random.normal(
+            np.zeros(len(theta)),
+            np.sqrt(1.0 / inv_mass_matrix)
+        )
+    else:
+        r = np.random.multivariate_normal(
+            np.zeros(len(theta)),
+            np.linalg.inv(inv_mass_matrix)
+        )
+    hamiltonian = L - kinetic_energy(r, inv_mass_matrix)
+    L_dash, grad_L_dash, theta_dash, r_dash = \
+        yield from leapfrog(theta, L, grad_L, r, epsilon, inv_mass_matrix)
+    hamiltonian_dash = L_dash - kinetic_energy(r_dash, inv_mass_matrix)
+    if np.isnan(hamiltonian_dash):
+        comparison = float('-inf')
+    else:
+        comparison = hamiltonian_dash - hamiltonian
+
+    # determine whether we are doubling or halving
+    alpha = 2 * int(comparison > np.log(0.5)) - 1
+
+    # double or half epsilon until acceptance probability crosses 0.5
+    while comparison * alpha > np.log(2) * (-alpha):
+        epsilon = 2**alpha * epsilon
+        L_dash, grad_L_dash, theta_dash, r_dash = \
+            yield from leapfrog(theta, L, grad_L, r, epsilon, inv_mass_matrix)
+        hamiltonian_dash = L_dash - kinetic_energy(r_dash, inv_mass_matrix)
+        if np.isnan(hamiltonian_dash):  # pragma: no cover
+            comparison = float('-inf')
+        else:
+            comparison = hamiltonian_dash - hamiltonian
+    return epsilon
+
+
+@asyncio.coroutine
+def nuts_sampler(x0, delta, num_adaption_steps, sigma0,
+                 hamiltonian_threshold, max_tree_depth,
+                 use_dense_mass_matrix):
+    """
+    The dual averaging NUTS mcmc sampler given in Algorithm 6 of [1]_.
+    Implements the multinomial sampling suggested in [2]_. Implements a mass
+    matrix for the dynamics, which is detailed in [2]_. Both the step size and
+    the mass matrix is adapted using a combination of the dual averaging
+    detailed in [1]_ and the windowed adaption for the mass matrix and step
+    size implemented in the Stan library (https://github.com/stan-dev/stan)
+
+    Implemented as a coroutine that continually generates new theta values to
+    evaluate (L, L') at. Users must send (L, L') back to the coroutine to
+    continue execution. The end of an mcmc step is signalled by generating a
+    tuple of values (theta, L, acceptance probability, number of leapfrog
+    steps)
+
+    Arguments
+    ---------
+
+    x0: ndarray
+        starting point
+    delta: float
+        target acceptance probability (Dual Averaging scheme)
+    num_adaption_steps: int
+        number of adaption steps (Dual Averaging scheme)
+    hamiltonian_threshold: float
+        threshold to test divergent iterations
+    max_tree_depth: int
+        maximum tree depth
+    use_dense_mass_matrix: bool
+        if False, use a diagonal mass matrix, if True use a fully dense mass
+        matrix
+
+    References
+    ----------
+    .. [1] Hoffman, M. D., & Gelman, A. (2014). The No-U-Turn sampler:
+           adaptively setting path lengths in Hamiltonian Monte Carlo.
+           Journal of Machine Learning Research, 15(1), 1593-1623.
+
+    .. [2] Betancourt, M. (2018). `A Conceptual Introduction to Hamiltonian
+           Monte Carlo`, https://arxiv.org/abs/1701.02434.
+
+    """
+    # Initialise sampler with x0 and calculate logpdf
+    theta = x0
+    L, grad_L = (yield theta)
+
+    # Check first point is somewhere sensible
+    if not np.isfinite(L):
+        raise ValueError(
+            'Initial point for MCMC must have finite logpdf.')
+
+    # pick the initial inverse mass matrix as the provided sigma0.
+    # reduce to a diagonal matrix if not using a dense mass matrix
+    if use_dense_mass_matrix:
+        init_inv_mass_matrix = sigma0
+        init_inv_mass_matrix = 1e-3 * np.eye(len(x0))
+    else:
+        init_inv_mass_matrix = np.diag(sigma0)
+        init_inv_mass_matrix = 1e-3 * np.ones(len(x0))
+
+    # find a good value to start epsilon at (this will later be refined so that
+    # the acceptance probability matches delta)
+    epsilon = yield from find_reasonable_epsilon(theta, L, grad_L,
+                                                 init_inv_mass_matrix)
+
+    # create adaption for epsilon and mass matrix
+    adaptor = pints.DualAveragingAdaption(
+        num_adaption_steps, delta, epsilon, init_inv_mass_matrix)
+
+    # start at iteration 1
+    m = 1
+
+    # provide an infinite generator of mcmc steps....
+    while True:
+        # randomly sample momentum
+        if use_dense_mass_matrix:
+            r0 = np.random.multivariate_normal(
+                np.zeros(len(theta)), adaptor.get_mass_matrix())
+        else:
+            r0 = np.random.normal(np.zeros(len(theta)),
+                                  np.sqrt(adaptor.get_mass_matrix()))
+
+        hamiltonian0 = L - kinetic_energy(r0, adaptor.get_inv_mass_matrix())
+
+        # create initial integration path state
+        state = NutsState(theta=theta, r=r0, L=L, grad_L=grad_L,
+                          n=0.0, s=1, alpha=1, n_alpha=1, divergent=False,
+                          inv_mass_matrix=adaptor.get_inv_mass_matrix())
+        j = 0
+
+        # build up an integration path with 2^j points, stopping when we either
+        # encounter a U-Turn, or reach a max number of points 2^max_tree_depth
+        while j < max_tree_depth and state.s == 1:
+
+            # pick a random direction to integrate in
+            # (to maintain detailed balance)
+            if np.random.randint(0, 2):
+                vj = 1
+            else:
+                vj = -1
+
+            # recursivly build up tree in that direction
+            state_dash = yield from \
+                build_tree(state, vj, j, adaptor,
+                           hamiltonian0, hamiltonian_threshold)
+
+            state.update(state_dash, direction=vj, root=True)
+
+            j += 1
+
+        # update current position in chain
+        theta = state.theta
+        L = state.L
+        grad_L = state.grad_L
+
+        # adapt epsilon and mass matrix using dual averaging
+        restart_stepsize_adapt = \
+            adaptor.step(state.theta, state.alpha / state.n_alpha)
+        if restart_stepsize_adapt:
+            epsilon = yield from \
+                find_reasonable_epsilon(theta, L, grad_L,
+                                        adaptor.get_inv_mass_matrix())
+            adaptor.init_adapt_epsilon(epsilon)
+
+        # signal calling process that mcmc step is complete by passing a tuple
+        # (rather than an ndarray)
+        yield (theta,
+               L,
+               state.alpha / state.n_alpha,
+               state.n_alpha,
+               state.divergent)
+
+        # next step
+        m += 1
+
+
+class NoUTurnMCMC(pints.SingleChainMCMC):
+    r"""
+
+    Implements the No U-Turn Sampler (NUTS) with dual averaging, as described
+    in Algorithm 6 in [1]_.
+
+    Implements the multinomial sampling suggested in [2]_. Implements a mass
+    matrix for the dynamics, which is detailed in [2]_. Both the step size and
+    the mass matrix is adapted using a combination of the dual averaging
+    detailed in [1]_, and the windowed adaption for the mass matrix and step
+    size implemented in the Stan library (https://github.com/stan-dev/stan).
+
+    Like Hamiltonian Monte Carlo, NUTS imagines a particle moving over negative
+    log-posterior (NLP) space to generate proposals. Naturally, the particle
+    tends to move to locations of low NLP -- meaning high posterior density.
+    Unlike HMC, NUTS allows the number of steps taken through parameter space
+    to depend on position, allowing local adaptation.
+
+    Note: This sampler is only supported on Python versions 3.3 and newer.
+
+    Extends :class:`SingleChainMCMC`.
+
+    References
+    ----------
+    .. [1] Hoffman, M. D., & Gelman, A. (2014). The No-U-Turn sampler:
+           adaptively setting path lengths in Hamiltonian Monte Carlo.
+           Journal of Machine Learning Research, 15(1), 1593-1623.
+
+    .. [2] Betancourt, M. (2018). `A Conceptual Introduction to Hamiltonian
+           Monte Carlo`, https://arxiv.org/abs/1701.02434.
+
+    """
+
+    def __init__(self, x0, sigma0=None):
+        super(NoUTurnMCMC, self).__init__(x0, sigma0)
+
+        # hyperparameters
+        self._num_adaption_steps = 500
+        self._delta = 0.8
+        self._step_size = None
+        self._max_tree_depth = 10
+        self._use_dense_mass_matrix = False
+
+        # Default threshold for Hamiltonian divergences
+        # (currently set to match Stan)
+        self._hamiltonian_threshold = 10**3
+
+        # coroutine nuts sampler
+        self._nuts = None
+
+        # number of mcmc iterations
+        self._mcmc_iteration = 0
+
+        # Logging
+        self._last_log_write = 0
+        self._mcmc_acceptance = 0
+        self._n_leapfrog = 0
+
+        # current point in chain
+        self._current = self._x0
+
+        # current logpdf (last logpdf returned by tell)
+        self._current_logpdf = None
+
+        # next point to ask user to evaluate
+        self._next = self._current
+
+        # Set initial state
+        self._running = False
+        self._ready_for_tell = False
+
+        # Divergence checking
+        # Create a vector of divergent iterations
+        self._divergent = np.asarray([], dtype='int')
+
+    def ask(self):
+        """ See :meth:`SingleChainMCMC.ask()`. """
+        # Check ask/tell pattern
+        if self._ready_for_tell:
+            raise RuntimeError('Ask() called when expecting call to tell().')
+
+        # Initialise on first call
+        if not self._running:
+            self._nuts = nuts_sampler(self._x0, self._delta,
+                                      self._num_adaption_steps,
+                                      self._sigma0,
+                                      self._hamiltonian_threshold,
+                                      self._max_tree_depth,
+                                      self._use_dense_mass_matrix)
+            # coroutine will ask for self._x0
+            self._next = next(self._nuts)
+            self._running = True
+
+        self._ready_for_tell = True
+        return np.array(self._next, copy=True)
+
+    def current_log_pdf(self):
+        """ See :meth:`SingleChainMCMC.current_log_pdf()`. """
+        return self._current_logpdf
+
+    def delta(self):
+        """
+        Returns delta used in leapfrog algorithm.
+        """
+        return self._delta
+
+    def divergent_iterations(self):
+        """
+        Returns the iteration number of any divergent iterations.
+        """
+        return self._divergent
+
+    def hamiltonian_threshold(self):
+        """
+        Returns threshold difference in Hamiltonian value from one iteration to
+        next which determines whether an iteration is divergent.
+        """
+        return self._hamiltonian_threshold
+
+    def _log_init(self, logger):
+        """ See :meth:`Loggable._log_init()`. """
+        logger.add_float('Accept.')
+        logger.add_counter('Steps.')
+
+    def _log_write(self, logger):
+        """ See :meth:`Loggable._log_write()`. """
+        # print nothing if no mcmc iterations since last log
+        if self._last_log_write == self._mcmc_iteration:
+            logger.log(None)
+            logger.log(None)
+        else:
+            logger.log(self._mcmc_acceptance)
+            logger.log(self._n_leapfrog)
+        self._mcmc_acceptance = 0
+        self._n_leapfrog = 0
+        self._last_log_write = self._mcmc_iteration
+
+    def max_tree_depth(self):
+        """
+        Returns the maximum tree depth ``D`` for the algorithm. For each
+        iteration, the number of leapfrog steps will not be greater than
+        ``2^D``.
+        """
+        return self._max_tree_depth
+
+    def n_hyper_parameters(self):
+        """ See :meth:`TunableMethod.n_hyper_parameters()`. """
+        return 1
+
+    def name(self):
+        """ See :meth:`pints.MCMCSampler.name()`. """
+        return 'No-U-Turn MCMC'
+
+    def needs_sensitivities(self):
+        """ See :meth:`pints.MCMCSampler.needs_sensitivities()`. """
+        return True
+
+    def number_adaption_steps(self):
+        """
+        Returns number of adaption steps used in the NUTS algorithm.
+        """
+        return self._num_adaption_steps
+
+    def set_delta(self, delta):
+        """
+        Sets delta for the nuts algorithm. This is the goal acceptance
+        probability for the algorithm. Used to set the scalar magnitude of the
+        leapfrog step size.
+        """
+        if self._running:
+            raise RuntimeError('cannot set delta while sampler is running')
+        if delta < 0 or delta > 1:
+            raise ValueError('delta must be in [0, 1]')
+        self._delta = delta
+
+    def set_hamiltonian_threshold(self, hamiltonian_threshold):
+        """
+        Sets threshold difference in Hamiltonian value from one iteration to
+        next which determines whether an iteration is divergent.
+        """
+        if hamiltonian_threshold < 0:
+            raise ValueError('Threshold for divergent iterations must be ' +
+                             'non-negative.')
+        self._hamiltonian_threshold = hamiltonian_threshold
+
+    def set_hyper_parameters(self, x):
+        """
+        The hyper-parameter vector is ``[number_adaption_steps]``.
+
+        See :meth:`TunableMethod.set_hyper_parameters()`.
+        """
+        self.set_number_adaption_steps(x[0])
+
+    def set_max_tree_depth(self, max_tree_depth):
+        """
+        Sets the maximum tree depth ``D`` for the algorithm. For each
+        iteration, the number of leapfrog steps will not be greater than
+        ``2^D``
+        """
+        if max_tree_depth < 0:
+            raise ValueError('Maximum tree depth must be non-negative.')
+        self._max_tree_depth = max_tree_depth
+
+    def set_number_adaption_steps(self, n):
+        """
+        Sets number of adaptions steps in the nuts algorithm. This is the
+        number of mcmc steps that are used to determin the best value for
+        epsilon, the scalar magnitude of the leafrog step size.
+        """
+        if self._running:
+            raise RuntimeError(
+                'cannot set number of adaption steps while sampler is running')
+        if n < 0:
+            raise ValueError('number of adaption steps must be non-negative')
+        self._num_adaption_steps = int(n)
+
+    def set_use_dense_mass_matrix(self, use_dense_mass_matrix):
+        """
+        If ``use_dense_mass_matrix`` is False then algorithm uses a diagonal
+        matrix for the mass matrix. If True then a fully dense mass matrix is
+        used.
+        """
+        self._use_dense_mass_matrix = bool(use_dense_mass_matrix)
+
+    def tell(self, reply):
+        """ See :meth:`pints.SingleChainMCMC.tell()`. """
+        if not self._ready_for_tell:
+            raise RuntimeError('Tell called before proposal was set.')
+        self._ready_for_tell = False
+
+        # send log likelihood and gradient to nuts coroutine,
+        # return value is the next theta to evaluate at
+        self._next = self._nuts.send(reply)
+
+        # coroutine signals end of current step by sending a tuple of
+        # information about the last mcmc step
+        if isinstance(self._next, tuple):
+            # extract next point in chain, its logpdf, the acceptance
+            # probability and the number of leapfrog steps taken during
+            # the last mcmc step
+            self._current = self._next[0]
+            self._current_logpdf = self._next[1]
+            current_acceptance = self._next[2]
+            current_n_leapfrog = self._next[3]
+            divergent = self._next[4]
+
+            # Increase iteration count
+            self._mcmc_iteration += 1
+
+            # average quantities for logging
+            n_it_since_log = self._mcmc_iteration - self._last_log_write
+            self._mcmc_acceptance = (
+                (n_it_since_log * self._mcmc_acceptance + current_acceptance) /
+                (n_it_since_log + 1)
+            )
+            self._n_leapfrog = (
+                (n_it_since_log * self._n_leapfrog + current_n_leapfrog) /
+                (n_it_since_log + 1)
+            )
+
+            # store divergent iterations
+            if divergent:
+                self._divergent = np.append(
+                    self._divergent, self._mcmc_iteration)
+
+            # request next point to evaluate
+            self._next = next(self._nuts)
+
+            # Return current position as next sample in the chain
+            return self._current
+        else:
+            # Return None to indicate there is no new sample for the chain
+            return None
+
+    def use_dense_mass_matrix(self):
+        """
+        Returns if the algorithm uses a dense (True) or diagonal (False) mass
+        matrix.
+        """
+        return self._use_dense_mass_matrix


Test patch:
diff --git a/pints/tests/test_dual_averaging.py b/pints/tests/test_dual_averaging.py
new file mode 100755
index 00000000..683842ab
--- /dev/null
+++ b/pints/tests/test_dual_averaging.py
@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+#
+# 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
+import unittest
+
+import pints
+from shared import StreamCapture
+
+
+class TestDualAveraging(unittest.TestCase):
+    """
+    Tests the dual averaging adaption used in the NUTS sampler.
+    """
+
+    def test_accept_prob_of_greater_then_one(self):
+        num_warmup_steps = 200
+        target_accept_prob = 1.0
+        init_epsilon = 1.0
+        init_inv_mass_matrix = np.array([[1, 0], [0, 1]])
+
+        averager = pints.DualAveragingAdaption(num_warmup_steps,
+                                               target_accept_prob,
+                                               init_epsilon,
+                                               init_inv_mass_matrix)
+
+        # should adjust the input 2.0 to 1.0, which is the target accept
+        # probability
+        averager.adapt_epsilon(2.0)
+        self.assertEqual(averager._h_bar, 0.0)
+
+    def test_set_inv_mass(self):
+        num_warmup_steps = 200
+        target_accept_prob = 1.0
+        init_epsilon = 1.0
+        init_inv_mass_matrix = np.array([[1, 0], [0, 0]])
+
+        with StreamCapture() as c:
+            with self.assertRaises(AttributeError):
+                pints.DualAveragingAdaption(
+                    num_warmup_steps,
+                    target_accept_prob,
+                    init_epsilon,
+                    init_inv_mass_matrix
+                )
+            self.assertIn("WARNING", c.text())
+
+    def test_dual_averaging(self):
+
+        num_warmup_steps = 200
+        target_accept_prob = 0.5
+        init_epsilon = 1.0
+        init_inv_mass_matrix = np.array([[1, 0], [0, 1]])
+        target_mass_matrix = np.array([[10, 0], [0, 10]])
+
+        # raises an exception if the requested number of warm-up steps is
+        # too low
+        with self.assertRaises(ValueError):
+            averager = pints.DualAveragingAdaption(10,
+                                                   target_accept_prob,
+                                                   init_epsilon,
+                                                   init_inv_mass_matrix)
+
+        averager = pints.DualAveragingAdaption(num_warmup_steps,
+                                               target_accept_prob,
+                                               init_epsilon,
+                                               init_inv_mass_matrix)
+
+        # test initialisation
+        self.assertEqual(averager._epsilon, init_epsilon)
+        np.testing.assert_array_equal(
+            averager.get_inv_mass_matrix(), init_inv_mass_matrix)
+        self.assertEqual(averager._counter, 0)
+
+        # these are the default window sizes for the algorithm
+        initial_window = 75
+        base_window = 25
+        terminal_window = 50
+
+        self.assertEqual(averager._next_window, initial_window + base_window)
+        self.assertEqual(averager._adapting, True)
+
+        # dummy function to generate acceptance probabilities
+        # dual averaging will attempt to set epsilon so this function
+        # returns `target_accept_prob`
+        def fake_accept_prob(epsilon):
+            return 1.0 / (10.0 * epsilon)
+
+        stored_x = np.empty((2, base_window))
+        for i in range(averager._next_window - 1):
+            x = np.random.multivariate_normal(np.zeros(2) + 123,
+                                              target_mass_matrix)
+            restart = averager.step(x, fake_accept_prob(averager._epsilon))
+            self.assertFalse(restart)
+            if i >= averager._initial_window:
+                stored_x[:, i - averager._initial_window] = x
+
+        # before the end of the window the mass matrix should not have been
+        # updated
+        np.testing.assert_array_equal(
+            averager.get_inv_mass_matrix(), init_inv_mass_matrix)
+        x = np.random.multivariate_normal(np.zeros(2) + 123,
+                                          target_mass_matrix)
+
+        np.testing.assert_array_equal(averager._samples[:, :-1],
+                                      stored_x[:, :-1])
+        restart = averager.step(x, fake_accept_prob(averager._epsilon))
+
+        # end of window triggers a restart
+        self.assertTrue(restart)
+        stored_x[:, -1] = x
+
+        cov = np.cov(stored_x)
+        n = base_window
+        p = 2
+        adapted_cov = (n / (n + 5.0)) * cov + \
+            1e-3 * (5.0 / (n + 5.0)) * np.eye(p)
+        np.testing.assert_array_equal(averager.get_inv_mass_matrix(),
+                                      adapted_cov)
+        np.testing.assert_array_equal(averager.get_mass_matrix(),
+                                      np.linalg.inv(adapted_cov))
+
+        # test that we have adapted epsilon correctly
+        self.assertAlmostEqual(fake_accept_prob(averager._epsilon),
+                               target_accept_prob, 1)
+
+        # test the counters
+        self.assertEqual(averager._counter, initial_window + base_window)
+        self.assertEqual(averager._next_window,
+                         num_warmup_steps - terminal_window)
+
+        # test counters for two more windows
+        for i in range(averager._next_window - averager._counter):
+            x = np.random.multivariate_normal(np.zeros(2) + 123,
+                                              target_mass_matrix)
+            averager.step(x, fake_accept_prob(averager._epsilon))
+
+        self.assertEqual(averager._counter, num_warmup_steps - terminal_window)
+        self.assertEqual(averager._next_window, num_warmup_steps)
+
+        for i in range(averager._next_window - averager._counter):
+            x = np.random.multivariate_normal(np.zeros(2) + 123,
+                                              target_mass_matrix)
+            averager.step(x, fake_accept_prob(averager._epsilon))
+
+        self.assertEqual(averager._counter, num_warmup_steps)
+        self.assertEqual(averager._adapting, False)
+
+        # check that subsequent steps do nothing
+        old_counter = averager._counter
+        averager.step(x, fake_accept_prob(averager._epsilon))
+        self.assertEqual(old_counter, averager._counter)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pints/tests/test_logger.py b/pints/tests/test_logger.py
index 574f709b..b13e6c69 100755
--- a/pints/tests/test_logger.py
+++ b/pints/tests/test_logger.py
@@ -16,39 +16,39 @@ from shared import StreamCapture, TemporaryDirectory
 
 data = [
     1, 4, 1.234567890987654321, 12, 10, 0, 'yes',
-    2, 3.234, -2.234567890987654321e12, 230, 100, 7.9, 'yes',
-    30, -2.23456789, -3.234567890987654321e-12, -230, 1000, 179.99999, 'no',
-    40, 1.23456789, 4.234567890987654321e-123, -12, 10000, 12345.6, 'no',
+    None, 3.234, -2.234567890987654321e12, 230, 100, 7.9, 'yes',
+    30, -2.23456789, -3.234567890987654321e-12, None, 1000, 179.99999, 'no',
+    40, 1.23456789, 4.234567890987654321e-123, -12, 10000, 12345.6, None,
 ]
 out1 = (
     '#  Latitude Number                   Val  Count Time     Q  \n' +
     '1   4        1.23456789098765429e+00  12  10      0:00.0 yes\n' +
-    '2   3.234   -2.23456789098765430e+12  230 100     0:07.9 yes\n' +
-    '30 -2.23457 -3.23456789098765439e-12 -230 1000    3:00.0 no \n' +
-    '40  1.23457  4.2345678909876540e-123 -12  10000 205:45.6 no \n'
+    '    3.234   -2.23456789098765430e+12  230 100     0:07.9 yes\n' +
+    '30 -2.23457 -3.23456789098765439e-12      1000    3:00.0 no \n' +
+    '40  1.23457  4.2345678909876540e-123 -12  10000 205:45.6    \n'
 )
 out2 = (
     '#  Lat.    Val  Count Time     Q  \n' +
     '1   4       12  10      0:00.0 yes\n' +
-    '2   3.234   230 100     0:07.9 yes\n' +
-    '30 -2.2346 -230 1000    3:00.0 no \n' +
-    '40  1.2346 -12  10000 205:45.6 no \n'
+    '    3.234   230 100     0:07.9 yes\n' +
+    '30 -2.2346      1000    3:00.0 no \n' +
+    '40  1.2346 -12  10000 205:45.6    \n'
 )
 out3 = (
     '#  Lat.    Number                   Val  Count Time     Q  \n' +
     '1   4       1.23456789098765429e+00  12  10      0:00.0 yes\n' +
-    '2   3.234  -2.23456789098765430e+12  230 100     0:07.9 yes\n' +
-    '30 -2.2346 -3.23456789098765439e-12 -230 1000    3:00.0 no \n' +
-    '40  1.2346  4.2345678909876540e-123 -12  10000 205:45.6 no \n'
+    '    3.234  -2.23456789098765430e+12  230 100     0:07.9 yes\n' +
+    '30 -2.2346 -3.23456789098765439e-12      1000    3:00.0 no \n' +
+    '40  1.2346  4.2345678909876540e-123 -12  10000 205:45.6    \n'
 )
 out4 = (
     '"#","Lat.","Number","Val","Count","Time","Q"\n' +
     '1,4.00000000000000000e+00,1.23456789098765429e+00,12,10,0,"yes"\n' +
-    '2,3.23399999999999999e+00,-2.23456789098765430e+12,230,100,7.9,"yes"\n' +
-    '30,-2.23456789000000011e+00,-3.23456789098765439e-12,-230,1000,' +
+    ',3.23399999999999999e+00,-2.23456789098765430e+12,230,100,7.9,"yes"\n' +
+    '30,-2.23456789000000011e+00,-3.23456789098765439e-12,,1000,' +
     '179.99999,"no"\n' +
     '40,1.23456788999999989e+00,4.23456789098765400e-123,-12,10000,' +
-    '12345.6,"no"\n'
+    '12345.6,\n'
 )
 
 
@@ -56,7 +56,7 @@ class TestLogger(unittest.TestCase):
     """
     Tests the Logger class.
     """
-    def test_logger(self):
+    def test_all_simultaneously(self):
         # Normal use, all data at once
         with StreamCapture() as c:
             # Test logger with no fields
@@ -86,6 +86,7 @@ class TestLogger(unittest.TestCase):
         self.assertRaises(RuntimeError, log.set_filename, 'a')
         self.assertRaises(RuntimeError, log.set_stream, sys.stdout)
 
+    def test_partial_row_not_shown(self):
         # Normal use, all data at once, plus extra bit
         with StreamCapture() as c:
             log = pints.Logger()
@@ -101,6 +102,7 @@ class TestLogger(unittest.TestCase):
             log.log(1, 2, 3)    # not enough for more output!
         self.assertOutput(expected=out1, returned=c.text())
 
+    def test_row_by_row(self):
         # Normal use, data row by row
         with StreamCapture() as c:
             log = pints.Logger()
@@ -118,6 +120,7 @@ class TestLogger(unittest.TestCase):
                 log.log(*data[i * n:(i + 1) * n])
         self.assertOutput(expected=out1, returned=c.text())
 
+    def test_field_by_field(self):
         # Normal use, data field by field
         with StreamCapture() as c:
             log = pints.Logger()
@@ -134,6 +137,7 @@ class TestLogger(unittest.TestCase):
                 log.log(d)
         self.assertOutput(expected=out1, returned=c.text())
 
+    def test_various_chunks(self):
         # Log in different sized chunks
         order = [3, 2, 1, 1, 4, 6, 3, 2, 6]
         self.assertEqual(sum(order), len(data))
@@ -154,6 +158,7 @@ class TestLogger(unittest.TestCase):
                 offset += n
         self.assertOutput(expected=out1, returned=c.text())
 
+    def test_file_only_fields_hidden_on_screen(self):
         # Log with file-only fields, and shorter name
         with StreamCapture() as c:
             log = pints.Logger()
@@ -167,6 +172,7 @@ class TestLogger(unittest.TestCase):
             log.log(*data)
         self.assertOutput(expected=out2, returned=c.text())
 
+    def test_file_writing_txt(self):
         # Log with file-only fields, and shorter name, and file
         with StreamCapture() as c:
             with TemporaryDirectory() as d:
@@ -186,6 +192,7 @@ class TestLogger(unittest.TestCase):
         self.assertOutput(expected=out2, returned=c.text())
         self.assertOutput(expected=out3, returned=out)
 
+    def test_file_writing_csv(self):
         # Repeat in csv mode
         with StreamCapture() as c:
             with TemporaryDirectory() as d:
@@ -205,6 +212,7 @@ class TestLogger(unittest.TestCase):
         self.assertOutput(expected=out2, returned=c.text())
         self.assertOutput(expected=out4, returned=out)
 
+    def test_file_writing_no_screen_csv(self):
         # Repeat without screen output
         with StreamCapture() as c:
             with TemporaryDirectory() as d:
@@ -225,6 +233,7 @@ class TestLogger(unittest.TestCase):
         self.assertOutput(expected='', returned=c.text())
         self.assertOutput(expected=out4, returned=out)
 
+    def test_file_writing_no_screen_txt(self):
         # Repeat without screen output, outside of csv mode
         with StreamCapture() as c:
             with TemporaryDirectory() as d:
@@ -259,6 +268,7 @@ class TestLogger(unittest.TestCase):
         self.assertOutput(expected='', returned=c.text())
         self.assertOutput(expected=out3, returned=out)
 
+    def test_no_output(self):
         # Repeat without any output
         with StreamCapture() as c:
             log = pints.Logger()
diff --git a/pints/tests/test_mcmc_controller.py b/pints/tests/test_mcmc_controller.py
index 0910c893..6efd963b 100755
--- a/pints/tests/test_mcmc_controller.py
+++ b/pints/tests/test_mcmc_controller.py
@@ -571,6 +571,10 @@ class TestMCMCController(unittest.TestCase):
         self.assertGreater(mcmc.time(), 0)
         self.assertGreater(t_upper, mcmc.time())
 
+        # Tets number of evaluations is a realistic number (should be 30 for
+        # a simple method)
+        self.assertEqual(mcmc.n_evaluations(), 30)
+
 
 class TestMCMCControllerLogging(unittest.TestCase):
     """
diff --git a/pints/tests/test_mcmc_nuts.py b/pints/tests/test_mcmc_nuts.py
new file mode 100755
index 00000000..9ab3ac59
--- /dev/null
+++ b/pints/tests/test_mcmc_nuts.py
@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+#
+# 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
+import unittest
+import sys
+
+import pints
+import pints.toy
+
+from shared import StreamCapture
+
+
+@unittest.skipIf(sys.hexversion < 0x03030000, 'No NUTS on Python < 3.3')
+class TestNutsMCMC(unittest.TestCase):
+    """
+    Tests the basic methods of the No-U-Turn MCMC sampler.
+    """
+
+    def test_method(self):
+
+        # Create log pdf
+        log_pdf = pints.toy.GaussianLogPDF([5, 5], [[4, 1], [1, 3]])
+
+        # Create mcmc
+        x0 = np.array([2, 2])
+        sigma = [[3, 0], [0, 3]]
+        mcmc = pints.NoUTurnMCMC(x0, sigma)
+
+        # This method needs sensitivities
+        self.assertTrue(mcmc.needs_sensitivities())
+
+        # Perform short run, test logging while we are at it
+        logger = pints.Logger()
+        logger.set_stream(None)
+        mcmc._log_init(logger)
+        chain = []
+        for i in range(2 * mcmc.number_adaption_steps()):
+            x = mcmc.ask()
+            fx, gr = log_pdf.evaluateS1(x)
+            sample = mcmc.tell((fx, gr))
+            mcmc._log_write(logger)
+
+            if sample is not None:
+                chain.append(sample)
+            if np.all(sample == x):
+                self.assertEqual(mcmc.current_log_pdf(), fx)
+
+        chain = np.array(chain)
+        self.assertGreater(chain.shape[0], 1)
+        self.assertEqual(chain.shape[1], len(x0))
+
+    def test_method_with_dense_mass(self):
+
+        # Create log pdf
+        log_pdf = pints.toy.GaussianLogPDF([5, 5], [[4, 1], [1, 3]])
+
+        # Create mcmc
+        x0 = np.array([2, 2])
+        sigma = [[3, 0], [0, 3]]
+        mcmc = pints.NoUTurnMCMC(x0, sigma)
+        mcmc.set_use_dense_mass_matrix(True)
+
+        # Perform short run
+        chain = []
+        for i in range(2 * mcmc.number_adaption_steps()):
+            x = mcmc.ask()
+            fx, gr = log_pdf.evaluateS1(x)
+            sample = mcmc.tell((fx, gr))
+            if sample is not None:
+                chain.append(sample)
+            if np.all(sample == x):
+                self.assertEqual(mcmc.current_log_pdf(), fx)
+
+        chain = np.array(chain)
+        self.assertGreater(chain.shape[0], 1)
+        self.assertEqual(chain.shape[1], len(x0))
+
+    def test_model_that_gives_nan(self):
+        # This model will return a nan in the gradient evaluation, which
+        # originally tripped up the find_reasonable_epsilon function in nuts.
+        # Run it for a bit so that we get coverage on the if statement!
+
+        model = pints.toy.LogisticModel()
+        real_parameters = model.suggested_parameters()
+        times = model.suggested_parameters()
+        org_values = model.simulate(real_parameters, times)
+        np.random.seed(1)
+        noise = 0.2
+        values = org_values + np.random.normal(0, noise, org_values.shape)
+        problem = pints.SingleOutputProblem(model, times, values)
+        log_likelihood = pints.GaussianKnownSigmaLogLikelihood(problem, noise)
+
+        log_prior = pints.UniformLogPrior(
+            [0.01, 40],
+            [0.2, 60]
+        )
+
+        log_posterior = pints.LogPosterior(log_likelihood, log_prior)
+
+        xs = [real_parameters * 1.1]
+        nuts_mcmc = pints.MCMCController(log_posterior,
+                                         len(xs), xs,
+                                         method=pints.NoUTurnMCMC)
+
+        nuts_mcmc.set_max_iterations(10)
+        nuts_mcmc.set_log_to_screen(False)
+        nuts_chains = nuts_mcmc.run()
+
+        self.assertFalse(np.isnan(np.sum(nuts_chains)))
+
+    def test_method_near_boundary(self):
+
+        # Create log pdf
+        log_pdf = pints.UniformLogPrior([0, 0], [1, 1])
+
+        # Create mcmc
+        x0 = np.array([0.999, 0.999])
+        sigma = [[1, 0], [0, 1]]
+        mcmc = pints.NoUTurnMCMC(x0, sigma)
+
+        # Perform short run
+        chain = []
+        for i in range(2 * mcmc.number_adaption_steps()):
+            x = mcmc.ask()
+            fx, gr = log_pdf.evaluateS1(x)
+            sample = mcmc.tell((fx, gr))
+            if sample is not None:
+                chain.append(sample)
+            if np.all(sample == x):
+                self.assertEqual(mcmc.current_log_pdf(), fx)
+
+        chain = np.array(chain)
+        self.assertGreater(chain.shape[0], 1)
+        self.assertEqual(chain.shape[1], len(x0))
+        self.assertGreater(mcmc.divergent_iterations().shape[0], 0)
+
+    def test_logging(self):
+        # Test logging includes name and custom fields.
+        log_pdf = pints.toy.GaussianLogPDF([5, 5], [[4, 1], [1, 3]])
+        x0 = [np.array([2, 2]), np.array([8, 8])]
+
+        mcmc = pints.MCMCController(
+            log_pdf, 2, x0, method=pints.NoUTurnMCMC)
+        mcmc.set_max_iterations(5)
+        with StreamCapture() as c:
+            mcmc.run()
+        text = c.text()
+
+        self.assertIn('No-U-Turn MCMC', text)
+
+    def test_flow(self):
+
+        log_pdf = pints.toy.GaussianLogPDF([5, 5], [[4, 1], [1, 3]])
+        x0 = np.array([2, 2])
+
+        # Test initial proposal is first point
+        mcmc = pints.NoUTurnMCMC(x0)
+        self.assertTrue(np.all(mcmc.ask() == mcmc._x0))
+
+        # Test current log pdf is None (no tell yet)
+        self.assertIsNone(mcmc.current_log_pdf())
+
+        # Repeated asks
+        self.assertRaises(RuntimeError, mcmc.ask)
+
+        # Tell without ask
+        mcmc = pints.NoUTurnMCMC(x0)
+        self.assertRaises(RuntimeError, mcmc.tell, 0)
+
+        # Repeated tells should fail
+        x = mcmc.ask()
+        mcmc.tell(log_pdf.evaluateS1(x))
+        self.assertRaises(RuntimeError, mcmc.tell, log_pdf.evaluateS1(x))
+
+        # Cannot set delta while running
+        self.assertRaises(RuntimeError, mcmc.set_delta, 0.5)
+
+        # Cannot set number of adpation steps while running
+        self.assertRaises(RuntimeError, mcmc.set_number_adaption_steps, 500)
+
+        # Bad starting point
+        mcmc = pints.NoUTurnMCMC(x0)
+        mcmc.ask()
+        self.assertRaises(
+            ValueError, mcmc.tell, (float('-inf'), np.array([1, 1])))
+
+    def test_set_hyper_parameters(self):
+        # Tests the parameter interface for this sampler.
+        x0 = np.array([2, 2])
+        mcmc = pints.NoUTurnMCMC(x0)
+
+        # Test delta parameter
+        delta = mcmc.delta()
+        self.assertIsInstance(delta, float)
+
+        mcmc.set_delta(0.5)
+        self.assertEqual(mcmc.delta(), 0.5)
+
+        # delta between 0 and 1
+        self.assertRaises(ValueError, mcmc.set_delta, -0.1)
+        self.assertRaises(ValueError, mcmc.set_delta, 1.1)
+
+        # Test number of adaption steps
+        n = mcmc.number_adaption_steps()
+        self.assertIsInstance(n, int)
+
+        mcmc.set_number_adaption_steps(100)
+        self.assertEqual(mcmc.number_adaption_steps(), 100)
+
+        # should convert to int
+        mcmc.set_number_adaption_steps(1.4)
+        self.assertEqual(mcmc.number_adaption_steps(), 1)
+
+        # number_adaption_steps is non-negative
+        self.assertRaises(ValueError, mcmc.set_number_adaption_steps, -100)
+
+        # test max tree depth
+        mcmc.set_max_tree_depth(20)
+        self.assertEqual(mcmc.max_tree_depth(), 20)
+        self.assertRaises(ValueError, mcmc.set_max_tree_depth, -1)
+
+        # test use_dense_mass_matrix
+        mcmc.set_use_dense_mass_matrix(True)
+        self.assertEqual(mcmc.use_dense_mass_matrix(), True)
+
+        # hyper param interface
+        self.assertEqual(mcmc.n_hyper_parameters(), 1)
+        mcmc.set_hyper_parameters([2])
+        self.assertEqual(mcmc.number_adaption_steps(), 2)
+
+    def test_other_setters(self):
+        # Tests other setters and getters.
+        x0 = np.array([2, 2])
+        mcmc = pints.NoUTurnMCMC(x0)
+        self.assertRaises(ValueError, mcmc.set_hamiltonian_threshold, -0.3)
+        threshold1 = mcmc.hamiltonian_threshold()
+        self.assertEqual(threshold1, 10**3)
+        threshold2 = 10
+        mcmc.set_hamiltonian_threshold(threshold2)
+        self.assertEqual(mcmc.hamiltonian_threshold(), threshold2)
+
+
+if __name__ == '__main__':
+    unittest.main()