From 23a69ac94aa36eff26821290db0c6100ef0ee53a Mon Sep 17 00:00:00 2001
From: DavAug <david.augustin@gmx.net>
Date: Tue, 16 Feb 2021 11:44:09 +0100
Subject: [PATCH 01/73] #1294 functional test HaarioBardenet

---
 pints/functionaltests/__init__.py             |  0
 .../functest_haario_bardenet_acmc.py          | 75 +++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 pints/functionaltests/__init__.py
 create mode 100644 pints/functionaltests/functest_haario_bardenet_acmc.py

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/pints/functionaltests/functest_haario_bardenet_acmc.py b/pints/functionaltests/functest_haario_bardenet_acmc.py
new file mode 100644
index 0000000000..bd1524ff3f
--- /dev/null
+++ b/pints/functionaltests/functest_haario_bardenet_acmc.py
@@ -0,0 +1,75 @@
+import numpy as np
+
+import pints
+import pints.toy
+
+
+class TestHaarioBardenetACMCOn2dimGaussianDistribution(object):
+    """
+    Tests the pints.HaarioBardenetACMC on a standard 2 dimensional Gaussian
+    distribution.
+    """
+    def __init__(self):
+        # Define calibrated test parameters
+        n_chains = 3
+        n_iterations = 4000
+        warmup = 1000
+        method = pints.HaarioBardenetACMC
+
+        # Define pdf
+        self.pdf = pints.toy.GaussianLogPDF(mean=[0, 0], sigma=[1, 1])
+
+        # Get initial parameters
+        log_prior = pints.ComposedLogPrior(
+            pints.GaussianLogPrior(mean=0, sd=100),
+            pints.GaussianLogPrior(mean=0, sd=100))
+        initial_parameters = log_prior.sample(n=n_chains)
+
+        # Set up sampler
+        sampler = pints.MCMCController(
+            self.pdf, n_chains, initial_parameters, method=method)
+        sampler.set_max_iterations(n_iterations)
+        sampler.set_log_to_screen(False)
+
+        # Infer posterior and throw away warm-up
+        chains = sampler.run()
+        self.chains = chains[:, warmup:]
+
+    def estimate_kld(self):
+        """
+        Estimates and returns the Kullback-Leibler divergence between the
+        approximate posterior and the true posterior assuming that the
+        approximated posterior has Gaussian shape.
+        """
+        # Pool samples from chains
+        chains_x = self.chains[:, :, 0].flatten()
+        chains_y = self.chains[:, :, 1].flatten()
+        chains = np.vstack([chains_x, chains_y]).T
+
+        return self.pdf.kl_divergence(chains)
+
+    def estimate_mean_ess(self):
+        """
+        Estimates the effective sample size (ESS) for each chain and each
+        parameter and returns the mean ESS for across all chains and
+        parameters.
+        """
+        # Estiomate mean ESS for each chain
+        n_chains, _, n_parameters = self.chains.shape
+        ess = np.empty(shape=(n_chains, n_parameters))
+        for chain_id, chain in enumerate(self.chains):
+            ess[chain_id] = pints.effective_sample_size(chain)
+
+        return np.mean(ess)
+
+    def get_results(self):
+        """
+        Runs the functional tests and returns the results.
+        """
+        results = {}
+
+        # Estimate
+        results['kld'] = self.estimate_kld()
+        results['mean-ess'] = self.estimate_mean_ess()
+
+        return results

From b852dd392e6d642acd2d0319c7e7ac9447a4c406 Mon Sep 17 00:00:00 2001
From: DavAug <david.augustin@gmx.net>
Date: Tue, 16 Feb 2021 11:47:52 +0100
Subject: [PATCH 02/73] @1294 add copyright notice

---
 .../functionaltests/functest_haario_bardenet_acmc.py  | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/pints/functionaltests/functest_haario_bardenet_acmc.py b/pints/functionaltests/functest_haario_bardenet_acmc.py
index bd1524ff3f..996de27fb9 100644
--- a/pints/functionaltests/functest_haario_bardenet_acmc.py
+++ b/pints/functionaltests/functest_haario_bardenet_acmc.py
@@ -1,3 +1,14 @@
+#!/usr/bin/env python3
+#
+# Tests the Boundaries classes.
+#
+# 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 division
+
 import numpy as np
 
 import pints

From 4e5bef18291da82a059d89f214e344d74f3be7b8 Mon Sep 17 00:00:00 2001
From: DavAug <david.augustin@gmx.net>
Date: Tue, 16 Feb 2021 11:49:30 +0100
Subject: [PATCH 03/73] #1294 exclude functional tests from coverage rep

---
 .coveragerc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.coveragerc b/.coveragerc
index bc98038386..3dcad84a4f 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -2,6 +2,7 @@
 source = pints
 omit = 
     pints/tests/*
+    pints/functionaltests/*
 
 [report]
 exclude_lines =

From 6e36010605a9ddf34d2484842abb198907bdfee7 Mon Sep 17 00:00:00 2001
From: DavAug <david.augustin@gmx.net>
Date: Tue, 16 Feb 2021 12:40:55 +0100
Subject: [PATCH 04/73] #1294 add copyright notice

---
 pints/functionaltests/__init__.py                      | 5 +++++
 pints/functionaltests/functest_haario_bardenet_acmc.py | 2 --
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index e69de29bb2..faeb415923 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -0,0 +1,5 @@
+#
+# 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.
+#
\ No newline at end of file
diff --git a/pints/functionaltests/functest_haario_bardenet_acmc.py b/pints/functionaltests/functest_haario_bardenet_acmc.py
index 996de27fb9..1682c02e12 100644
--- a/pints/functionaltests/functest_haario_bardenet_acmc.py
+++ b/pints/functionaltests/functest_haario_bardenet_acmc.py
@@ -1,7 +1,5 @@
 #!/usr/bin/env python3
 #
-# Tests the Boundaries classes.
-#
 # 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 5986250e6b7fa00727a1a52e5b12de87811c9085 Mon Sep 17 00:00:00 2001
From: DavAug <david.augustin@gmx.net>
Date: Tue, 16 Feb 2021 16:26:41 +0100
Subject: [PATCH 05/73] #1294 flake8

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

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index faeb415923..11ea46d4f4 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -2,4 +2,4 @@
 # 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.
-#
\ No newline at end of file
+#

From 3bc6fee37a2502fc8b6cdf95e3513ec812a4c313 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 22:53:03 +0000
Subject: [PATCH 06/73] Make test importable

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

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index 11ea46d4f4..b2297d832f 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -3,3 +3,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
+
+from .functest_haario_bardenet_acmc import TestHaarioBardenetACMCOn2dimGaussianDistribution
+

From d297099341d59e276182ed79f7045693d1d436e3 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 22:53:25 +0000
Subject: [PATCH 07/73] Return a string of the class name

(Is there a better way to do this?)
---
 pints/functionaltests/functest_haario_bardenet_acmc.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/pints/functionaltests/functest_haario_bardenet_acmc.py b/pints/functionaltests/functest_haario_bardenet_acmc.py
index 1682c02e12..70c964a59c 100644
--- a/pints/functionaltests/functest_haario_bardenet_acmc.py
+++ b/pints/functionaltests/functest_haario_bardenet_acmc.py
@@ -82,3 +82,10 @@ def get_results(self):
         results['mean-ess'] = self.estimate_mean_ess()
 
         return results
+
+    @staticmethod
+    def get_name():
+        """
+        Returns the name of this class.
+        """
+        return 'TestHaarioBardenetACMCOn2dimGaussianDistribution'

From 5e14e66d6974573a9c22bbf23c8665f3e92b1c42 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 23:03:46 +0000
Subject: [PATCH 08/73] Add skeleton for functional testing workflow

---
 .github/workflows/functional-tests.yml | 52 ++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 .github/workflows/functional-tests.yml

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml
new file mode 100644
index 0000000000..cd5a0d8e6c
--- /dev/null
+++ b/.github/workflows/functional-tests.yml
@@ -0,0 +1,52 @@
+name: Functional testing
+
+on:
+  push:
+    branches:
+      - issue-1294-functional-testing-module
+
+jobs:
+
+  run-functional-testing:
+    name: Functional testing
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out PINTS repository
+        uses: actions/checkout@v2
+        with:
+          path: 'pints'
+
+      - name: Check out functional-testing-2 repository
+        uses: actions/checkout@v2
+        with:
+          repository: 'pints-team/functional-testing-2'
+          path: 'functional-testing-2'
+
+      - name: Contents of pints
+        run: |
+          ls -la
+        working-directory: 'pints'
+
+      - name: Contents of functional-testing-2
+        run: |
+          ls -la
+        working-directory: 'functional-testing-2'
+
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.8
+          architecture: x64
+
+      - name: install pints
+        run: |
+          python --version
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install .
+        working-directory: 'pints'
+
+      - name: install functional-testing-2
+        run: |
+          python -m pip install .
+        working-directory: 'functional-testing-2'

From 29d52f732a42dac64c4250bb8ec8dca621cbd9b4 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 23:15:15 +0000
Subject: [PATCH 09/73] I think this is the correct syntax for not running on
 draft pr...

---
 .github/workflows/copyright-test.yml            | 1 +
 .github/workflows/coverage-test.yml             | 1 +
 .github/workflows/docs-test.yml                 | 1 +
 .github/workflows/style-test.yml                | 1 +
 .github/workflows/unit-test-os-coverage.yml     | 1 +
 .github/workflows/unit-test-python-coverage.yml | 1 +
 6 files changed, 6 insertions(+)

diff --git a/.github/workflows/copyright-test.yml b/.github/workflows/copyright-test.yml
index 262064fa88..fed06ee419 100644
--- a/.github/workflows/copyright-test.yml
+++ b/.github/workflows/copyright-test.yml
@@ -12,6 +12,7 @@ on:
 jobs:
 
   build-and-test:
+    if: github.event.pull_request.draft == false
     name: Copyright
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/coverage-test.yml b/.github/workflows/coverage-test.yml
index 1009845a92..286aa73119 100644
--- a/.github/workflows/coverage-test.yml
+++ b/.github/workflows/coverage-test.yml
@@ -12,6 +12,7 @@ on:
 jobs:
 
   build-and-test:
+    if: github.event.pull_request.draft == false
     name: Coverage
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/docs-test.yml b/.github/workflows/docs-test.yml
index 2f866901b2..e33094edad 100644
--- a/.github/workflows/docs-test.yml
+++ b/.github/workflows/docs-test.yml
@@ -12,6 +12,7 @@ on:
 jobs:
 
   build-and-test:
+    if: github.event.pull_request.draft == false
     name: Docs
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/style-test.yml b/.github/workflows/style-test.yml
index c6c4e7729c..8b79145838 100644
--- a/.github/workflows/style-test.yml
+++ b/.github/workflows/style-test.yml
@@ -12,6 +12,7 @@ on:
 jobs:
 
   build-and-test:
+    if: github.event.pull_request.draft == false
     name: Style
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/unit-test-os-coverage.yml b/.github/workflows/unit-test-os-coverage.yml
index 5b79ceff76..d89f714095 100644
--- a/.github/workflows/unit-test-os-coverage.yml
+++ b/.github/workflows/unit-test-os-coverage.yml
@@ -12,6 +12,7 @@ on:
 jobs:
 
   build-and-test:
+    if: github.event.pull_request.draft == false
     name: OS unit tests
     runs-on: ${{ matrix.os }}
 
diff --git a/.github/workflows/unit-test-python-coverage.yml b/.github/workflows/unit-test-python-coverage.yml
index e59b3772fc..9d968e8032 100644
--- a/.github/workflows/unit-test-python-coverage.yml
+++ b/.github/workflows/unit-test-python-coverage.yml
@@ -12,6 +12,7 @@ on:
 jobs:
 
   build-and-test:
+    if: github.event.pull_request.draft == false
     name: Python unit tests
     runs-on: ubuntu-latest
 

From d176527829e8b953c577b831977b7ac0de63a681 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 23:24:53 +0000
Subject: [PATCH 10/73] Try committing changes to functional testing

---
 .github/workflows/functional-tests.yml | 27 ++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml
index cd5a0d8e6c..c35e712061 100644
--- a/.github/workflows/functional-tests.yml
+++ b/.github/workflows/functional-tests.yml
@@ -21,17 +21,9 @@ jobs:
         uses: actions/checkout@v2
         with:
           repository: 'pints-team/functional-testing-2'
+          ref: 'new-infra'
           path: 'functional-testing-2'
-
-      - name: Contents of pints
-        run: |
-          ls -la
-        working-directory: 'pints'
-
-      - name: Contents of functional-testing-2
-        run: |
-          ls -la
-        working-directory: 'functional-testing-2'
+          token: ${{ secrets.FUNCTIONAL_TESTING_TOKEN }}
 
       - name: Set up Python 3.8
         uses: actions/setup-python@v1
@@ -50,3 +42,18 @@ jobs:
         run: |
           python -m pip install .
         working-directory: 'functional-testing-2'
+
+      - name: run functional testing
+        run: |
+          python run_all_the_things.py
+        working-directory: 'functional-testing-2'
+
+      - name: commit changes
+        run: |
+          git config user.name "github-workflow"
+          git config user.email "github-workflow"
+          git diff
+          git add -all
+          git commit -m "Run of functional testing" || echo "No changes to commit"
+          git push
+        working-directory: 'functional-testing-2'

From 6f143645691d8d61c00b310ed4e86cc9b0e10649 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 23:27:40 +0000
Subject: [PATCH 11/73] Fix syntax

---
 .github/workflows/functional-tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml
index c35e712061..b72880f035 100644
--- a/.github/workflows/functional-tests.yml
+++ b/.github/workflows/functional-tests.yml
@@ -53,7 +53,7 @@ jobs:
           git config user.name "github-workflow"
           git config user.email "github-workflow"
           git diff
-          git add -all
+          git add --all
           git commit -m "Run of functional testing" || echo "No changes to commit"
           git push
         working-directory: 'functional-testing-2'

From 36aa00be9f340da1d96225d9e80584d7a1b486be Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 22 Feb 2021 23:28:00 +0000
Subject: [PATCH 12/73] Remove diff

---
 .github/workflows/functional-tests.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml
index b72880f035..0ebb90fca1 100644
--- a/.github/workflows/functional-tests.yml
+++ b/.github/workflows/functional-tests.yml
@@ -52,7 +52,6 @@ jobs:
         run: |
           git config user.name "github-workflow"
           git config user.email "github-workflow"
-          git diff
           git add --all
           git commit -m "Run of functional testing" || echo "No changes to commit"
           git push

From 128f66eab51da08309f69ca7f5f153ccd01b9427 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Tue, 23 Feb 2021 00:10:31 +0000
Subject: [PATCH 13/73] Bump

---
 pints/functionaltests/__init__.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index b2297d832f..18ca6a35a7 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -5,4 +5,3 @@
 #
 
 from .functest_haario_bardenet_acmc import TestHaarioBardenetACMCOn2dimGaussianDistribution
-

From 2c360e71bf515e1446fe66d3ae3019c5a8f51b46 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Tue, 23 Feb 2021 12:21:38 +0000
Subject: [PATCH 14/73] Bump

---
 .github/workflows/functional-tests.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml
index 0ebb90fca1..3af5e54e4f 100644
--- a/.github/workflows/functional-tests.yml
+++ b/.github/workflows/functional-tests.yml
@@ -56,3 +56,4 @@ jobs:
           git commit -m "Run of functional testing" || echo "No changes to commit"
           git push
         working-directory: 'functional-testing-2'
+

From d28387dcc44b26aedc3c218fc9907d006adbe21e Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Tue, 23 Feb 2021 12:26:18 +0000
Subject: [PATCH 15/73] Bump

---
 .github/workflows/functional-tests.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml
index 3af5e54e4f..0ebb90fca1 100644
--- a/.github/workflows/functional-tests.yml
+++ b/.github/workflows/functional-tests.yml
@@ -56,4 +56,3 @@ jobs:
           git commit -m "Run of functional testing" || echo "No changes to commit"
           git push
         working-directory: 'functional-testing-2'
-

From fdbf30d20b9a677ecf914120a36299e40917754a Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 15 Mar 2021 23:44:58 +0000
Subject: [PATCH 16/73] #1294 update structure

Defer creation of toy problem to class; define function for specific method
---
 pints/functionaltests/__init__.py             |  2 +-
 ...t_haario_bardenet_acmc.py => _problems.py} | 78 +++++++------------
 pints/functionaltests/haario_bardenet_acmc.py | 26 +++++++
 3 files changed, 56 insertions(+), 50 deletions(-)
 rename pints/functionaltests/{functest_haario_bardenet_acmc.py => _problems.py} (61%)
 create mode 100644 pints/functionaltests/haario_bardenet_acmc.py

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index 18ca6a35a7..ed69e870e9 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -4,4 +4,4 @@
 # copyright notice and full license details.
 #
 
-from .functest_haario_bardenet_acmc import TestHaarioBardenetACMCOn2dimGaussianDistribution
+from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_two_dim_gaussian
diff --git a/pints/functionaltests/functest_haario_bardenet_acmc.py b/pints/functionaltests/_problems.py
similarity index 61%
rename from pints/functionaltests/functest_haario_bardenet_acmc.py
rename to pints/functionaltests/_problems.py
index 70c964a59c..6dae890336 100644
--- a/pints/functionaltests/functest_haario_bardenet_acmc.py
+++ b/pints/functionaltests/_problems.py
@@ -1,48 +1,19 @@
-#!/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.
 #
 
-from __future__ import division
-
 import numpy as np
-
 import pints
 import pints.toy
 
 
-class TestHaarioBardenetACMCOn2dimGaussianDistribution(object):
-    """
-    Tests the pints.HaarioBardenetACMC on a standard 2 dimensional Gaussian
-    distribution.
-    """
-    def __init__(self):
-        # Define calibrated test parameters
-        n_chains = 3
-        n_iterations = 4000
-        warmup = 1000
-        method = pints.HaarioBardenetACMC
-
-        # Define pdf
-        self.pdf = pints.toy.GaussianLogPDF(mean=[0, 0], sigma=[1, 1])
-
-        # Get initial parameters
-        log_prior = pints.ComposedLogPrior(
-            pints.GaussianLogPrior(mean=0, sd=100),
-            pints.GaussianLogPrior(mean=0, sd=100))
-        initial_parameters = log_prior.sample(n=n_chains)
-
-        # Set up sampler
-        sampler = pints.MCMCController(
-            self.pdf, n_chains, initial_parameters, method=method)
-        sampler.set_max_iterations(n_iterations)
-        sampler.set_log_to_screen(False)
+class RunMcmcMethodOnProblem(object):
 
-        # Infer posterior and throw away warm-up
-        chains = sampler.run()
-        self.chains = chains[:, warmup:]
+    def __init__(self, pdf, chains):
+        self.pdf = pdf
+        self.chains = chains
 
     def estimate_kld(self):
         """
@@ -63,7 +34,7 @@ def estimate_mean_ess(self):
         parameter and returns the mean ESS for across all chains and
         parameters.
         """
-        # Estiomate mean ESS for each chain
+        # Estimate mean ESS for each chain
         n_chains, _, n_parameters = self.chains.shape
         ess = np.empty(shape=(n_chains, n_parameters))
         for chain_id, chain in enumerate(self.chains):
@@ -71,21 +42,30 @@ def estimate_mean_ess(self):
 
         return np.mean(ess)
 
-    def get_results(self):
-        """
-        Runs the functional tests and returns the results.
-        """
-        results = {}
 
-        # Estimate
-        results['kld'] = self.estimate_kld()
-        results['mean-ess'] = self.estimate_mean_ess()
+class RunMcmcMethodOnTwoDimGaussian(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on a standard 2 dimensional Gaussian
+    distribution.
+    """
 
-        return results
+    def __init__(self, method, n_chains, n_iterations, n_warmup):
+        pdf = pints.toy.GaussianLogPDF(mean=[0, 0], sigma=[1, 1])
 
-    @staticmethod
-    def get_name():
-        """
-        Returns the name of this class.
-        """
-        return 'TestHaarioBardenetACMCOn2dimGaussianDistribution'
+        # Get initial parameters
+        log_prior = pints.ComposedLogPrior(
+            pints.GaussianLogPrior(mean=0, sd=100),
+            pints.GaussianLogPrior(mean=0, sd=100))
+        initial_parameters = log_prior.sample(n=n_chains)
+
+        # Set up sampler
+        sampler = pints.MCMCController(
+            pdf, n_chains, initial_parameters, method=method)
+        sampler.set_max_iterations(n_iterations)
+        sampler.set_log_to_screen(False)
+
+        # Infer posterior and throw away warm-up
+        chains = sampler.run()
+        chains = chains[:, n_warmup:]
+
+        super().__init__(pdf, chains)
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
new file mode 100644
index 0000000000..82b8b9727e
--- /dev/null
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -0,0 +1,26 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import RunMcmcMethodOnTwoDimGaussian
+
+
+def test_haario_bardenet_acmc_on_two_dim_gaussian():
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.HaarioBardenetACMC,
+        n_chains=3,
+        n_iterations=4000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 122590599936a2325fafedd09b46639c6e4240e8 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Tue, 16 Mar 2021 09:50:58 +0000
Subject: [PATCH 17/73] #1294 allow setting of hyper parameters

---
 pints/functionaltests/_problems.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 6dae890336..2573fa4496 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -49,7 +49,7 @@ class RunMcmcMethodOnTwoDimGaussian(RunMcmcMethodOnProblem):
     distribution.
     """
 
-    def __init__(self, method, n_chains, n_iterations, n_warmup):
+    def __init__(self, method, n_chains, n_iterations, n_warmup, method_hyper_parameters=None):
         pdf = pints.toy.GaussianLogPDF(mean=[0, 0], sigma=[1, 1])
 
         # Get initial parameters
@@ -59,13 +59,21 @@ def __init__(self, method, n_chains, n_iterations, n_warmup):
         initial_parameters = log_prior.sample(n=n_chains)
 
         # Set up sampler
-        sampler = pints.MCMCController(
+        controller = pints.MCMCController(
             pdf, n_chains, initial_parameters, method=method)
-        sampler.set_max_iterations(n_iterations)
-        sampler.set_log_to_screen(False)
+        controller.set_max_iterations(n_iterations)
+        controller.set_log_to_screen(False)
+
+        # Set hyper parameters, if required. This is different based on single/multi chain
+        if method_hyper_parameters is not None:
+            if issubclass(method, pints.MultiChainMCMC):
+                controller.sampler().set_hyper_parameters(method_hyper_parameters)
+            else:
+                for sampler in controller.samplers():
+                    sampler.set_hyper_parameters(method_hyper_parameters)
 
         # Infer posterior and throw away warm-up
-        chains = sampler.run()
+        chains = controller.run()
         chains = chains[:, n_warmup:]
 
         super().__init__(pdf, chains)

From 09af99638ec8b9ede04e28a5504adc6caa36a06c Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Mon, 22 Mar 2021 23:50:49 +0000
Subject: [PATCH 18/73] Added banana problem

- Simplified problem class
- Added Haario-Bardenet test for banana
---
 pints/functionaltests/_problems.py            | 73 ++++++++++++++-----
 pints/functionaltests/haario_bardenet_acmc.py | 19 ++++-
 2 files changed, 73 insertions(+), 19 deletions(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 2573fa4496..bb10511914 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -11,8 +11,8 @@
 
 class RunMcmcMethodOnProblem(object):
 
-    def __init__(self, pdf, chains):
-        self.pdf = pdf
+    def __init__(self, log_pdf, chains):
+        self.log_pdf = log_pdf
         self.chains = chains
 
     def estimate_kld(self):
@@ -26,7 +26,7 @@ def estimate_kld(self):
         chains_y = self.chains[:, :, 1].flatten()
         chains = np.vstack([chains_x, chains_y]).T
 
-        return self.pdf.kl_divergence(chains)
+        return self.log_pdf.kl_divergence(chains)
 
     def estimate_mean_ess(self):
         """
@@ -49,8 +49,9 @@ class RunMcmcMethodOnTwoDimGaussian(RunMcmcMethodOnProblem):
     distribution.
     """
 
-    def __init__(self, method, n_chains, n_iterations, n_warmup, method_hyper_parameters=None):
-        pdf = pints.toy.GaussianLogPDF(mean=[0, 0], sigma=[1, 1])
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        log_pdf = pints.toy.GaussianLogPDF(mean=[0, 0], sigma=[1, 1])
 
         # Get initial parameters
         log_prior = pints.ComposedLogPrior(
@@ -60,20 +61,58 @@ def __init__(self, method, n_chains, n_iterations, n_warmup, method_hyper_parame
 
         # Set up sampler
         controller = pints.MCMCController(
-            pdf, n_chains, initial_parameters, method=method)
+            log_pdf, n_chains, initial_parameters, method=method)
         controller.set_max_iterations(n_iterations)
         controller.set_log_to_screen(False)
+        set_hyperparameters_for_any_mcmc_class(controller, method,
+                                               method_hyper_parameters)
 
-        # Set hyper parameters, if required. This is different based on single/multi chain
-        if method_hyper_parameters is not None:
-            if issubclass(method, pints.MultiChainMCMC):
-                controller.sampler().set_hyper_parameters(method_hyper_parameters)
-            else:
-                for sampler in controller.samplers():
-                    sampler.set_hyper_parameters(method_hyper_parameters)
+        chains = run_and_throw_away_warmup(controller, n_warmup)
 
-        # Infer posterior and throw away warm-up
-        chains = controller.run()
-        chains = chains[:, n_warmup:]
+        super().__init__(log_pdf, chains)
 
-        super().__init__(pdf, chains)
+
+class RunMcmcMethodOnBanana(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `pints.TwistedGaussianLogPDF`.
+    """
+
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        log_pdf = pints.toy.TwistedGaussianLogPDF(dimension=2, b=0.1)
+
+        # Get initial parameters
+        log_prior = pints.MultivariateGaussianLogPrior([0, 0],
+                                                       [[10, 0], [0, 10]])
+        x0 = log_prior.sample(n_chains)
+        sigma0 = np.diag(np.array([1, 3]))
+
+        # Set up sampler
+        controller = pints.MCMCController(
+            log_pdf, n_chains, x0, sigma0=sigma0, method=method)
+        controller.set_max_iterations(n_iterations)
+        controller.set_log_to_screen(False)
+        set_hyperparameters_for_any_mcmc_class(controller, method,
+                                               method_hyper_parameters)
+
+        chains = run_and_throw_away_warmup(controller, n_warmup)
+
+        super().__init__(log_pdf, chains)
+
+
+def set_hyperparameters_for_any_mcmc_class(controller, method,
+                                           method_hyper_parameters):
+    """ Sets hyperparameters for any MCMC class. """
+    if method_hyper_parameters is not None:
+        if issubclass(method, pints.MultiChainMCMC):
+            controller.sampler().set_hyper_parameters(
+                method_hyper_parameters)
+        else:
+            for sampler in controller.samplers():
+                sampler.set_hyper_parameters(method_hyper_parameters)
+
+
+def run_and_throw_away_warmup(controller, n_warmup):
+    """ Runs sampling then throws away warmup. """
+    chains = controller.run()
+    return chains[:, n_warmup:]
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 82b8b9727e..9d70c71d87 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -9,13 +9,28 @@
 
 import pints
 
-from ._problems import RunMcmcMethodOnTwoDimGaussian
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana)
 
 
 def test_haario_bardenet_acmc_on_two_dim_gaussian():
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioBardenetACMC,
-        n_chains=3,
+        n_chains=4,
+        n_iterations=4000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_haario_bardenet_acmc_on_banana():
+    problem = RunMcmcMethodOnBanana(
+        method=pints.HaarioBardenetACMC,
+        n_chains=4,
         n_iterations=4000,
         n_warmup=1000
     )

From f42b5cf35f4f3f9f8126c55dec2c3b444a8faa26 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Mon, 22 Mar 2021 23:59:45 +0000
Subject: [PATCH 19/73] Added gaussian and banana tests for differential
 evolution

---
 .../functionaltests/differential_evolution.py | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 pints/functionaltests/differential_evolution.py

diff --git a/pints/functionaltests/differential_evolution.py b/pints/functionaltests/differential_evolution.py
new file mode 100644
index 0000000000..286864b13b
--- /dev/null
+++ b/pints/functionaltests/differential_evolution.py
@@ -0,0 +1,41 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana)
+
+
+def test_differential_evolution_on_two_dim_gaussian():
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.DifferentialEvolutionMCMC,
+        n_chains=10,
+        n_iterations=10000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_differential_evolution_on_banana():
+    problem = RunMcmcMethodOnBanana(
+        method=pints.DifferentialEvolutionMCMC,
+        n_chains=20,
+        n_iterations=5000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 774d4606862c9e2ac9a17a93ebfc09932abb4ec6 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 23 Mar 2021 10:22:49 +0000
Subject: [PATCH 20/73] Moved controller initialisation methods to parent class

---
 pints/functionaltests/_problems.py | 41 ++++++++++++------------------
 1 file changed, 16 insertions(+), 25 deletions(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index bb10511914..10f348271a 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -11,9 +11,17 @@
 
 class RunMcmcMethodOnProblem(object):
 
-    def __init__(self, log_pdf, chains):
+    def __init__(self, log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                 n_warmup, method_hyper_parameters):
         self.log_pdf = log_pdf
-        self.chains = chains
+
+        controller = pints.MCMCController(
+            log_pdf, n_chains, x0, sigma0=sigma0, method=method)
+        controller.set_max_iterations(n_iterations)
+        controller.set_log_to_screen(False)
+        set_hyperparameters_for_any_mcmc_class(controller, method,
+                                               method_hyper_parameters)
+        self.chains = run_and_throw_away_warmup(controller, n_warmup)
 
     def estimate_kld(self):
         """
@@ -57,19 +65,11 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
         log_prior = pints.ComposedLogPrior(
             pints.GaussianLogPrior(mean=0, sd=100),
             pints.GaussianLogPrior(mean=0, sd=100))
-        initial_parameters = log_prior.sample(n=n_chains)
-
-        # Set up sampler
-        controller = pints.MCMCController(
-            log_pdf, n_chains, initial_parameters, method=method)
-        controller.set_max_iterations(n_iterations)
-        controller.set_log_to_screen(False)
-        set_hyperparameters_for_any_mcmc_class(controller, method,
-                                               method_hyper_parameters)
-
-        chains = run_and_throw_away_warmup(controller, n_warmup)
+        x0 = log_prior.sample(n=n_chains)
+        sigma0 = None
 
-        super().__init__(log_pdf, chains)
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
 
 
 class RunMcmcMethodOnBanana(RunMcmcMethodOnProblem):
@@ -87,17 +87,8 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
         x0 = log_prior.sample(n_chains)
         sigma0 = np.diag(np.array([1, 3]))
 
-        # Set up sampler
-        controller = pints.MCMCController(
-            log_pdf, n_chains, x0, sigma0=sigma0, method=method)
-        controller.set_max_iterations(n_iterations)
-        controller.set_log_to_screen(False)
-        set_hyperparameters_for_any_mcmc_class(controller, method,
-                                               method_hyper_parameters)
-
-        chains = run_and_throw_away_warmup(controller, n_warmup)
-
-        super().__init__(log_pdf, chains)
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
 
 
 def set_hyperparameters_for_any_mcmc_class(controller, method,

From 6d8c5530200f7e7e20ec82482696792aa54569da Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 23 Mar 2021 10:32:11 +0000
Subject: [PATCH 21/73] Added dream

---
 pints/functionaltests/dream.py | 41 ++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 pints/functionaltests/dream.py

diff --git a/pints/functionaltests/dream.py b/pints/functionaltests/dream.py
new file mode 100644
index 0000000000..c86096a551
--- /dev/null
+++ b/pints/functionaltests/dream.py
@@ -0,0 +1,41 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana)
+
+
+def test_dream_on_two_dim_gaussian():
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.DreamMCMC,
+        n_chains=10,
+        n_iterations=10000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_dream_on_banana():
+    problem = RunMcmcMethodOnBanana(
+        method=pints.DreamMCMC,
+        n_chains=20,
+        n_iterations=5000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 63a674d076e3a35d773dc06f2b1a0e226c5fb6ae Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 23 Mar 2021 10:35:47 +0000
Subject: [PATCH 22/73] Added Haario to functional tests

---
 pints/functionaltests/haario_ac.py | 41 ++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 pints/functionaltests/haario_ac.py

diff --git a/pints/functionaltests/haario_ac.py b/pints/functionaltests/haario_ac.py
new file mode 100644
index 0000000000..d78b48c801
--- /dev/null
+++ b/pints/functionaltests/haario_ac.py
@@ -0,0 +1,41 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana)
+
+
+def test_haario_acmc_on_two_dim_gaussian():
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.HaarioACMC,
+        n_chains=4,
+        n_iterations=4000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_haario_acmc_on_banana():
+    problem = RunMcmcMethodOnBanana(
+        method=pints.HaarioACMC,
+        n_chains=4,
+        n_iterations=4000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From d3d8f41c4ba970f54bfdbd0aa81cc7828727df22 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 23 Mar 2021 15:08:11 +0000
Subject: [PATCH 23/73] added functional tests for emcee hammer

---
 pints/functionaltests/emcee_hammer.py | 41 +++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 pints/functionaltests/emcee_hammer.py

diff --git a/pints/functionaltests/emcee_hammer.py b/pints/functionaltests/emcee_hammer.py
new file mode 100644
index 0000000000..4e74a609e6
--- /dev/null
+++ b/pints/functionaltests/emcee_hammer.py
@@ -0,0 +1,41 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana)
+
+
+def test_emcee_hammer_on_two_dim_gaussian():
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.EmceeHammerMCMC,
+        n_chains=4,
+        n_iterations=100000,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_emcee_hammer_on_banana():
+    problem = RunMcmcMethodOnBanana(
+        method=pints.EmceeHammerMCMC,
+        n_chains=4,
+        n_iterations=10000,
+        n_warmup=2000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From d076b1a6e2ce0006a5e14491d88d065b15dd2053 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 23 Mar 2021 23:59:47 +0000
Subject: [PATCH 24/73] Added sample sizes as optional parameter for tests

- Added simple egg box problem
- Cleaned up KL divergence method
---
 pints/functionaltests/_problems.py            | 28 ++++++---
 .../functionaltests/differential_evolution.py | 12 ++--
 pints/functionaltests/dream.py                | 12 ++--
 pints/functionaltests/emcee_hammer.py         | 12 ++--
 pints/functionaltests/haario_ac.py            | 12 ++--
 pints/functionaltests/haario_bardenet_acmc.py | 12 ++--
 pints/functionaltests/population.py           | 62 +++++++++++++++++++
 7 files changed, 121 insertions(+), 29 deletions(-)
 create mode 100644 pints/functionaltests/population.py

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 10f348271a..a5539f2e44 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -25,14 +25,9 @@ def __init__(self, log_pdf, x0, sigma0, method, n_chains, n_iterations,
 
     def estimate_kld(self):
         """
-        Estimates and returns the Kullback-Leibler divergence between the
-        approximate posterior and the true posterior assuming that the
-        approximated posterior has Gaussian shape.
+        Estimates the Kullback-Leibler divergence.
         """
-        # Pool samples from chains
-        chains_x = self.chains[:, :, 0].flatten()
-        chains_y = self.chains[:, :, 1].flatten()
-        chains = np.vstack([chains_x, chains_y]).T
+        chains = np.vstack(self.chains)
 
         return self.log_pdf.kl_divergence(chains)
 
@@ -74,9 +69,8 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
 class RunMcmcMethodOnBanana(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `pints.TwistedGaussianLogPDF`.
+    Tests a given MCMC method on `pints.toy.TwistedGaussianLogPDF`.
     """
-
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
         log_pdf = pints.toy.TwistedGaussianLogPDF(dimension=2, b=0.1)
@@ -91,6 +85,22 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+class RunMcmcMethodOnSimpleEggBox(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `pints.toy.SimpleEggBoxLogPDF`.
+    """
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        sigma = 2
+        r = 4
+        log_pdf = pints.toy.SimpleEggBoxLogPDF(sigma, r)
+        x0 = np.random.uniform(-15, 15, size=(n_chains, 2))
+        sigma0 = None
+
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
+
+
 def set_hyperparameters_for_any_mcmc_class(controller, method,
                                            method_hyper_parameters):
     """ Sets hyperparameters for any MCMC class. """
diff --git a/pints/functionaltests/differential_evolution.py b/pints/functionaltests/differential_evolution.py
index 286864b13b..deefadef09 100644
--- a/pints/functionaltests/differential_evolution.py
+++ b/pints/functionaltests/differential_evolution.py
@@ -13,11 +13,13 @@
                         RunMcmcMethodOnBanana)
 
 
-def test_differential_evolution_on_two_dim_gaussian():
+def test_differential_evolution_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
-        n_iterations=10000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
@@ -27,11 +29,13 @@ def test_differential_evolution_on_two_dim_gaussian():
     }
 
 
-def test_differential_evolution_on_banana():
+def test_differential_evolution_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
     problem = RunMcmcMethodOnBanana(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
-        n_iterations=5000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
diff --git a/pints/functionaltests/dream.py b/pints/functionaltests/dream.py
index c86096a551..c1f357d855 100644
--- a/pints/functionaltests/dream.py
+++ b/pints/functionaltests/dream.py
@@ -13,11 +13,13 @@
                         RunMcmcMethodOnBanana)
 
 
-def test_dream_on_two_dim_gaussian():
+def test_dream_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.DreamMCMC,
         n_chains=10,
-        n_iterations=10000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
@@ -27,11 +29,13 @@ def test_dream_on_two_dim_gaussian():
     }
 
 
-def test_dream_on_banana():
+def test_dream_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
     problem = RunMcmcMethodOnBanana(
         method=pints.DreamMCMC,
         n_chains=20,
-        n_iterations=5000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
diff --git a/pints/functionaltests/emcee_hammer.py b/pints/functionaltests/emcee_hammer.py
index 4e74a609e6..fbbdee8d1c 100644
--- a/pints/functionaltests/emcee_hammer.py
+++ b/pints/functionaltests/emcee_hammer.py
@@ -13,11 +13,13 @@
                         RunMcmcMethodOnBanana)
 
 
-def test_emcee_hammer_on_two_dim_gaussian():
+def test_emcee_hammer_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=4,
-        n_iterations=100000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
@@ -27,11 +29,13 @@ def test_emcee_hammer_on_two_dim_gaussian():
     }
 
 
-def test_emcee_hammer_on_banana():
+def test_emcee_hammer_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
     problem = RunMcmcMethodOnBanana(
         method=pints.EmceeHammerMCMC,
         n_chains=4,
-        n_iterations=10000,
+        n_iterations=n_iterations,
         n_warmup=2000
     )
 
diff --git a/pints/functionaltests/haario_ac.py b/pints/functionaltests/haario_ac.py
index d78b48c801..1b23a4b118 100644
--- a/pints/functionaltests/haario_ac.py
+++ b/pints/functionaltests/haario_ac.py
@@ -13,11 +13,13 @@
                         RunMcmcMethodOnBanana)
 
 
-def test_haario_acmc_on_two_dim_gaussian():
+def test_haario_acmc_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
-        n_iterations=4000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
@@ -27,11 +29,13 @@ def test_haario_acmc_on_two_dim_gaussian():
     }
 
 
-def test_haario_acmc_on_banana():
+def test_haario_acmc_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
     problem = RunMcmcMethodOnBanana(
         method=pints.HaarioACMC,
         n_chains=4,
-        n_iterations=4000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 9d70c71d87..4b9e356b2c 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -13,11 +13,13 @@
                         RunMcmcMethodOnBanana)
 
 
-def test_haario_bardenet_acmc_on_two_dim_gaussian():
+def test_haario_bardenet_acmc_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
-        n_iterations=4000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
@@ -27,11 +29,13 @@ def test_haario_bardenet_acmc_on_two_dim_gaussian():
     }
 
 
-def test_haario_bardenet_acmc_on_banana():
+def test_haario_bardenet_acmc_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
     problem = RunMcmcMethodOnBanana(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
-        n_iterations=4000,
+        n_iterations=n_iterations,
         n_warmup=1000
     )
 
diff --git a/pints/functionaltests/population.py b/pints/functionaltests/population.py
new file mode 100644
index 0000000000..9233965bc5
--- /dev/null
+++ b/pints/functionaltests/population.py
@@ -0,0 +1,62 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnSimpleEggBox)
+
+
+def test_population_mcmc_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 20000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.PopulationMCMC,
+        n_chains=1,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_population_mcmc_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.PopulationMCMC,
+        n_chains=1,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_population_mcmc_on_simple_egg_box(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 16000
+    problem = RunMcmcMethodOnSimpleEggBox(
+        method=pints.PopulationMCMC,
+        n_chains=1,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From e9fd8ab168769e60ec73048f00ebd2737ede1bd3 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Wed, 24 Mar 2021 00:57:44 +0000
Subject: [PATCH 25/73] Added high dim Gaussian problem

- Also added Hamiltonian func tests
---
 pints/functionaltests/_problems.py   | 15 +++++++
 pints/functionaltests/hamiltonian.py | 64 ++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+)
 create mode 100644 pints/functionaltests/hamiltonian.py

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index a5539f2e44..9b355845a8 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -101,6 +101,21 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+#TODO add evaluateS1 to high dim Gaussian
+class RunMcmcMethodOnHighDimensionalGaussian(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `pints.toy.HighDimensionalGaussianLogPDF`.
+    """
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        log_pdf = pints.toy.HighDimensionalGaussianLogPDF()
+        x0 = np.random.uniform(-25, 25, size=(n_chains, 20))
+        sigma0 = None
+
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
+
+
 def set_hyperparameters_for_any_mcmc_class(controller, method,
                                            method_hyper_parameters):
     """ Sets hyperparameters for any MCMC class. """
diff --git a/pints/functionaltests/hamiltonian.py b/pints/functionaltests/hamiltonian.py
new file mode 100644
index 0000000000..e8711d4db3
--- /dev/null
+++ b/pints/functionaltests/hamiltonian.py
@@ -0,0 +1,64 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnHighDimensionalGaussian)
+
+
+def test_hamiltonian_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 1000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.HamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=200,
+        method_hyper_parameters=[20, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_hamiltonian_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.HamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=1000,
+        method_hyper_parameters=[20, 2]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_hamiltonian_on_high_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnHighDimensionalGaussian(
+        method=pints.HamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 4f4b9ea2821ee20a7ee1926065ca5ea90256d8c8 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Mon, 19 Apr 2021 18:32:02 +0100
Subject: [PATCH 26/73] Added nuts problems

---
 pints/functionaltests/hamiltonian.py |  5 ++-
 pints/functionaltests/nuts.py        | 62 ++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 2 deletions(-)
 create mode 100644 pints/functionaltests/nuts.py

diff --git a/pints/functionaltests/hamiltonian.py b/pints/functionaltests/hamiltonian.py
index e8711d4db3..357d1a5001 100644
--- a/pints/functionaltests/hamiltonian.py
+++ b/pints/functionaltests/hamiltonian.py
@@ -50,12 +50,13 @@ def test_hamiltonian_on_banana(n_iterations=None):
 
 def test_hamiltonian_on_high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
-        n_iterations = 2000
+        n_iterations = 4000
     problem = RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=1000,
+        method_hyper_parameters=[20, 1]
     )
 
     return {
diff --git a/pints/functionaltests/nuts.py b/pints/functionaltests/nuts.py
new file mode 100644
index 0000000000..a1fb5c4097
--- /dev/null
+++ b/pints/functionaltests/nuts.py
@@ -0,0 +1,62 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnHighDimensionalGaussian)
+
+
+def test_nuts_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 1000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.NoUTurnMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=200
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_nuts_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.NoUTurnMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_nuts_on_high_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
+    problem = RunMcmcMethodOnHighDimensionalGaussian(
+        method=pints.NoUTurnMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 73c8a8c461172ed7eb2c9bcb24398ca07e13d78c Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 20 Apr 2021 11:25:11 +0100
Subject: [PATCH 27/73] Added correlated Gaussian and started to add DRAM but
 found a bug

---
 pints/functionaltests/_problems.py | 16 +++++++++++
 pints/functionaltests/dram.py      | 45 ++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)
 create mode 100644 pints/functionaltests/dram.py

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 9b355845a8..0cd4c5dea8 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -116,6 +116,22 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+class RunMcmcMethodOnCorrelatedGaussian(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `pints.toy.HighDimensionalGaussianLogPDF`
+    but using a 6-dimensional problem with higher correlation.
+    """
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        log_pdf = pints.toy.HighDimensionalGaussianLogPDF(
+            dimension=6, rho=0.8)
+        x0 = np.random.uniform(-25, 25, size=(n_chains, 6))
+        sigma0 = None
+
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
+
+
 def set_hyperparameters_for_any_mcmc_class(controller, method,
                                            method_hyper_parameters):
     """ Sets hyperparameters for any MCMC class. """
diff --git a/pints/functionaltests/dram.py b/pints/functionaltests/dram.py
new file mode 100644
index 0000000000..da18c2887c
--- /dev/null
+++ b/pints/functionaltests/dram.py
@@ -0,0 +1,45 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnCorrelatedGaussian)
+
+
+def test_dram_acmc_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 8000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.DramACMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=2000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_dram_acmc_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 8000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.DramACMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=4000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 7bdef09f4e420b23f632b0f410a987e93dd9709e Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 20 Apr 2021 22:37:28 +0100
Subject: [PATCH 28/73] Added banana test for dram

---
 pints/functionaltests/dram.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/pints/functionaltests/dram.py b/pints/functionaltests/dram.py
index da18c2887c..cdc3b133b8 100644
--- a/pints/functionaltests/dram.py
+++ b/pints/functionaltests/dram.py
@@ -10,7 +10,8 @@
 import pints
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnCorrelatedGaussian)
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnBanana)
 
 
 def test_dram_acmc_on_two_dim_gaussian(n_iterations=None):
@@ -29,6 +30,22 @@ def test_dram_acmc_on_two_dim_gaussian(n_iterations=None):
     }
 
 
+def test_haario_acmc_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.DramACMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
 def test_dram_acmc_on_correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000

From 8f528d2874ab52c17928c96e0b4cf6fca5f6c440 Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 20 Apr 2021 23:12:54 +0100
Subject: [PATCH 29/73] Simplified starting points for problems.

---
 pints/functionaltests/_problems.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 0cd4c5dea8..191c3436e8 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -58,8 +58,8 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
         # Get initial parameters
         log_prior = pints.ComposedLogPrior(
-            pints.GaussianLogPrior(mean=0, sd=100),
-            pints.GaussianLogPrior(mean=0, sd=100))
+            pints.GaussianLogPrior(mean=0, sd=10),
+            pints.GaussianLogPrior(mean=0, sd=10))
         x0 = log_prior.sample(n=n_chains)
         sigma0 = None
 
@@ -109,7 +109,7 @@ class RunMcmcMethodOnHighDimensionalGaussian(RunMcmcMethodOnProblem):
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
         log_pdf = pints.toy.HighDimensionalGaussianLogPDF()
-        x0 = np.random.uniform(-25, 25, size=(n_chains, 20))
+        x0 = np.random.uniform(-4, 4, size=(n_chains, 20))
         sigma0 = None
 
         super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
@@ -125,7 +125,7 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
         log_pdf = pints.toy.HighDimensionalGaussianLogPDF(
             dimension=6, rho=0.8)
-        x0 = np.random.uniform(-25, 25, size=(n_chains, 6))
+        x0 = np.random.uniform(-4, 4, size=(n_chains, 6))
         sigma0 = None
 
         super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,

From 7f57caf724894cf9b7c5aee01b25c3e9d6f9d9ed Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 20 Apr 2021 23:19:15 +0100
Subject: [PATCH 30/73] Added correlated Gaussian test for haario-bardenet

---
 pints/functionaltests/haario_bardenet_acmc.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 4b9e356b2c..910f32ea7d 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -10,7 +10,8 @@
 import pints
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana)
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnCorrelatedGaussian)
 
 
 def test_haario_bardenet_acmc_on_two_dim_gaussian(n_iterations=None):
@@ -43,3 +44,19 @@ def test_haario_bardenet_acmc_on_banana(n_iterations=None):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_dram_acmc_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 8000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.HaarioBardenetACMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=4000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From d9ef3c600b2320ccac79be905316262a5e9d425a Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 20 Apr 2021 23:21:05 +0100
Subject: [PATCH 31/73] Corrected func test name for haario bardenet

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

diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 910f32ea7d..93ed599b99 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -46,7 +46,7 @@ def test_haario_bardenet_acmc_on_banana(n_iterations=None):
     }
 
 
-def test_dram_acmc_on_correlated_gaussian(n_iterations=None):
+def test_haario_bardenet_on_correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(

From 8429f1062f9480773a31bb6531729cb04b22b71a Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 20 Apr 2021 23:21:25 +0100
Subject: [PATCH 32/73] Update haario_bardenet_acmc.py

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

diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 93ed599b99..7cf99eb30e 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -46,7 +46,7 @@ def test_haario_bardenet_acmc_on_banana(n_iterations=None):
     }
 
 
-def test_haario_bardenet_on_correlated_gaussian(n_iterations=None):
+def test_haario_bardenet_acmc_on_correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(

From 88a48035db528fecf651e52e6a27c7fd75b9da8f Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Wed, 21 Apr 2021 00:24:50 +0100
Subject: [PATCH 33/73] Added annulus problem for Haario-bardenet

---
 pints/functionaltests/_problems.py            | 20 +++++++++++++++++++
 pints/functionaltests/haario_bardenet_acmc.py | 19 +++++++++++++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 191c3436e8..808cb836ba 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -45,6 +45,12 @@ def estimate_mean_ess(self):
 
         return np.mean(ess)
 
+    def estimate_distance(self):
+        """
+        Estimates a measure of distance for the `pints.AnnulusLogPDF` class.
+        """
+        return self.log_pdf.distance(np.vstack(self.chains))
+
 
 class RunMcmcMethodOnTwoDimGaussian(RunMcmcMethodOnProblem):
     """
@@ -132,6 +138,20 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+class RunMcmcMethodOnAnnulus(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `pints.AnnulusLogPDF`.
+    """
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        log_pdf = pints.toy.AnnulusLogPDF()
+        x0 = log_pdf.sample(n_chains)
+        sigma0 = None
+
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
+
+
 def set_hyperparameters_for_any_mcmc_class(controller, method,
                                            method_hyper_parameters):
     """ Sets hyperparameters for any MCMC class. """
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 7cf99eb30e..15b0ac090d 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -11,7 +11,8 @@
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
                         RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian)
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus)
 
 
 def test_haario_bardenet_acmc_on_two_dim_gaussian(n_iterations=None):
@@ -60,3 +61,19 @@ def test_haario_bardenet_acmc_on_correlated_gaussian(n_iterations=None):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_haario_bardenet_acmc_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.HaarioBardenetACMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=2000
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From d1b0c9a8f85cf0c8bd3bee4ac117602ff84b6714 Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 26 Apr 2021 22:43:59 +0100
Subject: [PATCH 34/73] expose some more functional tests

---
 pints/functionaltests/__init__.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index ed69e870e9..a3e83e9816 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -4,4 +4,10 @@
 # copyright notice and full license details.
 #
 
+from .differential_evolution import test_differential_evolution_on_banana
+from .differential_evolution import test_differential_evolution_on_two_dim_gaussian
+
+from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_annulus
+from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_banana
+from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_correlated_gaussian
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_two_dim_gaussian

From ac0bf23f22ab042ba95c41a5a8607f3bd69b238e Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Mon, 26 Apr 2021 23:17:59 +0100
Subject: [PATCH 35/73] bump

---
 pints/functionaltests/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index a3e83e9816..388dfb255e 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -11,3 +11,4 @@
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_banana
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_correlated_gaussian
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_two_dim_gaussian
+

From 7a7d9abc5f3b9d23604ed4ed86869d723a7e125c Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 4 May 2021 14:03:59 +0100
Subject: [PATCH 36/73] Added problems for emcee hammer

---
 pints/functionaltests/emcee_hammer.py | 40 +++++++++++++++++++++++++--
 1 file changed, 37 insertions(+), 3 deletions(-)

diff --git a/pints/functionaltests/emcee_hammer.py b/pints/functionaltests/emcee_hammer.py
index fbbdee8d1c..1bc13b1a0f 100644
--- a/pints/functionaltests/emcee_hammer.py
+++ b/pints/functionaltests/emcee_hammer.py
@@ -10,7 +10,9 @@
 import pints
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana)
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus)
 
 
 def test_emcee_hammer_on_two_dim_gaussian(n_iterations=None):
@@ -18,7 +20,7 @@ def test_emcee_hammer_on_two_dim_gaussian(n_iterations=None):
         n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.EmceeHammerMCMC,
-        n_chains=4,
+        n_chains=10,
         n_iterations=n_iterations,
         n_warmup=1000
     )
@@ -34,7 +36,7 @@ def test_emcee_hammer_on_banana(n_iterations=None):
         n_iterations = 10000
     problem = RunMcmcMethodOnBanana(
         method=pints.EmceeHammerMCMC,
-        n_chains=4,
+        n_chains=10,
         n_iterations=n_iterations,
         n_warmup=2000
     )
@@ -43,3 +45,35 @@ def test_emcee_hammer_on_banana(n_iterations=None):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_emcee_hammer_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 8000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.EmceeHammerMCMC,
+        n_chains=10,
+        n_iterations=n_iterations,
+        n_warmup=4000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_emcee_hammer_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.EmceeHammerMCMC,
+        n_chains=10,
+        n_iterations=n_iterations,
+        n_warmup=2000
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 81436e0d890ec671c85042ada31997e4a8d698ab Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Tue, 4 May 2021 23:02:19 +0100
Subject: [PATCH 37/73] Added cone problem

---
 pints/functionaltests/_problems.py    | 36 ++++++++++++++++++++++++++-
 pints/functionaltests/emcee_hammer.py | 36 ++++++++++++++++++++++++++-
 2 files changed, 70 insertions(+), 2 deletions(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 808cb836ba..dde37b34d3 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -29,7 +29,7 @@ def estimate_kld(self):
         """
         chains = np.vstack(self.chains)
 
-        return self.log_pdf.kl_divergence(chains)
+        return np.mean(self.log_pdf.kl_divergence(chains))
 
     def estimate_mean_ess(self):
         """
@@ -152,6 +152,40 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+class RunMcmcMethodOnMultimodalGaussian(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `MultimodalGaussianLogPDF`.
+    """
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        covariances = [[[1, 0], [0, 1]],
+                       [[2, 0.8], [0.8, 3]],
+                       [[1, -0.5], [-0.5, 1]]]
+        log_pdf = pints.toy.MultimodalGaussianLogPDF(modes=[[0, 0],
+                                                            [5, 10],
+                                                            [10, 0]],
+                                                     covariances=covariances)
+        x0 = log_pdf.sample(n_chains)
+        sigma0 = None
+
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
+
+
+class RunMcmcMethodOnCone(RunMcmcMethodOnProblem):
+    """
+    Tests a given MCMC method on `MultimodalGaussianLogPDF`.
+    """
+    def __init__(self, method, n_chains, n_iterations, n_warmup,
+                 method_hyper_parameters=None):
+        log_pdf = pints.toy.ConeLogPDF(dimensions=2, beta=0.6)
+        x0 = log_pdf.sample(n_chains)
+        sigma0 = None
+
+        super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
+                         n_warmup, method_hyper_parameters)
+
+
 def set_hyperparameters_for_any_mcmc_class(controller, method,
                                            method_hyper_parameters):
     """ Sets hyperparameters for any MCMC class. """
diff --git a/pints/functionaltests/emcee_hammer.py b/pints/functionaltests/emcee_hammer.py
index 1bc13b1a0f..b1ebb1c615 100644
--- a/pints/functionaltests/emcee_hammer.py
+++ b/pints/functionaltests/emcee_hammer.py
@@ -12,7 +12,9 @@
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
                         RunMcmcMethodOnBanana,
                         RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus)
+                        RunMcmcMethodOnAnnulus,
+                        RunMcmcMethodOnMultimodalGaussian,
+                        RunMcmcMethodOnCone)
 
 
 def test_emcee_hammer_on_two_dim_gaussian(n_iterations=None):
@@ -77,3 +79,35 @@ def test_emcee_hammer_on_annulus(n_iterations=None):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_emcee_hammer_on_multimodal_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnMultimodalGaussian(
+        method=pints.EmceeHammerMCMC,
+        n_chains=10,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_emcee_hammer_on_cone(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnCone(
+        method=pints.EmceeHammerMCMC,
+        n_chains=10,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 8ae5c5f0b43300e11122c21219b5c1e6ed1cbe1b Mon Sep 17 00:00:00 2001
From: ben18785 <ben.c.lambert@gmail.com>
Date: Wed, 5 May 2021 22:08:38 +0100
Subject: [PATCH 38/73] Added monomial gamma problems

---
 pints/functionaltests/_problems.py            |   1 -
 .../monomial_gamma_hamiltonian.py             | 137 ++++++++++++++++++
 2 files changed, 137 insertions(+), 1 deletion(-)
 create mode 100644 pints/functionaltests/monomial_gamma_hamiltonian.py

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index dde37b34d3..6b7c0a4448 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -107,7 +107,6 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
-#TODO add evaluateS1 to high dim Gaussian
 class RunMcmcMethodOnHighDimensionalGaussian(RunMcmcMethodOnProblem):
     """
     Tests a given MCMC method on `pints.toy.HighDimensionalGaussianLogPDF`.
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian.py b/pints/functionaltests/monomial_gamma_hamiltonian.py
new file mode 100644
index 0000000000..1ef623106f
--- /dev/null
+++ b/pints/functionaltests/monomial_gamma_hamiltonian.py
@@ -0,0 +1,137 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnHighDimensionalGaussian,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus,
+                        RunMcmcMethodOnMultimodalGaussian,
+                        RunMcmcMethodOnCone)
+
+
+def test_monomial_gamma_hamiltonian_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 1000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=200,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_monomial_gamma_hamiltonian_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_monomial_gamma_hamiltonian_on_high_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnHighDimensionalGaussian(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_monomial_gamma_hamiltonian_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_monomial_gamma_hamiltonian_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_monomial_gamma_hamiltonian_on_multimodal_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnMultimodalGaussian(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_monomial_gamma_hamiltonian_on_cone(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnCone(
+        method=pints.MonomialGammaHamiltonianMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 9e48d20d0dadd464a91240815837560d1bc4675f Mon Sep 17 00:00:00 2001
From: Chon Lok Lei <chonloklei@gmail.com>
Date: Tue, 25 May 2021 17:16:49 +0800
Subject: [PATCH 39/73] Delete empty ending line

---
 pints/functionaltests/__init__.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index 388dfb255e..a3e83e9816 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -11,4 +11,3 @@
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_banana
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_correlated_gaussian
 from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_two_dim_gaussian
-

From 5eccd573b63d277773fed0fa665881540c9473f8 Mon Sep 17 00:00:00 2001
From: Chon Lok Lei <chonloklei@gmail.com>
Date: Tue, 25 May 2021 17:17:33 +0800
Subject: [PATCH 40/73] Rename to haario_acmc.py and add correlated Gaussian
 problem

---
 .../{haario_ac.py => haario_acmc.py}          | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
 rename pints/functionaltests/{haario_ac.py => haario_acmc.py} (68%)

diff --git a/pints/functionaltests/haario_ac.py b/pints/functionaltests/haario_acmc.py
similarity index 68%
rename from pints/functionaltests/haario_ac.py
rename to pints/functionaltests/haario_acmc.py
index 1b23a4b118..2a24497aef 100644
--- a/pints/functionaltests/haario_ac.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -10,7 +10,8 @@
 import pints
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana)
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnCorrelatedGaussian)
 
 
 def test_haario_acmc_on_two_dim_gaussian(n_iterations=None):
@@ -43,3 +44,19 @@ def test_haario_acmc_on_banana(n_iterations=None):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_haario_acmc_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 8000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.HaarioACMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=4000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 20adc1606b3de5a4db130ec01125d193c1ae60fa Mon Sep 17 00:00:00 2001
From: rcw5890 <richard.creswell@hertford.ox.ac.uk>
Date: Fri, 28 May 2021 20:27:09 +0100
Subject: [PATCH 41/73] add correlated gaussian and annulus to differential
 evolution functests

---
 .../functionaltests/differential_evolution.py | 36 ++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/pints/functionaltests/differential_evolution.py b/pints/functionaltests/differential_evolution.py
index deefadef09..9c9a634652 100644
--- a/pints/functionaltests/differential_evolution.py
+++ b/pints/functionaltests/differential_evolution.py
@@ -10,7 +10,9 @@
 import pints
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana)
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus)
 
 
 def test_differential_evolution_on_two_dim_gaussian(n_iterations=None):
@@ -43,3 +45,35 @@ def test_differential_evolution_on_banana(n_iterations=None):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_differential_evolution_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.DifferentialEvolutionMCMC,
+        n_chains=20,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_differential_evolution_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.DifferentialEvolutionMCMC,
+        n_chains=10,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From de66391a0aeefc70d83069434213a6179695d346 Mon Sep 17 00:00:00 2001
From: rcw5890 <richard.creswell@hertford.ox.ac.uk>
Date: Mon, 31 May 2021 14:37:05 +0100
Subject: [PATCH 42/73] add correlated gaussian and annulus to dream functests

---
 pints/functionaltests/dream.py | 36 +++++++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/pints/functionaltests/dream.py b/pints/functionaltests/dream.py
index c1f357d855..70a9a722ec 100644
--- a/pints/functionaltests/dream.py
+++ b/pints/functionaltests/dream.py
@@ -10,7 +10,9 @@
 import pints
 
 from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana)
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus)
 
 
 def test_dream_on_two_dim_gaussian(n_iterations=None):
@@ -43,3 +45,35 @@ def test_dream_on_banana(n_iterations=None):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+def test_dream_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.DreamMCMC,
+        n_chains=20,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_dream_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.DreamMCMC,
+        n_chains=10,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From d55f7d2e9653b0244fdcbdbdd422da4366371b6a Mon Sep 17 00:00:00 2001
From: Chon Lok Lei <chonloklei@gmail.com>
Date: Tue, 10 Aug 2021 12:16:35 +0800
Subject: [PATCH 43/73] Add problems for Metropolis functests

---
 pints/functionaltests/metropolis.py | 62 +++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 pints/functionaltests/metropolis.py

diff --git a/pints/functionaltests/metropolis.py b/pints/functionaltests/metropolis.py
new file mode 100644
index 0000000000..f05a87ffdc
--- /dev/null
+++ b/pints/functionaltests/metropolis.py
@@ -0,0 +1,62 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnCorrelatedGaussian)
+
+
+def test_metropolis_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.MetropolisRandomWalkMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_metropolis_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 4000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.MetropolisRandomWalkMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=1000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_metropolis_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 8000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.MetropolisRandomWalkMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=4000
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 494574ff235c370ccddb6b15d5884311210a2d70 Mon Sep 17 00:00:00 2001
From: rcw5890 <richard.creswell@hertford.ox.ac.uk>
Date: Tue, 10 Aug 2021 10:52:05 +0100
Subject: [PATCH 44/73] add relativistic problems

---
 pints/functionaltests/relativistic.py | 137 ++++++++++++++++++++++++++
 1 file changed, 137 insertions(+)
 create mode 100644 pints/functionaltests/relativistic.py

diff --git a/pints/functionaltests/relativistic.py b/pints/functionaltests/relativistic.py
new file mode 100644
index 0000000000..4fc3371d80
--- /dev/null
+++ b/pints/functionaltests/relativistic.py
@@ -0,0 +1,137 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnHighDimensionalGaussian,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus,
+                        RunMcmcMethodOnMultimodalGaussian,
+                        RunMcmcMethodOnCone)
+
+
+def test_relativistic_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 1000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=200,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_relativistic_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_relativistic_on_high_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnHighDimensionalGaussian(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_relativistic_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_relativistic_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_relativistic_on_multimodal_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnMultimodalGaussian(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_relativistic_on_cone(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnCone(
+        method=pints.RelativisticMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[20, 1, 1, 1]
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From aa55906844a5b5fa041b5e87210a8c21790e9a0c Mon Sep 17 00:00:00 2001
From: FarmHJ <huijia-farm_95@hotmail.com>
Date: Tue, 10 Aug 2021 14:29:32 +0100
Subject: [PATCH 45/73] Functional testing for slice stepout

---
 pints/functionaltests/slice_stepout.py | 129 +++++++++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 pints/functionaltests/slice_stepout.py

diff --git a/pints/functionaltests/slice_stepout.py b/pints/functionaltests/slice_stepout.py
new file mode 100644
index 0000000000..9ca5af4763
--- /dev/null
+++ b/pints/functionaltests/slice_stepout.py
@@ -0,0 +1,129 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnHighDimensionalGaussian,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus,
+                        RunMcmcMethodOnMultimodalGaussian,
+                        RunMcmcMethodOnCone)
+
+
+def test_slice_stepout_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+def test_slice_stepout_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_slice_stepout_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_slice_stepout_on_high_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnHighDimensionalGaussian(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_slice_stepout_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 10000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=2000
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_slice_stepout_on_multimodal_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnMultimodalGaussian(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_slice_stepout_on_cone(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 5000
+    problem = RunMcmcMethodOnCone(
+        method=pints.SliceStepoutMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 3b0f96155cc13d5979f40d28bfbba4bb93e30c76 Mon Sep 17 00:00:00 2001
From: rcw5890 <richard.creswell@hertford.ox.ac.uk>
Date: Tue, 10 Aug 2021 14:46:02 +0100
Subject: [PATCH 46/73] update relativistic functional test hyperparameters

---
 pints/functionaltests/relativistic.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/pints/functionaltests/relativistic.py b/pints/functionaltests/relativistic.py
index 4fc3371d80..bad99e78ea 100644
--- a/pints/functionaltests/relativistic.py
+++ b/pints/functionaltests/relativistic.py
@@ -26,7 +26,7 @@ def test_relativistic_on_two_dim_gaussian(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=200,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {
@@ -43,7 +43,7 @@ def test_relativistic_on_banana(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=500,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {
@@ -60,7 +60,7 @@ def test_relativistic_on_high_dim_gaussian(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=500,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {
@@ -77,7 +77,7 @@ def test_relativistic_on_correlated_gaussian(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=500,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {
@@ -94,7 +94,7 @@ def test_relativistic_on_annulus(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=500,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {
@@ -111,7 +111,7 @@ def test_relativistic_on_multimodal_gaussian(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=500,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {
@@ -128,7 +128,7 @@ def test_relativistic_on_cone(n_iterations=None):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=500,
-        method_hyper_parameters=[20, 1, 1, 1]
+        method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
     return {

From 24603ab884b6d2cf20d29510a192e194e77648a3 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 02:52:41 +0100
Subject: [PATCH 47/73] Updated tests for Population MCMC.

---
 pints/functionaltests/population.py | 66 +++++++++++++++++++++++------
 1 file changed, 53 insertions(+), 13 deletions(-)

diff --git a/pints/functionaltests/population.py b/pints/functionaltests/population.py
index 9233965bc5..cb8232edf5 100644
--- a/pints/functionaltests/population.py
+++ b/pints/functionaltests/population.py
@@ -1,27 +1,40 @@
 #!/usr/bin/env python3
 #
+# Functional tests for Population MCMC.
+#
 # 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 division
-
 import pints
 
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnSimpleEggBox)
+from ._problems import (
+    RunMcmcMethodOnBanana,
+    RunMcmcMethodOnMultimodalGaussian,
+    RunMcmcMethodOnSimpleEggBox,
+    RunMcmcMethodOnTwoDimGaussian,
+)
 
 
 def test_population_mcmc_on_two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.PopulationMCMC` on a two-dimensional Gaussian with
+    means 0 and 0, and returns a dict with entries "kld" and "mean-ess".
+
+    See :class:`pints
+    """
     if n_iterations is None:
         n_iterations = 20000
+
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = RunMcmcMethodOnTwoDimGaussian(
         method=pints.PopulationMCMC,
         n_chains=1,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup
     )
 
     return {
@@ -31,13 +44,23 @@ def test_population_mcmc_on_two_dim_gaussian(n_iterations=None):
 
 
 def test_population_mcmc_on_banana(n_iterations=None):
+    """
+    Tests :class:`pints.PopulationMCMC` on a 2-d twisted Gaussian "banana"
+    problem with true solution ``(0, 0)``, and returns a dict with entries
+    "kld" and "mean-ess".
+    """
     if n_iterations is None:
-        n_iterations = 5000
+        n_iterations = 20000
+
+    n_warmup = 5000  # Needs a lot of warm-up on banana!
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = RunMcmcMethodOnBanana(
         method=pints.PopulationMCMC,
         n_chains=1,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup
     )
 
     return {
@@ -46,17 +69,34 @@ def test_population_mcmc_on_banana(n_iterations=None):
     }
 
 
-def test_population_mcmc_on_simple_egg_box(n_iterations=None):
+def test_population_mcmc_on_multimodal_gaussian(
+        n_iterations=None, n_temperatures=None):
+    """
+    Tests :class:`pints.PopulationMCMC` on a multi-modal Gaussian distribution
+    with modes at ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict
+    with entries "kld" and "mean-ess".
+    """
     if n_iterations is None:
-        n_iterations = 16000
-    problem = RunMcmcMethodOnSimpleEggBox(
+        n_iterations = 20000
+
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    method_hyper_parameters = None
+    if n_temperatures is not None:
+        method_hyper_parameters = [n_temperatures]
+
+    problem = RunMcmcMethodOnMultimodalGaussian(
         method=pints.PopulationMCMC,
         n_chains=1,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
+        method_hyper_parameters=method_hyper_parameters,
     )
 
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+

From f1f3fda5f3c3f8fd23b228a7a4fbf0e4dbc659fa Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 10:04:46 +0100
Subject: [PATCH 48/73] Made all functional test classes modules have names
 that match the methods they test (underscores instead of camelcase).

---
 .../{differential_evolution.py => differential_evolution_mcmc.py} | 0
 pints/functionaltests/{dram.py => dram_acmc.py}                   | 0
 pints/functionaltests/{dream.py => dream_mcmc.py}                 | 0
 pints/functionaltests/{emcee_hammer.py => emcee_hammer_mcmc.py}   | 0
 pints/functionaltests/{hamiltonian.py => hamiltonian_mcmc.py}     | 0
 .../{metropolis.py => metropolis_random_walk_mcmc.py}             | 0
 ...al_gamma_hamiltonian.py => monomial_gamma_hamiltonian_mcmc.py} | 0
 pints/functionaltests/{nuts.py => no_u_turn_mcmc.py}              | 0
 pints/functionaltests/{population.py => population_mcmc.py}       | 0
 pints/functionaltests/{relativistic.py => relativistic_mcmc.py}   | 0
 pints/functionaltests/{slice_stepout.py => slice_stepout_mcmc.py} | 0
 11 files changed, 0 insertions(+), 0 deletions(-)
 rename pints/functionaltests/{differential_evolution.py => differential_evolution_mcmc.py} (100%)
 rename pints/functionaltests/{dram.py => dram_acmc.py} (100%)
 rename pints/functionaltests/{dream.py => dream_mcmc.py} (100%)
 rename pints/functionaltests/{emcee_hammer.py => emcee_hammer_mcmc.py} (100%)
 rename pints/functionaltests/{hamiltonian.py => hamiltonian_mcmc.py} (100%)
 rename pints/functionaltests/{metropolis.py => metropolis_random_walk_mcmc.py} (100%)
 rename pints/functionaltests/{monomial_gamma_hamiltonian.py => monomial_gamma_hamiltonian_mcmc.py} (100%)
 rename pints/functionaltests/{nuts.py => no_u_turn_mcmc.py} (100%)
 rename pints/functionaltests/{population.py => population_mcmc.py} (100%)
 rename pints/functionaltests/{relativistic.py => relativistic_mcmc.py} (100%)
 rename pints/functionaltests/{slice_stepout.py => slice_stepout_mcmc.py} (100%)

diff --git a/pints/functionaltests/differential_evolution.py b/pints/functionaltests/differential_evolution_mcmc.py
similarity index 100%
rename from pints/functionaltests/differential_evolution.py
rename to pints/functionaltests/differential_evolution_mcmc.py
diff --git a/pints/functionaltests/dram.py b/pints/functionaltests/dram_acmc.py
similarity index 100%
rename from pints/functionaltests/dram.py
rename to pints/functionaltests/dram_acmc.py
diff --git a/pints/functionaltests/dream.py b/pints/functionaltests/dream_mcmc.py
similarity index 100%
rename from pints/functionaltests/dream.py
rename to pints/functionaltests/dream_mcmc.py
diff --git a/pints/functionaltests/emcee_hammer.py b/pints/functionaltests/emcee_hammer_mcmc.py
similarity index 100%
rename from pints/functionaltests/emcee_hammer.py
rename to pints/functionaltests/emcee_hammer_mcmc.py
diff --git a/pints/functionaltests/hamiltonian.py b/pints/functionaltests/hamiltonian_mcmc.py
similarity index 100%
rename from pints/functionaltests/hamiltonian.py
rename to pints/functionaltests/hamiltonian_mcmc.py
diff --git a/pints/functionaltests/metropolis.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
similarity index 100%
rename from pints/functionaltests/metropolis.py
rename to pints/functionaltests/metropolis_random_walk_mcmc.py
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
similarity index 100%
rename from pints/functionaltests/monomial_gamma_hamiltonian.py
rename to pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
diff --git a/pints/functionaltests/nuts.py b/pints/functionaltests/no_u_turn_mcmc.py
similarity index 100%
rename from pints/functionaltests/nuts.py
rename to pints/functionaltests/no_u_turn_mcmc.py
diff --git a/pints/functionaltests/population.py b/pints/functionaltests/population_mcmc.py
similarity index 100%
rename from pints/functionaltests/population.py
rename to pints/functionaltests/population_mcmc.py
diff --git a/pints/functionaltests/relativistic.py b/pints/functionaltests/relativistic_mcmc.py
similarity index 100%
rename from pints/functionaltests/relativistic.py
rename to pints/functionaltests/relativistic_mcmc.py
diff --git a/pints/functionaltests/slice_stepout.py b/pints/functionaltests/slice_stepout_mcmc.py
similarity index 100%
rename from pints/functionaltests/slice_stepout.py
rename to pints/functionaltests/slice_stepout_mcmc.py

From 30d4e44e94e731e72892f7ec8067705b92e1a927 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 10:09:56 +0100
Subject: [PATCH 49/73] Removed 'test_method_on' prefix from all functional
 tests, so they can be called as e.g.
 'differential_evaluation_mcmc.two_dim_gaussian()'.

---
 .../functionaltests/differential_evolution_mcmc.py |  8 ++++----
 pints/functionaltests/dram_acmc.py                 |  6 +++---
 pints/functionaltests/dream_mcmc.py                |  8 ++++----
 pints/functionaltests/emcee_hammer_mcmc.py         | 12 ++++++------
 pints/functionaltests/haario_acmc.py               |  6 +++---
 pints/functionaltests/haario_bardenet_acmc.py      |  8 ++++----
 pints/functionaltests/hamiltonian_mcmc.py          |  6 +++---
 .../functionaltests/metropolis_random_walk_mcmc.py |  6 +++---
 .../monomial_gamma_hamiltonian_mcmc.py             | 14 +++++++-------
 pints/functionaltests/no_u_turn_mcmc.py            |  6 +++---
 pints/functionaltests/population_mcmc.py           |  6 +++---
 pints/functionaltests/relativistic_mcmc.py         | 14 +++++++-------
 pints/functionaltests/slice_stepout_mcmc.py        | 14 +++++++-------
 13 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index 9c9a634652..1824050ad0 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -15,7 +15,7 @@
                         RunMcmcMethodOnAnnulus)
 
 
-def test_differential_evolution_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -31,7 +31,7 @@ def test_differential_evolution_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_differential_evolution_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnBanana(
@@ -47,7 +47,7 @@ def test_differential_evolution_on_banana(n_iterations=None):
     }
 
 
-def test_differential_evolution_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -63,7 +63,7 @@ def test_differential_evolution_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_differential_evolution_on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnAnnulus(
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index cdc3b133b8..2439106c7e 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -14,7 +14,7 @@
                         RunMcmcMethodOnBanana)
 
 
-def test_dram_acmc_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -30,7 +30,7 @@ def test_dram_acmc_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_haario_acmc_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnBanana(
@@ -46,7 +46,7 @@ def test_haario_acmc_on_banana(n_iterations=None):
     }
 
 
-def test_dram_acmc_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index 70a9a722ec..fce4eb7587 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -15,7 +15,7 @@
                         RunMcmcMethodOnAnnulus)
 
 
-def test_dream_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -31,7 +31,7 @@ def test_dream_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_dream_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnBanana(
@@ -47,7 +47,7 @@ def test_dream_on_banana(n_iterations=None):
     }
 
 
-def test_dream_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -63,7 +63,7 @@ def test_dream_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_dream_on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnAnnulus(
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index b1ebb1c615..bdf64d001e 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -17,7 +17,7 @@
                         RunMcmcMethodOnCone)
 
 
-def test_emcee_hammer_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -33,7 +33,7 @@ def test_emcee_hammer_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_emcee_hammer_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnBanana(
@@ -49,7 +49,7 @@ def test_emcee_hammer_on_banana(n_iterations=None):
     }
 
 
-def test_emcee_hammer_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -65,7 +65,7 @@ def test_emcee_hammer_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_emcee_hammer_on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnAnnulus(
@@ -81,7 +81,7 @@ def test_emcee_hammer_on_annulus(n_iterations=None):
     }
 
 
-def test_emcee_hammer_on_multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnMultimodalGaussian(
@@ -97,7 +97,7 @@ def test_emcee_hammer_on_multimodal_gaussian(n_iterations=None):
     }
 
 
-def test_emcee_hammer_on_cone(n_iterations=None):
+def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnCone(
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index 2a24497aef..ace093e18f 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -14,7 +14,7 @@
                         RunMcmcMethodOnCorrelatedGaussian)
 
 
-def test_haario_acmc_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -30,7 +30,7 @@ def test_haario_acmc_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_haario_acmc_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnBanana(
@@ -46,7 +46,7 @@ def test_haario_acmc_on_banana(n_iterations=None):
     }
 
 
-def test_haario_acmc_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 15b0ac090d..a76f46b033 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -15,7 +15,7 @@
                         RunMcmcMethodOnAnnulus)
 
 
-def test_haario_bardenet_acmc_on_two_dim_gaussian(n_iterations=None):
+def on_two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -31,7 +31,7 @@ def test_haario_bardenet_acmc_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_haario_bardenet_acmc_on_banana(n_iterations=None):
+def on_banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnBanana(
@@ -47,7 +47,7 @@ def test_haario_bardenet_acmc_on_banana(n_iterations=None):
     }
 
 
-def test_haario_bardenet_acmc_on_correlated_gaussian(n_iterations=None):
+def on_correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -63,7 +63,7 @@ def test_haario_bardenet_acmc_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_haario_bardenet_acmc_on_annulus(n_iterations=None):
+def on_annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnAnnulus(
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index 357d1a5001..5d582f5738 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -14,7 +14,7 @@
                         RunMcmcMethodOnHighDimensionalGaussian)
 
 
-def test_hamiltonian_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -31,7 +31,7 @@ def test_hamiltonian_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_hamiltonian_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnBanana(
@@ -48,7 +48,7 @@ def test_hamiltonian_on_banana(n_iterations=None):
     }
 
 
-def test_hamiltonian_on_high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnHighDimensionalGaussian(
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index f05a87ffdc..8906123752 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -14,7 +14,7 @@
                         RunMcmcMethodOnCorrelatedGaussian)
 
 
-def test_metropolis_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -30,7 +30,7 @@ def test_metropolis_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_metropolis_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnBanana(
@@ -46,7 +46,7 @@ def test_metropolis_on_banana(n_iterations=None):
     }
 
 
-def test_metropolis_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
     problem = RunMcmcMethodOnCorrelatedGaussian(
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index 1ef623106f..a60c58ca28 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -18,7 +18,7 @@
                         RunMcmcMethodOnCone)
 
 
-def test_monomial_gamma_hamiltonian_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -35,7 +35,7 @@ def test_monomial_gamma_hamiltonian_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_monomial_gamma_hamiltonian_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnBanana(
@@ -52,7 +52,7 @@ def test_monomial_gamma_hamiltonian_on_banana(n_iterations=None):
     }
 
 
-def test_monomial_gamma_hamiltonian_on_high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnHighDimensionalGaussian(
@@ -69,7 +69,7 @@ def test_monomial_gamma_hamiltonian_on_high_dim_gaussian(n_iterations=None):
     }
 
 
-def test_monomial_gamma_hamiltonian_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -86,7 +86,7 @@ def test_monomial_gamma_hamiltonian_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_monomial_gamma_hamiltonian_on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnAnnulus(
@@ -103,7 +103,7 @@ def test_monomial_gamma_hamiltonian_on_annulus(n_iterations=None):
     }
 
 
-def test_monomial_gamma_hamiltonian_on_multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnMultimodalGaussian(
@@ -120,7 +120,7 @@ def test_monomial_gamma_hamiltonian_on_multimodal_gaussian(n_iterations=None):
     }
 
 
-def test_monomial_gamma_hamiltonian_on_cone(n_iterations=None):
+def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnCone(
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index a1fb5c4097..e906f2d575 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -14,7 +14,7 @@
                         RunMcmcMethodOnHighDimensionalGaussian)
 
 
-def test_nuts_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -30,7 +30,7 @@ def test_nuts_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_nuts_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnBanana(
@@ -46,7 +46,7 @@ def test_nuts_on_banana(n_iterations=None):
     }
 
 
-def test_nuts_on_high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
     problem = RunMcmcMethodOnHighDimensionalGaussian(
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index cb8232edf5..127232a298 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -16,7 +16,7 @@
 )
 
 
-def test_population_mcmc_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     """
     Tests :class:`pints.PopulationMCMC` on a two-dimensional Gaussian with
     means 0 and 0, and returns a dict with entries "kld" and "mean-ess".
@@ -43,7 +43,7 @@ def test_population_mcmc_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_population_mcmc_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     """
     Tests :class:`pints.PopulationMCMC` on a 2-d twisted Gaussian "banana"
     problem with true solution ``(0, 0)``, and returns a dict with entries
@@ -69,7 +69,7 @@ def test_population_mcmc_on_banana(n_iterations=None):
     }
 
 
-def test_population_mcmc_on_multimodal_gaussian(
+def multimodal_gaussian(
         n_iterations=None, n_temperatures=None):
     """
     Tests :class:`pints.PopulationMCMC` on a multi-modal Gaussian distribution
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index bad99e78ea..caff989404 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -18,7 +18,7 @@
                         RunMcmcMethodOnCone)
 
 
-def test_relativistic_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -35,7 +35,7 @@ def test_relativistic_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_relativistic_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnBanana(
@@ -52,7 +52,7 @@ def test_relativistic_on_banana(n_iterations=None):
     }
 
 
-def test_relativistic_on_high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnHighDimensionalGaussian(
@@ -69,7 +69,7 @@ def test_relativistic_on_high_dim_gaussian(n_iterations=None):
     }
 
 
-def test_relativistic_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -86,7 +86,7 @@ def test_relativistic_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_relativistic_on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnAnnulus(
@@ -103,7 +103,7 @@ def test_relativistic_on_annulus(n_iterations=None):
     }
 
 
-def test_relativistic_on_multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnMultimodalGaussian(
@@ -120,7 +120,7 @@ def test_relativistic_on_multimodal_gaussian(n_iterations=None):
     }
 
 
-def test_relativistic_on_cone(n_iterations=None):
+def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
     problem = RunMcmcMethodOnCone(
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index 9ca5af4763..3b12358bfa 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -18,7 +18,7 @@
                         RunMcmcMethodOnCone)
 
 
-def test_slice_stepout_on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnTwoDimGaussian(
@@ -33,7 +33,7 @@ def test_slice_stepout_on_two_dim_gaussian(n_iterations=None):
         'mean-ess': problem.estimate_mean_ess()
     }
 
-def test_slice_stepout_on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnCorrelatedGaussian(
@@ -49,7 +49,7 @@ def test_slice_stepout_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_slice_stepout_on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnBanana(
@@ -65,7 +65,7 @@ def test_slice_stepout_on_banana(n_iterations=None):
     }
 
 
-def test_slice_stepout_on_high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnHighDimensionalGaussian(
@@ -81,7 +81,7 @@ def test_slice_stepout_on_high_dim_gaussian(n_iterations=None):
     }
 
 
-def test_slice_stepout_on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
     problem = RunMcmcMethodOnAnnulus(
@@ -97,7 +97,7 @@ def test_slice_stepout_on_annulus(n_iterations=None):
     }
 
 
-def test_slice_stepout_on_multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnMultimodalGaussian(
@@ -113,7 +113,7 @@ def test_slice_stepout_on_multimodal_gaussian(n_iterations=None):
     }
 
 
-def test_slice_stepout_on_cone(n_iterations=None):
+def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
     problem = RunMcmcMethodOnCone(

From e029413bd9005a054e3e36a1232dba6a9b3cef87 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 10:20:17 +0100
Subject: [PATCH 50/73] Updated the way functionaltest modules and problem
 classes are imported.

---
 pints/functionaltests/__init__.py             | 38 ++++++++++++++++---
 .../differential_evolution_mcmc.py            | 14 +++----
 pints/functionaltests/dram_acmc.py            | 11 ++----
 pints/functionaltests/dream_mcmc.py           | 14 +++----
 pints/functionaltests/emcee_hammer_mcmc.py    | 20 ++++------
 pints/functionaltests/haario_acmc.py          | 11 ++----
 pints/functionaltests/haario_bardenet_acmc.py | 22 +++++------
 pints/functionaltests/hamiltonian_mcmc.py     | 11 ++----
 .../metropolis_random_walk_mcmc.py            | 11 ++----
 .../monomial_gamma_hamiltonian_mcmc.py        | 23 ++++-------
 pints/functionaltests/no_u_turn_mcmc.py       | 11 ++----
 pints/functionaltests/population_mcmc.py      | 14 ++-----
 pints/functionaltests/relativistic_mcmc.py    | 23 ++++-------
 pints/functionaltests/slice_stepout_mcmc.py   | 23 ++++-------
 14 files changed, 106 insertions(+), 140 deletions(-)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index a3e83e9816..82931b7929 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -1,13 +1,39 @@
 #
+# "Functional test" module for PINTS.
+#
 # 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 .differential_evolution import test_differential_evolution_on_banana
-from .differential_evolution import test_differential_evolution_on_two_dim_gaussian
+# Import all problem classes straight into this module, so that they can be
+# addressed as e.g. pints.functionaltests.RunMcmcMethodOnAnnulus.
+from ._problems import (
+    RunMcmcMethodOnAnnulus,
+    RunMcmcMethodOnBanana,
+    RunMcmcMethodOnCone,
+    RunMcmcMethodOnCorrelatedGaussian,
+    RunMcmcMethodOnHighDimensionalGaussian,
+    RunMcmcMethodOnMultimodalGaussian,
+    RunMcmcMethodOnTwoDimGaussian,
+)
+
+# Import all test modules (not methods!) directly into this method, so that
+# they can be addressed as e.g.
+# pints.functionaltests.dram_acmc.two_dim_gaussian().
+from . import (
+    differential_evolution_mcmc,
+    dram_acmc,
+    dream_mcmc,
+    emcee_hammer_mcmc,
+    haario_acmc,
+    haario_bardenet_acmc,
+    hamiltonian_mcmc,
+    metropolis_random_walk_mcmc,
+    monomial_gamma_hamiltonian_mcmc,
+    no_u_turn_mcmc,
+    population_mcmc,
+    relativistic_mcmc,
+    slice_stepout_mcmc,
+)
 
-from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_annulus
-from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_banana
-from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_correlated_gaussian
-from .haario_bardenet_acmc import test_haario_bardenet_acmc_on_two_dim_gaussian
diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index 1824050ad0..ee072b0c19 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -8,17 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -34,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
         n_iterations=n_iterations,
@@ -50,7 +46,7 @@ def banana(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
         n_iterations=n_iterations,
@@ -66,7 +62,7 @@ def correlated_gaussian(n_iterations=None):
 def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index 2439106c7e..b461dbd5e5 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -8,16 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnBanana)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DramACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -33,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.DramACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -49,7 +46,7 @@ def banana(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DramACMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index fce4eb7587..ed5766837a 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -8,17 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DreamMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -34,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.DreamMCMC,
         n_chains=20,
         n_iterations=n_iterations,
@@ -50,7 +46,7 @@ def banana(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DreamMCMC,
         n_chains=20,
         n_iterations=n_iterations,
@@ -66,7 +62,7 @@ def correlated_gaussian(n_iterations=None):
 def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.DreamMCMC,
         n_chains=10,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index bdf64d001e..c36501f11d 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -8,19 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus,
-                        RunMcmcMethodOnMultimodalGaussian,
-                        RunMcmcMethodOnCone)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -36,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -52,7 +46,7 @@ def banana(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -68,7 +62,7 @@ def correlated_gaussian(n_iterations=None):
 def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -84,7 +78,7 @@ def annulus(n_iterations=None):
 def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnMultimodalGaussian(
+    problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
@@ -100,7 +94,7 @@ def multimodal_gaussian(n_iterations=None):
 def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnCone(
+    problem = ft.RunMcmcMethodOnCone(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index ace093e18f..75b34d5400 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -8,16 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -33,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.HaarioACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -49,7 +46,7 @@ def banana(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index a76f46b033..b8f3165185 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -8,17 +8,13 @@
 from __future__ import division
 
 import pints
+import pints.functionaltests as ft
 
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus)
 
-
-def on_two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -31,10 +27,10 @@ def on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def on_banana(n_iterations=None):
+def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -47,10 +43,10 @@ def on_banana(n_iterations=None):
     }
 
 
-def on_correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -63,10 +59,10 @@ def on_correlated_gaussian(n_iterations=None):
     }
 
 
-def on_annulus(n_iterations=None):
+def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index 5d582f5738..44242d6259 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -8,16 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnHighDimensionalGaussian)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -34,7 +31,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -51,7 +48,7 @@ def banana(n_iterations=None):
 def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnHighDimensionalGaussian(
+    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index 8906123752..81e4806d9d 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -8,16 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnCorrelatedGaussian)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -33,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -49,7 +46,7 @@ def banana(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 8000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index a60c58ca28..7ee3e0fc10 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -8,20 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnHighDimensionalGaussian,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus,
-                        RunMcmcMethodOnMultimodalGaussian,
-                        RunMcmcMethodOnCone)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -38,7 +31,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -55,7 +48,7 @@ def banana(n_iterations=None):
 def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnHighDimensionalGaussian(
+    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -72,7 +65,7 @@ def high_dim_gaussian(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -89,7 +82,7 @@ def correlated_gaussian(n_iterations=None):
 def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -106,7 +99,7 @@ def annulus(n_iterations=None):
 def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnMultimodalGaussian(
+    problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -123,7 +116,7 @@ def multimodal_gaussian(n_iterations=None):
 def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnCone(
+    problem = ft.RunMcmcMethodOnCone(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index e906f2d575..ffaa3c33d9 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -8,16 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnHighDimensionalGaussian)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.NoUTurnMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -33,7 +30,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.NoUTurnMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -49,7 +46,7 @@ def banana(n_iterations=None):
 def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 4000
-    problem = RunMcmcMethodOnHighDimensionalGaussian(
+    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.NoUTurnMCMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index 127232a298..7609cddec4 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -7,13 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-
-from ._problems import (
-    RunMcmcMethodOnBanana,
-    RunMcmcMethodOnMultimodalGaussian,
-    RunMcmcMethodOnSimpleEggBox,
-    RunMcmcMethodOnTwoDimGaussian,
-)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
@@ -30,7 +24,7 @@ def two_dim_gaussian(n_iterations=None):
     if n_warmup > n_iterations // 2:
         n_warmup = n_iterations // 10
 
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.PopulationMCMC,
         n_chains=1,
         n_iterations=n_iterations,
@@ -56,7 +50,7 @@ def banana(n_iterations=None):
     if n_warmup > n_iterations // 2:
         n_warmup = n_iterations // 10
 
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.PopulationMCMC,
         n_chains=1,
         n_iterations=n_iterations,
@@ -87,7 +81,7 @@ def multimodal_gaussian(
     if n_temperatures is not None:
         method_hyper_parameters = [n_temperatures]
 
-    problem = RunMcmcMethodOnMultimodalGaussian(
+    problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.PopulationMCMC,
         n_chains=1,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index caff989404..7b9fe3f4f9 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -8,20 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnHighDimensionalGaussian,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus,
-                        RunMcmcMethodOnMultimodalGaussian,
-                        RunMcmcMethodOnCone)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 1000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -38,7 +31,7 @@ def two_dim_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -55,7 +48,7 @@ def banana(n_iterations=None):
 def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnHighDimensionalGaussian(
+    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -72,7 +65,7 @@ def high_dim_gaussian(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -89,7 +82,7 @@ def correlated_gaussian(n_iterations=None):
 def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -106,7 +99,7 @@ def annulus(n_iterations=None):
 def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnMultimodalGaussian(
+    problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -123,7 +116,7 @@ def multimodal_gaussian(n_iterations=None):
 def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 2000
-    problem = RunMcmcMethodOnCone(
+    problem = ft.RunMcmcMethodOnCone(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index 3b12358bfa..9e54663a3d 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -8,20 +8,13 @@
 from __future__ import division
 
 import pints
-
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnHighDimensionalGaussian,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus,
-                        RunMcmcMethodOnMultimodalGaussian,
-                        RunMcmcMethodOnCone)
+import pints.functionaltests as ft
 
 
 def two_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -36,7 +29,7 @@ def two_dim_gaussian(n_iterations=None):
 def correlated_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -52,7 +45,7 @@ def correlated_gaussian(n_iterations=None):
 def banana(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnBanana(
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -68,7 +61,7 @@ def banana(n_iterations=None):
 def high_dim_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnHighDimensionalGaussian(
+    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -84,7 +77,7 @@ def high_dim_gaussian(n_iterations=None):
 def annulus(n_iterations=None):
     if n_iterations is None:
         n_iterations = 10000
-    problem = RunMcmcMethodOnAnnulus(
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -100,7 +93,7 @@ def annulus(n_iterations=None):
 def multimodal_gaussian(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnMultimodalGaussian(
+    problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
@@ -116,7 +109,7 @@ def multimodal_gaussian(n_iterations=None):
 def cone(n_iterations=None):
     if n_iterations is None:
         n_iterations = 5000
-    problem = RunMcmcMethodOnCone(
+    problem = ft.RunMcmcMethodOnCone(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,

From c83bfc3c44b7f3ae693073c5a0a7552d71ec47ed Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 10:21:32 +0100
Subject: [PATCH 51/73] Removed 'from __future__' imports.

---
 pints/functionaltests/differential_evolution_mcmc.py     | 3 ---
 pints/functionaltests/dram_acmc.py                       | 3 ---
 pints/functionaltests/dream_mcmc.py                      | 3 ---
 pints/functionaltests/emcee_hammer_mcmc.py               | 3 ---
 pints/functionaltests/haario_acmc.py                     | 3 ---
 pints/functionaltests/haario_bardenet_acmc.py            | 3 ---
 pints/functionaltests/hamiltonian_mcmc.py                | 3 ---
 pints/functionaltests/metropolis_random_walk_mcmc.py     | 3 ---
 pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py | 3 ---
 pints/functionaltests/no_u_turn_mcmc.py                  | 3 ---
 pints/functionaltests/relativistic_mcmc.py               | 3 ---
 pints/functionaltests/slice_stepout_mcmc.py              | 3 ---
 12 files changed, 36 deletions(-)

diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index ee072b0c19..c9b90e7dbf 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index b461dbd5e5..927a53d321 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index ed5766837a..b8e397e7eb 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index c36501f11d..23f6aa5b59 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index 75b34d5400..aeda0e9add 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index b8f3165185..84cbc7080e 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index 44242d6259..5fe7435bed 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index 81e4806d9d..a03fbacb7c 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index 7ee3e0fc10..f99edf9a98 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index ffaa3c33d9..772a3ad94b 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index 7b9fe3f4f9..a45428e6c0 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index 9e54663a3d..5d72682397 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -4,9 +4,6 @@
 # released under the BSD 3-clause license. See accompanying LICENSE.md for
 # copyright notice and full license details.
 #
-
-from __future__ import division
-
 import pints
 import pints.functionaltests as ft
 

From 3edbeb1021be5b78d7422329f853289d5a22ad88 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 12:10:07 +0100
Subject: [PATCH 52/73] Added docstrings to functional tests.

---
 pints/functionaltests/_problems.py            | 94 +++++++++++++++----
 .../differential_evolution_mcmc.py            | 35 +++++++
 pints/functionaltests/dram_acmc.py            | 29 +++++-
 pints/functionaltests/dream_mcmc.py           | 35 +++++++
 pints/functionaltests/emcee_hammer_mcmc.py    | 52 ++++++++++
 pints/functionaltests/haario_acmc.py          | 27 ++++++
 pints/functionaltests/haario_bardenet_acmc.py | 35 +++++++
 pints/functionaltests/hamiltonian_mcmc.py     | 26 +++++
 .../metropolis_random_walk_mcmc.py            | 27 ++++++
 .../monomial_gamma_hamiltonian_mcmc.py        | 60 ++++++++++++
 pints/functionaltests/no_u_turn_mcmc.py       | 26 +++++
 pints/functionaltests/population_mcmc.py      | 31 +++---
 pints/functionaltests/relativistic_mcmc.py    | 60 ++++++++++++
 pints/functionaltests/slice_stepout_mcmc.py   | 60 ++++++++++++
 14 files changed, 567 insertions(+), 30 deletions(-)

diff --git a/pints/functionaltests/_problems.py b/pints/functionaltests/_problems.py
index 6b7c0a4448..7b0409e6c1 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/functionaltests/_problems.py
@@ -1,15 +1,44 @@
 #
+# Shared problems used in functional testing.
+#
 # 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 pints
 import pints.toy
 
 
 class RunMcmcMethodOnProblem(object):
+    """
+    Base class for tests that run an MCMC method on a log-PDF.
+
+    Parameters
+    ----------
+    log_pdf : pints.LogPDF
+        The PDF to sample. Will be passed to a :class:`pints.MCMCController`.
+    x0
+        One or more starting points to be passed to the
+        :class:`pints.MCMCController`.
+    sigma0
+        One or more ``sigma0`` parameters to be passed to the
+        :class:`pints.MCMCController`.
+    method : pints.MCMCSampler
+        The method to test. Will be passed to the
+        :class:`pints.MCMCController`.
+    n_chains : int
+        The number of chains to run. Will be passed to the
+        :class:`pints.MCMCController`.
+    n_iterations : int
+        The number of iterations to run
+    n_warmup : int
+        The number of iterations to discard
+    method_hyper_parameters : list
+        A list of hyperparameter values.
+
+    """
 
     def __init__(self, log_pdf, x0, sigma0, method, n_chains, n_iterations,
                  n_warmup, method_hyper_parameters):
@@ -26,9 +55,11 @@ def __init__(self, log_pdf, x0, sigma0, method, n_chains, n_iterations,
     def estimate_kld(self):
         """
         Estimates the Kullback-Leibler divergence.
+
+        Raises an ``AttributeError`` if the underlying LogPDF does not have a
+        method ``kl_divergence()``.
         """
         chains = np.vstack(self.chains)
-
         return np.mean(self.log_pdf.kl_divergence(chains))
 
     def estimate_mean_ess(self):
@@ -47,15 +78,21 @@ def estimate_mean_ess(self):
 
     def estimate_distance(self):
         """
-        Estimates a measure of distance for the `pints.AnnulusLogPDF` class.
+        Estimates a measure of distance between the sampled chains and the true
+        distribution.
+
+        Raises an ``AttributeError`` if the underlying LogPDF does not have a
+        method ``distance()``.
         """
         return self.log_pdf.distance(np.vstack(self.chains))
 
 
 class RunMcmcMethodOnTwoDimGaussian(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on a standard 2 dimensional Gaussian
-    distribution.
+    Tests a given MCMC method on a two-dimensional Gaussian distribution with
+    means ``[0, 0]`` and sigma ``[1, 1]``.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
 
     def __init__(self, method, n_chains, n_iterations, n_warmup,
@@ -75,7 +112,11 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
 class RunMcmcMethodOnBanana(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `pints.toy.TwistedGaussianLogPDF`.
+    Tests a given MCMC method on a two-dimensional
+    :class:`pints.toy.TwistedGaussianLogPDF` distribution with means
+    ``[0, 0]``.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
@@ -91,6 +132,7 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+'''
 class RunMcmcMethodOnSimpleEggBox(RunMcmcMethodOnProblem):
     """
     Tests a given MCMC method on `pints.toy.SimpleEggBoxLogPDF`.
@@ -105,11 +147,15 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
         super().__init__(log_pdf, x0, sigma0, method, n_chains, n_iterations,
                          n_warmup, method_hyper_parameters)
+'''
 
 
 class RunMcmcMethodOnHighDimensionalGaussian(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `pints.toy.HighDimensionalGaussianLogPDF`.
+    Tests a given MCMC method on a 20-dimensional
+    :class:`pints.toy.HighDimensionalGaussianLogPDF` centered at the origin.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
@@ -123,13 +169,14 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
 class RunMcmcMethodOnCorrelatedGaussian(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `pints.toy.HighDimensionalGaussianLogPDF`
-    but using a 6-dimensional problem with higher correlation.
+    Tests a given MCMC method on a 6-dimensional, highly correlated
+    :class:`pints.toy.HighDimensionalGaussianLogPDF` centered at the origin.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
-        log_pdf = pints.toy.HighDimensionalGaussianLogPDF(
-            dimension=6, rho=0.8)
+        log_pdf = pints.toy.HighDimensionalGaussianLogPDF(dimension=6, rho=0.8)
         x0 = np.random.uniform(-4, 4, size=(n_chains, 6))
         sigma0 = None
 
@@ -139,7 +186,11 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
 class RunMcmcMethodOnAnnulus(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `pints.AnnulusLogPDF`.
+    Tests a given MCMC method on a two-dimensional
+    :class:`pints.toy.AnnulusLogPDF` distribution, with its highest values at
+    any point ``x`` with ``np.linalg.norm(x) == 10``.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
@@ -153,17 +204,21 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
 class RunMcmcMethodOnMultimodalGaussian(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `MultimodalGaussianLogPDF`.
+    Tests a given MCMC method on a two-dimensional
+    :class:`pints.toy.MultimodalGaussianLogPDF` with modes at ``[0, 0]``,
+    ``[5, 10]``, and ``[10, 0]``.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
+        modes = [[0, 0],
+                 [5, 10],
+                 [10, 0]]
         covariances = [[[1, 0], [0, 1]],
                        [[2, 0.8], [0.8, 3]],
                        [[1, -0.5], [-0.5, 1]]]
-        log_pdf = pints.toy.MultimodalGaussianLogPDF(modes=[[0, 0],
-                                                            [5, 10],
-                                                            [10, 0]],
-                                                     covariances=covariances)
+        log_pdf = pints.toy.MultimodalGaussianLogPDF(modes, covariances)
         x0 = log_pdf.sample(n_chains)
         sigma0 = None
 
@@ -173,7 +228,10 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
 
 class RunMcmcMethodOnCone(RunMcmcMethodOnProblem):
     """
-    Tests a given MCMC method on `MultimodalGaussianLogPDF`.
+    Tests a given MCMC method on a two-dimensional
+    :class:`pints.toy,ConeLogPDF` centered at ``[0, 0]``.
+
+    For constructor arguments, see :class:`RunMcmcMethodOnProblem`.
     """
     def __init__(self, method, n_chains, n_iterations, n_warmup,
                  method_hyper_parameters=None):
diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index c9b90e7dbf..cd15f36a2e 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for DifferentialEvolutionMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.DifferentialEvolutionMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.DifferentialEvolutionMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.DifferentialEvolutionMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -57,6 +84,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.DifferentialEvolutionMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnAnnulus(
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index 927a53d321..61faa771cf 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for DramACMC
+#
 # 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.
@@ -9,6 +11,15 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.DramACMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
+
     if n_iterations is None:
         n_iterations = 8000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,7 +36,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
-    if n_iterations is None:
+    """
+    Tests :class:`pints.DramACMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """    if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DramACMC,
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.DramACMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 8000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index b8e397e7eb..db2c5afe24 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for DreamMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.DreamMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.DreamMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.DreamMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -57,6 +84,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.DreamMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnAnnulus(
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index 23f6aa5b59..25570d8624 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for EmceeHammerMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.EmceeHammerMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.EmceeHammerMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.EmceeHammerMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 8000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -57,6 +84,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.EmceeHammerMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnAnnulus(
@@ -73,6 +108,15 @@ def annulus(n_iterations=None):
 
 
 def multimodal_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.EmceeHammerMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
@@ -89,6 +133,14 @@ def multimodal_gaussian(n_iterations=None):
 
 
 def cone(n_iterations=None):
+    """
+    Tests :class:`pints.EmceeHammerMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnCone(
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index aeda0e9add..7808bc113a 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for HaarioACMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioACMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioACMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioACMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 8000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 84cbc7080e..5aed19f84b 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for HaarioBardenetACMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioBardenetACMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioBardenetACMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioBardenetACMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 8000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -57,6 +84,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.HaarioBardenetACMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnAnnulus(
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index 5fe7435bed..f987a37e33 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for HamiltonianMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.HamiltonianMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 1000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -26,6 +36,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.HamiltonianMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnBanana(
@@ -43,6 +61,14 @@ def banana(n_iterations=None):
 
 
 def high_dim_gaussian(n_iterations=None):
+    """
+     Tests :class:`pints.HamiltonianMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index a03fbacb7c..7f89340abf 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for MetropolisRandomWalkMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.MetropolisRandomWalkMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.MetropolisRandomWalkMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,15 @@ def banana(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.MetropolisRandomWalkMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 8000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index f99edf9a98..c8424921ab 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for MonomialGammaHamiltonianMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 1000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -26,6 +36,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnBanana(
@@ -43,6 +61,14 @@ def banana(n_iterations=None):
 
 
 def high_dim_gaussian(n_iterations=None):
+    """
+     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
@@ -60,6 +86,15 @@ def high_dim_gaussian(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -77,6 +112,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnAnnulus(
@@ -94,6 +137,15 @@ def annulus(n_iterations=None):
 
 
 def multimodal_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
@@ -111,6 +163,14 @@ def multimodal_gaussian(n_iterations=None):
 
 
 def cone(n_iterations=None):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnCone(
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index 772a3ad94b..57b4da9146 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for NoUTurnMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.NoUTurnMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 1000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -25,6 +35,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.NoUTurnMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnBanana(
@@ -41,6 +59,14 @@ def banana(n_iterations=None):
 
 
 def high_dim_gaussian(n_iterations=None):
+    """
+     Tests :class:`pints.NoUTurnMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 4000
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index 7609cddec4..ce7d34203c 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -12,10 +12,12 @@
 
 def two_dim_gaussian(n_iterations=None):
     """
-    Tests :class:`pints.PopulationMCMC` on a two-dimensional Gaussian with
-    means 0 and 0, and returns a dict with entries "kld" and "mean-ess".
+    Tests :class:`pints.PopulationMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
-    See :class:`pints
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     if n_iterations is None:
         n_iterations = 20000
@@ -39,10 +41,14 @@ def two_dim_gaussian(n_iterations=None):
 
 def banana(n_iterations=None):
     """
-    Tests :class:`pints.PopulationMCMC` on a 2-d twisted Gaussian "banana"
-    problem with true solution ``(0, 0)``, and returns a dict with entries
-    "kld" and "mean-ess".
+    Tests :class:`pints.PopulationMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
+
     if n_iterations is None:
         n_iterations = 20000
 
@@ -63,12 +69,15 @@ def banana(n_iterations=None):
     }
 
 
-def multimodal_gaussian(
-        n_iterations=None, n_temperatures=None):
+def multimodal_gaussian(n_iterations=None, n_temperatures=None):
     """
-    Tests :class:`pints.PopulationMCMC` on a multi-modal Gaussian distribution
-    with modes at ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict
-    with entries "kld" and "mean-ess".
+    Tests :class:`pints.PopulationMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
     if n_iterations is None:
         n_iterations = 20000
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index a45428e6c0..d3acf0dccc 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for RelativisticMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.RelativisticMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 1000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -26,6 +36,14 @@ def two_dim_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.RelativisticMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnBanana(
@@ -43,6 +61,14 @@ def banana(n_iterations=None):
 
 
 def high_dim_gaussian(n_iterations=None):
+    """
+     Tests :class:`pints.RelativisticMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
@@ -60,6 +86,15 @@ def high_dim_gaussian(n_iterations=None):
 
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.RelativisticMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -77,6 +112,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.RelativisticMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnAnnulus(
@@ -94,6 +137,15 @@ def annulus(n_iterations=None):
 
 
 def multimodal_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.RelativisticMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
@@ -111,6 +163,14 @@ def multimodal_gaussian(n_iterations=None):
 
 
 def cone(n_iterations=None):
+    """
+    Tests :class:`pints.RelativisticMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    """
     if n_iterations is None:
         n_iterations = 2000
     problem = ft.RunMcmcMethodOnCone(
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index 5d72682397..ebfcea50ba 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 #
+# Functional tests for SliceStepoutMCMC
+#
 # 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.
@@ -9,6 +11,14 @@
 
 
 def two_dim_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.SliceStepoutMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
@@ -24,6 +34,15 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 def correlated_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.SliceStepoutMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
@@ -40,6 +59,14 @@ def correlated_gaussian(n_iterations=None):
 
 
 def banana(n_iterations=None):
+    """
+    Tests :class:`pints.SliceStepoutMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnBanana(
@@ -56,6 +83,14 @@ def banana(n_iterations=None):
 
 
 def high_dim_gaussian(n_iterations=None):
+    """
+     Tests :class:`pints.SliceStepoutMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
@@ -72,6 +107,14 @@ def high_dim_gaussian(n_iterations=None):
 
 
 def annulus(n_iterations=None):
+    """
+    Tests :class:`pints.SliceStepoutMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
     if n_iterations is None:
         n_iterations = 10000
     problem = ft.RunMcmcMethodOnAnnulus(
@@ -88,6 +131,15 @@ def annulus(n_iterations=None):
 
 
 def multimodal_gaussian(n_iterations=None):
+    """
+    Tests :class:`pints.SliceStepoutMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
@@ -104,6 +156,14 @@ def multimodal_gaussian(n_iterations=None):
 
 
 def cone(n_iterations=None):
+    """
+    Tests :class:`pints.SliceStepoutMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    """
     if n_iterations is None:
         n_iterations = 5000
     problem = ft.RunMcmcMethodOnCone(

From 3b0e026a67b4f9f1c227c04409a9572857bb8a7d Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 12:32:58 +0100
Subject: [PATCH 53/73] Updated way iterations and warmup is set in functional
 tests.

---
 pints/functionaltests/__init__.py             |  4 +-
 .../differential_evolution_mcmc.py            | 40 ++++++-----
 pints/functionaltests/dram_acmc.py            | 30 ++++----
 pints/functionaltests/dream_mcmc.py           | 40 ++++++-----
 pints/functionaltests/emcee_hammer_mcmc.py    | 60 +++++++++-------
 pints/functionaltests/haario_acmc.py          | 30 ++++----
 pints/functionaltests/haario_bardenet_acmc.py | 40 ++++++-----
 pints/functionaltests/hamiltonian_mcmc.py     | 30 ++++----
 .../metropolis_random_walk_mcmc.py            | 30 ++++----
 .../monomial_gamma_hamiltonian_mcmc.py        | 70 ++++++++++--------
 pints/functionaltests/no_u_turn_mcmc.py       | 30 ++++----
 pints/functionaltests/population_mcmc.py      | 16 +----
 pints/functionaltests/relativistic_mcmc.py    | 70 ++++++++++--------
 pints/functionaltests/slice_stepout_mcmc.py   | 71 +++++++++++--------
 14 files changed, 330 insertions(+), 231 deletions(-)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index 82931b7929..e300fec098 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -8,7 +8,7 @@
 
 # Import all problem classes straight into this module, so that they can be
 # addressed as e.g. pints.functionaltests.RunMcmcMethodOnAnnulus.
-from ._problems import (
+from ._problems import (    # noqa
     RunMcmcMethodOnAnnulus,
     RunMcmcMethodOnBanana,
     RunMcmcMethodOnCone,
@@ -21,7 +21,7 @@
 # Import all test modules (not methods!) directly into this method, so that
 # they can be addressed as e.g.
 # pints.functionaltests.dram_acmc.two_dim_gaussian().
-from . import (
+from . import (     # noqa
     differential_evolution_mcmc,
     dram_acmc,
     dream_mcmc,
diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index cd15f36a2e..1951f6f5f1 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=10000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=5000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=10000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -83,7 +89,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=10000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -92,13 +98,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index 61faa771cf..2216cdaa00 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=8000):
     """
     Tests :class:`pints.DramACMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,14 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
+    n_warmup = 2000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
 
-    if n_iterations is None:
-        n_iterations = 8000
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DramACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=2000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -35,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=4000):
     """
     Tests :class:`pints.DramACMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +44,16 @@ def banana(n_iterations=None):
 
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
-    """    if n_iterations is None:
-        n_iterations = 4000
+    """
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DramACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=8000):
     """
     Tests :class:`pints.DramACMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 8000
+    n_warmup = 4000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DramACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=4000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index db2c5afe24..ab0729b162 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=10000):
     """
     Tests :class:`pints.DreamMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DreamMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=5000):
     """
     Tests :class:`pints.DreamMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DreamMCMC,
         n_chains=20,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=10000):
     """
     Tests :class:`pints.DreamMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DreamMCMC,
         n_chains=20,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -83,7 +89,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=10000):
     """
     Tests :class:`pints.DreamMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -92,13 +98,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.DreamMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index 25570d8624..7d6a6fc57e 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=10000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=10000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 2000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=2000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=8000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 8000
+    n_warmup = 4000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=4000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -83,7 +89,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=4000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -92,13 +98,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 2000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=2000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -107,7 +115,7 @@ def annulus(n_iterations=None):
     }
 
 
-def multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=10000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -117,13 +125,15 @@ def multimodal_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -132,7 +142,7 @@ def multimodal_gaussian(n_iterations=None):
     }
 
 
-def cone(n_iterations=None):
+def cone(n_iterations=10000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -141,13 +151,15 @@ def cone(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCone(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index 7808bc113a..682827d23f 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=4000):
     """
     Tests :class:`pints.HaarioACMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=4000):
     """
     Tests :class:`pints.HaarioACMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.HaarioACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=8000):
     """
     Tests :class:`pints.HaarioACMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 8000
+    n_warmup = 4000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=4000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 5aed19f84b..1e505d38a5 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=4000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=4000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=8000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 8000
+    n_warmup = 4000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=4000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -83,7 +89,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=4000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -92,13 +98,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 2000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=2000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index f987a37e33..c8d086aa04 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=1000):
     """
     Tests :class:`pints.HamiltonianMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 1000
+    n_warmup = 200
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=200,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1]
     )
 
@@ -35,7 +37,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=2000):
     """
     Tests :class:`pints.HamiltonianMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -44,13 +46,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 2]
     )
 
@@ -60,7 +64,7 @@ def banana(n_iterations=None):
     }
 
 
-def high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=4000):
     """
      Tests :class:`pints.HamiltonianMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -69,13 +73,15 @@ def high_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1]
     )
 
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index 7f89340abf..2830bff19f 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=4000):
     """
     Tests :class:`pints.MetropolisRandomWalkMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=4000):
     """
     Tests :class:`pints.MetropolisRandomWalkMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=8000):
     """
     Tests :class:`pints.MetropolisRandomWalkMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -68,13 +72,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 8000
+    n_warmup = 4000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=4000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index c8424921ab..9fe849ae50 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=1000):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 1000
+    n_warmup = 200
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=200,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
@@ -35,7 +37,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=2000):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -44,13 +46,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
@@ -60,7 +64,7 @@ def banana(n_iterations=None):
     }
 
 
-def high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=2000):
     """
      Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -69,13 +73,15 @@ def high_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
@@ -85,7 +91,7 @@ def high_dim_gaussian(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=2000):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -95,13 +101,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
@@ -111,7 +119,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=2000):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -120,13 +128,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
@@ -136,7 +146,7 @@ def annulus(n_iterations=None):
     }
 
 
-def multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=2000):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -146,13 +156,15 @@ def multimodal_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
@@ -162,7 +174,7 @@ def multimodal_gaussian(n_iterations=None):
     }
 
 
-def cone(n_iterations=None):
+def cone(n_iterations=2000):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -171,13 +183,15 @@ def cone(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCone(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
 
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index 57b4da9146..e1995449b3 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=1000):
     """
     Tests :class:`pints.NoUTurnMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 1000
+    n_warmup = 200
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.NoUTurnMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=200
+        n_warmup=n_warmup,
     )
 
     return {
@@ -34,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=2000):
     """
     Tests :class:`pints.NoUTurnMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -43,13 +45,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.NoUTurnMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=4000):
     """
      Tests :class:`pints.NoUTurnMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -67,13 +71,15 @@ def high_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 4000
+    n_warmup = 1000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.NoUTurnMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=1000
+        n_warmup=n_warmup,
     )
 
     return {
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index ce7d34203c..111b66e7ab 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=20000):
     """
     Tests :class:`pints.PopulationMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,9 +19,6 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 20000
-
     n_warmup = 500
     if n_warmup > n_iterations // 2:
         n_warmup = n_iterations // 10
@@ -39,7 +36,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=20000):
     """
     Tests :class:`pints.PopulationMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -48,10 +45,6 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-
-    if n_iterations is None:
-        n_iterations = 20000
-
     n_warmup = 5000  # Needs a lot of warm-up on banana!
     if n_warmup > n_iterations // 2:
         n_warmup = n_iterations // 10
@@ -69,7 +62,7 @@ def banana(n_iterations=None):
     }
 
 
-def multimodal_gaussian(n_iterations=None, n_temperatures=None):
+def multimodal_gaussian(n_iterations=20000, n_temperatures=None):
     """
     Tests :class:`pints.PopulationMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -79,9 +72,6 @@ def multimodal_gaussian(n_iterations=None, n_temperatures=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 20000
-
     n_warmup = 500
     if n_warmup > n_iterations // 2:
         n_warmup = n_iterations // 10
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index d3acf0dccc..063ee5106f 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=1000):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 1000
+    n_warmup = 200
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=200,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
@@ -35,7 +37,7 @@ def two_dim_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=5000):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -44,13 +46,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
@@ -60,7 +64,7 @@ def banana(n_iterations=None):
     }
 
 
-def high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=5000):
     """
      Tests :class:`pints.RelativisticMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -69,13 +73,15 @@ def high_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
@@ -85,7 +91,7 @@ def high_dim_gaussian(n_iterations=None):
     }
 
 
-def correlated_gaussian(n_iterations=None):
+def correlated_gaussian(n_iterations=5000):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -95,13 +101,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
@@ -111,7 +119,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=5000):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -120,13 +128,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
@@ -136,7 +146,7 @@ def annulus(n_iterations=None):
     }
 
 
-def multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=2000):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -146,13 +156,15 @@ def multimodal_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
@@ -162,7 +174,7 @@ def multimodal_gaussian(n_iterations=None):
     }
 
 
-def cone(n_iterations=None):
+def cone(n_iterations=2000):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -171,13 +183,15 @@ def cone(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    if n_iterations is None:
-        n_iterations = 2000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCone(
         method=pints.RelativisticMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
 
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index ebfcea50ba..e1968069e6 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=None):
+def two_dim_gaussian(n_iterations=5000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,13 +19,15 @@ def two_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {
@@ -33,7 +35,8 @@ def two_dim_gaussian(n_iterations=None):
         'mean-ess': problem.estimate_mean_ess()
     }
 
-def correlated_gaussian(n_iterations=None):
+
+def correlated_gaussian(n_iterations=5000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -43,13 +46,15 @@ def correlated_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {
@@ -58,7 +63,7 @@ def correlated_gaussian(n_iterations=None):
     }
 
 
-def banana(n_iterations=None):
+def banana(n_iterations=5000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -67,13 +72,15 @@ def banana(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {
@@ -82,7 +89,7 @@ def banana(n_iterations=None):
     }
 
 
-def high_dim_gaussian(n_iterations=None):
+def high_dim_gaussian(n_iterations=5000):
     """
      Tests :class:`pints.SliceStepoutMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -91,13 +98,15 @@ def high_dim_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {
@@ -106,7 +115,7 @@ def high_dim_gaussian(n_iterations=None):
     }
 
 
-def annulus(n_iterations=None):
+def annulus(n_iterations=10000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -115,13 +124,15 @@ def annulus(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    if n_iterations is None:
-        n_iterations = 10000
+    n_warmup = 2000
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=2000
+        n_warmup=n_warmup,
     )
 
     return {
@@ -130,7 +141,7 @@ def annulus(n_iterations=None):
     }
 
 
-def multimodal_gaussian(n_iterations=None):
+def multimodal_gaussian(n_iterations=5000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -140,13 +151,15 @@ def multimodal_gaussian(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {
@@ -155,7 +168,7 @@ def multimodal_gaussian(n_iterations=None):
     }
 
 
-def cone(n_iterations=None):
+def cone(n_iterations=5000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -164,13 +177,15 @@ def cone(n_iterations=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    if n_iterations is None:
-        n_iterations = 5000
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
     problem = ft.RunMcmcMethodOnCone(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500
+        n_warmup=n_warmup,
     )
 
     return {

From c9cb2260e52ee2bab5bee60af28f8cb95f3f692f Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Wed, 11 Aug 2021 13:04:58 +0100
Subject: [PATCH 54/73] Added functional test discovery mechanism.

---
 pints/functionaltests/__init__.py             |  3 ++
 pints/functionaltests/_discovery.py           | 40 +++++++++++++++++++
 .../differential_evolution_mcmc.py            |  9 +++++
 pints/functionaltests/dram_acmc.py            |  8 ++++
 pints/functionaltests/dream_mcmc.py           |  9 +++++
 pints/functionaltests/emcee_hammer_mcmc.py    | 11 +++++
 pints/functionaltests/haario_acmc.py          |  9 +++++
 pints/functionaltests/haario_bardenet_acmc.py |  9 +++++
 pints/functionaltests/hamiltonian_mcmc.py     |  8 ++++
 .../metropolis_random_walk_mcmc.py            |  8 ++++
 .../monomial_gamma_hamiltonian_mcmc.py        | 12 ++++++
 pints/functionaltests/no_u_turn_mcmc.py       |  8 ++++
 pints/functionaltests/population_mcmc.py      |  7 ++++
 pints/functionaltests/relativistic_mcmc.py    | 12 ++++++
 pints/functionaltests/slice_stepout_mcmc.py   | 12 ++++++
 15 files changed, 165 insertions(+)
 create mode 100644 pints/functionaltests/_discovery.py

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index e300fec098..afb340246a 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -37,3 +37,6 @@
     slice_stepout_mcmc,
 )
 
+
+# Test discovery methods
+from ._discovery import tests
diff --git a/pints/functionaltests/_discovery.py b/pints/functionaltests/_discovery.py
new file mode 100644
index 0000000000..38227f85ee
--- /dev/null
+++ b/pints/functionaltests/_discovery.py
@@ -0,0 +1,40 @@
+#
+# Functional test discovery methods for PINTS.
+#
+# 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 inspect
+
+import pints.functionaltests as ft
+
+
+def tests(method=None):
+    """
+    Returns a list of all functional tests, each represented as a tuple
+    ``(method, test)`` where ``method`` is the PINTS class being tested and
+    ``test`` is a callable that returns the test results.
+
+    If the optional argument ``method`` is given, only tests for this method
+    are returned.
+    """
+    # Get all modules imported into this module
+    modules = [getattr(ft, x) for x in dir(ft) if not x.startswith('_')]
+    modules = [x for x in modules if inspect.ismodule(x)]
+
+    # Look for (explicitly defined) tests
+    tests = []
+    for module in modules:
+        try:
+            m_method = module._method
+            m_tests = module._functional_tests
+        except AttributeError:
+            continue
+
+        if method is None or method == m_method:
+            for test in m_tests:
+                tests.append((m_method, test))
+
+    return tests
+
diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index 1951f6f5f1..9ff41d8024 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -113,3 +113,12 @@ def annulus(n_iterations=10000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.DifferentialEvolutionMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    correlated_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index 2216cdaa00..119e9bb668 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -87,3 +87,11 @@ def correlated_gaussian(n_iterations=8000):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.DramACMC
+_functional_tests = [
+    banana,
+    correlated_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index ab0729b162..85424a50b5 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -113,3 +113,12 @@ def annulus(n_iterations=10000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.DreamMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    correlated_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index 7d6a6fc57e..18c8edd686 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -166,3 +166,14 @@ def cone(n_iterations=10000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.EmceeHammerMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    cone,
+    correlated_gaussian,
+    multimodal_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index 682827d23f..b93edf83af 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -87,3 +87,12 @@ def correlated_gaussian(n_iterations=8000):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.HaarioACMC
+_functional_tests = [
+    banana,
+    correlated_gaussian,
+    two_dim_gaussian,
+]
+
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 1e505d38a5..7c06425c38 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -113,3 +113,12 @@ def annulus(n_iterations=4000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.HaarioBardenetACMC
+_functional_tests = [
+    annulus,
+    banana,
+    correlated_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index c8d086aa04..313f8ea416 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -89,3 +89,11 @@ def high_dim_gaussian(n_iterations=4000):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.HamiltonianMCMC
+_functional_tests = [
+    banana,
+    high_dim_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index 2830bff19f..468caa1a29 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -87,3 +87,11 @@ def correlated_gaussian(n_iterations=8000):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.MetropolisRandomWalkMCMC
+_functional_tests = [
+    banana,
+    correlated_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index 9fe849ae50..850916adfe 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -199,3 +199,15 @@ def cone(n_iterations=2000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.MonomialGammaHamiltonianMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    cone,
+    correlated_gaussian,
+    high_dim_gaussian,
+    multimodal_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index e1995449b3..68058f1f7d 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -86,3 +86,11 @@ def high_dim_gaussian(n_iterations=4000):
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.NoUTurnMCMC
+_functional_tests = [
+    banana,
+    high_dim_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index 111b66e7ab..6f2779798a 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -93,3 +93,10 @@ def multimodal_gaussian(n_iterations=20000, n_temperatures=None):
         'mean-ess': problem.estimate_mean_ess()
     }
 
+
+_method = pints.PopulationMCMC
+_functional_tests = [
+    banana,
+    multimodal_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index 063ee5106f..4d4e4054e2 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -199,3 +199,15 @@ def cone(n_iterations=2000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.RelativisticMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    cone,
+    correlated_gaussian,
+    high_dim_gaussian,
+    multimodal_gaussian,
+    two_dim_gaussian,
+]
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index e1968069e6..aebbdb776b 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -192,3 +192,15 @@ def cone(n_iterations=5000):
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.SliceStepoutMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    cone,
+    correlated_gaussian,
+    high_dim_gaussian,
+    multimodal_gaussian,
+    two_dim_gaussian,
+]

From 32033d5e81ee95add9431495920207406bf4dafe Mon Sep 17 00:00:00 2001
From: Fergus Cooper <fcooper8472@gmail.com>
Date: Thu, 12 Aug 2021 16:48:42 +0100
Subject: [PATCH 55/73] Add MALA methods

---
 pints/functionaltests/mala_mcmc.py | 137 +++++++++++++++++++++++++++++
 1 file changed, 137 insertions(+)
 create mode 100644 pints/functionaltests/mala_mcmc.py

diff --git a/pints/functionaltests/mala_mcmc.py b/pints/functionaltests/mala_mcmc.py
new file mode 100644
index 0000000000..7ee97b35a2
--- /dev/null
+++ b/pints/functionaltests/mala_mcmc.py
@@ -0,0 +1,137 @@
+#!/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.
+#
+
+from __future__ import division
+
+import pints
+
+from ._problems import (RunMcmcMethodOnTwoDimGaussian,
+                        RunMcmcMethodOnBanana,
+                        RunMcmcMethodOnHighDimensionalGaussian,
+                        RunMcmcMethodOnCorrelatedGaussian,
+                        RunMcmcMethodOnAnnulus,
+                        RunMcmcMethodOnMultimodalGaussian,
+                        RunMcmcMethodOnCone)
+
+
+def test_mala_mcmc_on_two_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 1000
+    problem = RunMcmcMethodOnTwoDimGaussian(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=200,
+        method_hyper_parameters=[[1.0, 1.0]]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_mala_mcmc_on_banana(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnBanana(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[[0.8] * 2]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_mala_mcmc_on_high_dim_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnHighDimensionalGaussian(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[[1.2] * 20]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_mala_mcmc_on_correlated_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnCorrelatedGaussian(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[[1.0] * 6]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_mala_mcmc_on_annulus(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnAnnulus(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[[1.2] * 2]
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_mala_mcmc_on_multimodal_gaussian(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnMultimodalGaussian(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[[2.0] * 2]
+    )
+
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def test_mala_mcmc_on_cone(n_iterations=None):
+    if n_iterations is None:
+        n_iterations = 2000
+    problem = RunMcmcMethodOnCone(
+        method=pints.MALAMCMC,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=500,
+        method_hyper_parameters=[[1.0, 1.0]]
+    )
+
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }

From 6c8f607e17264c2910bf2eeb4c4d5cd3608001ec Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Mon, 16 Aug 2021 09:21:47 +0100
Subject: [PATCH 56/73] Updated new MALA tests.

---
 pints/functionaltests/mala_mcmc.py | 170 +++++++++++++++++++++--------
 1 file changed, 123 insertions(+), 47 deletions(-)

diff --git a/pints/functionaltests/mala_mcmc.py b/pints/functionaltests/mala_mcmc.py
index 7ee97b35a2..03883c954e 100644
--- a/pints/functionaltests/mala_mcmc.py
+++ b/pints/functionaltests/mala_mcmc.py
@@ -1,31 +1,33 @@
 #!/usr/bin/env python3
 #
+# Functional tests for MALA MCMC
+#
 # 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 division
-
 import pints
+import pints.functionaltests as ft
 
-from ._problems import (RunMcmcMethodOnTwoDimGaussian,
-                        RunMcmcMethodOnBanana,
-                        RunMcmcMethodOnHighDimensionalGaussian,
-                        RunMcmcMethodOnCorrelatedGaussian,
-                        RunMcmcMethodOnAnnulus,
-                        RunMcmcMethodOnMultimodalGaussian,
-                        RunMcmcMethodOnCone)
 
+def two_dim_gaussian(n_iterations=1000):
+    """
+    Tests :class:`pints.MALAMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
-def test_mala_mcmc_on_two_dim_gaussian(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 1000
-    problem = RunMcmcMethodOnTwoDimGaussian(
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    """
+    n_warmup = 200
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=200,
+        n_warmup=n_warmup,
         method_hyper_parameters=[[1.0, 1.0]]
     )
 
@@ -35,14 +37,24 @@ def test_mala_mcmc_on_two_dim_gaussian(n_iterations=None):
     }
 
 
-def test_mala_mcmc_on_banana(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 2000
-    problem = RunMcmcMethodOnBanana(
+def banana(n_iterations=2000):
+    """
+    Tests :class:`pints.MALAMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    """
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnBanana(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[[0.8] * 2]
     )
 
@@ -52,14 +64,24 @@ def test_mala_mcmc_on_banana(n_iterations=None):
     }
 
 
-def test_mala_mcmc_on_high_dim_gaussian(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 2000
-    problem = RunMcmcMethodOnHighDimensionalGaussian(
+def high_dim_gaussian(n_iterations=2000):
+    """
+     Tests :class:`pints.MALAMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[[1.2] * 20]
     )
 
@@ -69,14 +91,25 @@ def test_mala_mcmc_on_high_dim_gaussian(n_iterations=None):
     }
 
 
-def test_mala_mcmc_on_correlated_gaussian(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 2000
-    problem = RunMcmcMethodOnCorrelatedGaussian(
+def correlated_gaussian(n_iterations=2000):
+    """
+    Tests :class:`pints.MALAMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[[1.0] * 6]
     )
 
@@ -86,15 +119,25 @@ def test_mala_mcmc_on_correlated_gaussian(n_iterations=None):
     }
 
 
-def test_mala_mcmc_on_annulus(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 2000
-    problem = RunMcmcMethodOnAnnulus(
+def annulus(n_iterations=2000):
+    """
+    Tests :class:`pints.MALAMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    """
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
-        method_hyper_parameters=[[1.2] * 2]
+        n_warmup=n_warmup,
+        method_hyper_parameters=[[1.2] * 2],
     )
 
     return {
@@ -103,14 +146,25 @@ def test_mala_mcmc_on_annulus(n_iterations=None):
     }
 
 
-def test_mala_mcmc_on_multimodal_gaussian(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 2000
-    problem = RunMcmcMethodOnMultimodalGaussian(
+def multimodal_gaussian(n_iterations=2000):
+    """
+    Tests :class:`pints.MALAMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    """
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
+        n_warmup=n_warmup,
         method_hyper_parameters=[[2.0] * 2]
     )
 
@@ -120,18 +174,40 @@ def test_mala_mcmc_on_multimodal_gaussian(n_iterations=None):
     }
 
 
-def test_mala_mcmc_on_cone(n_iterations=None):
-    if n_iterations is None:
-        n_iterations = 2000
-    problem = RunMcmcMethodOnCone(
+def cone(n_iterations=2000):
+    """
+    Tests :class:`pints.MALAMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    """
+    n_warmup = 500
+    if n_warmup > n_iterations // 2:
+        n_warmup = n_iterations // 10
+
+    problem = ft.RunMcmcMethodOnCone(
         method=pints.MALAMCMC,
         n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=500,
-        method_hyper_parameters=[[1.0, 1.0]]
+        n_warmup=n_warmup,
+        method_hyper_parameters=[[1.0, 1.0]],
     )
 
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
+
+
+_method = pints.MALAMCMC
+_functional_tests = [
+    annulus,
+    banana,
+    cone,
+    correlated_gaussian,
+    high_dim_gaussian,
+    multimodal_gaussian,
+    two_dim_gaussian,
+]

From 1e434c58188421ce0c0f0646d297ce49e5b2f716 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Mon, 16 Aug 2021 11:04:44 +0100
Subject: [PATCH 57/73] Updated new MALA tests.

---
 pints/functionaltests/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pints/functionaltests/__init__.py b/pints/functionaltests/__init__.py
index afb340246a..ee5981e634 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/functionaltests/__init__.py
@@ -29,6 +29,7 @@
     haario_acmc,
     haario_bardenet_acmc,
     hamiltonian_mcmc,
+    mala_mcmc,
     metropolis_random_walk_mcmc,
     monomial_gamma_hamiltonian_mcmc,
     no_u_turn_mcmc,

From 14c0263d3ac502732314bbc79f8efedb5a81413b Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Mon, 16 Aug 2021 11:04:55 +0100
Subject: [PATCH 58/73] Made ft warmup a user-set parameter.

---
 .../differential_evolution_mcmc.py            | 24 ++---------
 pints/functionaltests/dram_acmc.py            | 18 ++------
 pints/functionaltests/dream_mcmc.py           | 24 ++---------
 pints/functionaltests/emcee_hammer_mcmc.py    | 36 +++-------------
 pints/functionaltests/haario_acmc.py          | 18 ++------
 pints/functionaltests/haario_bardenet_acmc.py | 24 ++---------
 pints/functionaltests/hamiltonian_mcmc.py     | 18 ++------
 pints/functionaltests/mala_mcmc.py            | 42 ++++---------------
 .../metropolis_random_walk_mcmc.py            | 18 ++------
 .../monomial_gamma_hamiltonian_mcmc.py        | 38 ++++-------------
 pints/functionaltests/no_u_turn_mcmc.py       | 18 ++------
 pints/functionaltests/population_mcmc.py      | 19 ++-------
 pints/functionaltests/relativistic_mcmc.py    | 42 ++++---------------
 pints/functionaltests/slice_stepout_mcmc.py   | 42 ++++---------------
 14 files changed, 65 insertions(+), 316 deletions(-)

diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index 9ff41d8024..f4510cac45 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=10000):
+def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=10000):
     }
 
 
-def banana(n_iterations=5000):
+def banana(n_iterations=5000, n_warmup=1000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
@@ -62,7 +54,7 @@ def banana(n_iterations=5000):
     }
 
 
-def correlated_gaussian(n_iterations=10000):
+def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=20,
@@ -89,7 +77,7 @@ def correlated_gaussian(n_iterations=10000):
     }
 
 
-def annulus(n_iterations=10000):
+def annulus(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.DifferentialEvolutionMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -98,10 +86,6 @@ def annulus(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.DifferentialEvolutionMCMC,
         n_chains=10,
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index 119e9bb668..17f82242f6 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=8000):
+def two_dim_gaussian(n_iterations=8000, n_warmup=2000):
     """
     Tests :class:`pints.DramACMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=8000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 2000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DramACMC,
         n_chains=4,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=8000):
     }
 
 
-def banana(n_iterations=4000):
+def banana(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.DramACMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DramACMC,
         n_chains=4,
@@ -62,7 +54,7 @@ def banana(n_iterations=4000):
     }
 
 
-def correlated_gaussian(n_iterations=8000):
+def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     """
     Tests :class:`pints.DramACMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=8000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 4000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DramACMC,
         n_chains=4,
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index 85424a50b5..e8e75bf407 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=10000):
+def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.DreamMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.DreamMCMC,
         n_chains=10,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=10000):
     }
 
 
-def banana(n_iterations=5000):
+def banana(n_iterations=5000, n_warmup=1000):
     """
     Tests :class:`pints.DreamMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.DreamMCMC,
         n_chains=20,
@@ -62,7 +54,7 @@ def banana(n_iterations=5000):
     }
 
 
-def correlated_gaussian(n_iterations=10000):
+def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.DreamMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.DreamMCMC,
         n_chains=20,
@@ -89,7 +77,7 @@ def correlated_gaussian(n_iterations=10000):
     }
 
 
-def annulus(n_iterations=10000):
+def annulus(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.DreamMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -98,10 +86,6 @@ def annulus(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.DreamMCMC,
         n_chains=10,
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index 18c8edd686..8071a25080 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=10000):
+def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=10000):
     }
 
 
-def banana(n_iterations=10000):
+def banana(n_iterations=10000, n_warmup=2000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 2000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
@@ -62,7 +54,7 @@ def banana(n_iterations=10000):
     }
 
 
-def correlated_gaussian(n_iterations=8000):
+def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=8000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 4000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
@@ -89,7 +77,7 @@ def correlated_gaussian(n_iterations=8000):
     }
 
 
-def annulus(n_iterations=4000):
+def annulus(n_iterations=4000, n_warmup=2000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -98,10 +86,6 @@ def annulus(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 2000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
@@ -115,7 +99,7 @@ def annulus(n_iterations=4000):
     }
 
 
-def multimodal_gaussian(n_iterations=10000):
+def multimodal_gaussian(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -125,10 +109,6 @@ def multimodal_gaussian(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
@@ -142,7 +122,7 @@ def multimodal_gaussian(n_iterations=10000):
     }
 
 
-def cone(n_iterations=10000):
+def cone(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.EmceeHammerMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -151,10 +131,6 @@ def cone(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCone(
         method=pints.EmceeHammerMCMC,
         n_chains=10,
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index b93edf83af..c6e8df611f 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=4000):
+def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.HaarioACMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=4000):
     }
 
 
-def banana(n_iterations=4000):
+def banana(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.HaarioACMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.HaarioACMC,
         n_chains=4,
@@ -62,7 +54,7 @@ def banana(n_iterations=4000):
     }
 
 
-def correlated_gaussian(n_iterations=8000):
+def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     """
     Tests :class:`pints.HaarioACMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=8000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 4000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.HaarioACMC,
         n_chains=4,
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index 7c06425c38..a6aafd9f09 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=4000):
+def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=4000):
     }
 
 
-def banana(n_iterations=4000):
+def banana(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
@@ -62,7 +54,7 @@ def banana(n_iterations=4000):
     }
 
 
-def correlated_gaussian(n_iterations=8000):
+def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=8000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 4000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
@@ -89,7 +77,7 @@ def correlated_gaussian(n_iterations=8000):
     }
 
 
-def annulus(n_iterations=4000):
+def annulus(n_iterations=4000, n_warmup=2000):
     """
     Tests :class:`pints.HaarioBardenetACMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -98,10 +86,6 @@ def annulus(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 2000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.HaarioBardenetACMC,
         n_chains=4,
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index 313f8ea416..8720673d91 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=1000):
+def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     """
     Tests :class:`pints.HamiltonianMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=1000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 200
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
@@ -37,7 +33,7 @@ def two_dim_gaussian(n_iterations=1000):
     }
 
 
-def banana(n_iterations=2000):
+def banana(n_iterations=2000, n_warmup=1000):
     """
     Tests :class:`pints.HamiltonianMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -46,10 +42,6 @@ def banana(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.HamiltonianMCMC,
         n_chains=4,
@@ -64,7 +56,7 @@ def banana(n_iterations=2000):
     }
 
 
-def high_dim_gaussian(n_iterations=4000):
+def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     """
      Tests :class:`pints.HamiltonianMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -73,10 +65,6 @@ def high_dim_gaussian(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.HamiltonianMCMC,
         n_chains=4,
diff --git a/pints/functionaltests/mala_mcmc.py b/pints/functionaltests/mala_mcmc.py
index 03883c954e..0de389afe4 100644
--- a/pints/functionaltests/mala_mcmc.py
+++ b/pints/functionaltests/mala_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=1000):
+def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     """
     Tests :class:`pints.MALAMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=1000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 200
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
@@ -37,7 +33,7 @@ def two_dim_gaussian(n_iterations=1000):
     }
 
 
-def banana(n_iterations=2000):
+def banana(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MALAMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -46,10 +42,6 @@ def banana(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.MALAMCMC,
         n_chains=4,
@@ -64,7 +56,7 @@ def banana(n_iterations=2000):
     }
 
 
-def high_dim_gaussian(n_iterations=2000):
+def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     """
      Tests :class:`pints.MALAMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -73,10 +65,6 @@ def high_dim_gaussian(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
@@ -91,7 +79,7 @@ def high_dim_gaussian(n_iterations=2000):
     }
 
 
-def correlated_gaussian(n_iterations=2000):
+def correlated_gaussian(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MALAMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -101,10 +89,6 @@ def correlated_gaussian(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
@@ -119,7 +103,7 @@ def correlated_gaussian(n_iterations=2000):
     }
 
 
-def annulus(n_iterations=2000):
+def annulus(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MALAMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -128,10 +112,6 @@ def annulus(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.MALAMCMC,
         n_chains=4,
@@ -146,7 +126,7 @@ def annulus(n_iterations=2000):
     }
 
 
-def multimodal_gaussian(n_iterations=2000):
+def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MALAMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -156,10 +136,6 @@ def multimodal_gaussian(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.MALAMCMC,
         n_chains=4,
@@ -174,7 +150,7 @@ def multimodal_gaussian(n_iterations=2000):
     }
 
 
-def cone(n_iterations=2000):
+def cone(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MALAMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -183,10 +159,6 @@ def cone(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCone(
         method=pints.MALAMCMC,
         n_chains=4,
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index 468caa1a29..a13c3057db 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=4000):
+def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.MetropolisRandomWalkMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=4000):
     }
 
 
-def banana(n_iterations=4000):
+def banana(n_iterations=4000, n_warmup=1000):
     """
     Tests :class:`pints.MetropolisRandomWalkMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
@@ -62,7 +54,7 @@ def banana(n_iterations=4000):
     }
 
 
-def correlated_gaussian(n_iterations=8000):
+def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     """
     Tests :class:`pints.MetropolisRandomWalkMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -72,10 +64,6 @@ def correlated_gaussian(n_iterations=8000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 4000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.MetropolisRandomWalkMCMC,
         n_chains=4,
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index 850916adfe..c808c3f81a 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=1000):
+def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=1000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 200
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
@@ -37,7 +33,7 @@ def two_dim_gaussian(n_iterations=1000):
     }
 
 
-def banana(n_iterations=2000):
+def banana(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -46,10 +42,6 @@ def banana(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
@@ -64,7 +56,7 @@ def banana(n_iterations=2000):
     }
 
 
-def high_dim_gaussian(n_iterations=2000):
+def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     """
      Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -73,10 +65,6 @@ def high_dim_gaussian(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
@@ -91,7 +79,7 @@ def high_dim_gaussian(n_iterations=2000):
     }
 
 
-def correlated_gaussian(n_iterations=2000):
+def correlated_gaussian(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -119,7 +107,7 @@ def correlated_gaussian(n_iterations=2000):
     }
 
 
-def annulus(n_iterations=2000):
+def annulus(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -128,10 +116,6 @@ def annulus(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
@@ -146,7 +130,7 @@ def annulus(n_iterations=2000):
     }
 
 
-def multimodal_gaussian(n_iterations=2000):
+def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -156,10 +140,6 @@ def multimodal_gaussian(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
@@ -174,7 +154,7 @@ def multimodal_gaussian(n_iterations=2000):
     }
 
 
-def cone(n_iterations=2000):
+def cone(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.MonomialGammaHamiltonianMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -183,10 +163,6 @@ def cone(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCone(
         method=pints.MonomialGammaHamiltonianMCMC,
         n_chains=4,
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index 68058f1f7d..d627690ead 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=1000):
+def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     """
     Tests :class:`pints.NoUTurnMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=1000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 200
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.NoUTurnMCMC,
         n_chains=4,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=1000):
     }
 
 
-def banana(n_iterations=2000):
+def banana(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.NoUTurnMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.NoUTurnMCMC,
         n_chains=4,
@@ -62,7 +54,7 @@ def banana(n_iterations=2000):
     }
 
 
-def high_dim_gaussian(n_iterations=4000):
+def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     """
      Tests :class:`pints.NoUTurnMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -71,10 +63,6 @@ def high_dim_gaussian(n_iterations=4000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    n_warmup = 1000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.NoUTurnMCMC,
         n_chains=4,
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index 6f2779798a..b0390255b6 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=20000):
+def two_dim_gaussian(n_iterations=20000, n_warmup=500):
     """
     Tests :class:`pints.PopulationMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=20000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.PopulationMCMC,
         n_chains=1,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=20000):
     }
 
 
-def banana(n_iterations=20000):
+def banana(n_iterations=20000, n_warmup=5000):
     """
     Tests :class:`pints.PopulationMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -45,10 +41,6 @@ def banana(n_iterations=20000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 5000  # Needs a lot of warm-up on banana!
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.PopulationMCMC,
         n_chains=1,
@@ -62,7 +54,8 @@ def banana(n_iterations=20000):
     }
 
 
-def multimodal_gaussian(n_iterations=20000, n_temperatures=None):
+def multimodal_gaussian(
+        n_iterations=20000, n_warmup=500, n_temperatures=None):
     """
     Tests :class:`pints.PopulationMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -72,10 +65,6 @@ def multimodal_gaussian(n_iterations=20000, n_temperatures=None):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     method_hyper_parameters = None
     if n_temperatures is not None:
         method_hyper_parameters = [n_temperatures]
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index 4d4e4054e2..711acc6180 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=1000):
+def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=1000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 200
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
@@ -37,7 +33,7 @@ def two_dim_gaussian(n_iterations=1000):
     }
 
 
-def banana(n_iterations=5000):
+def banana(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -46,10 +42,6 @@ def banana(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.RelativisticMCMC,
         n_chains=4,
@@ -64,7 +56,7 @@ def banana(n_iterations=5000):
     }
 
 
-def high_dim_gaussian(n_iterations=5000):
+def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     """
      Tests :class:`pints.RelativisticMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -73,10 +65,6 @@ def high_dim_gaussian(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
@@ -91,7 +79,7 @@ def high_dim_gaussian(n_iterations=5000):
     }
 
 
-def correlated_gaussian(n_iterations=5000):
+def correlated_gaussian(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -101,10 +89,6 @@ def correlated_gaussian(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
@@ -119,7 +103,7 @@ def correlated_gaussian(n_iterations=5000):
     }
 
 
-def annulus(n_iterations=5000):
+def annulus(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -128,10 +112,6 @@ def annulus(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.RelativisticMCMC,
         n_chains=4,
@@ -146,7 +126,7 @@ def annulus(n_iterations=5000):
     }
 
 
-def multimodal_gaussian(n_iterations=2000):
+def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -156,10 +136,6 @@ def multimodal_gaussian(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.RelativisticMCMC,
         n_chains=4,
@@ -174,7 +150,7 @@ def multimodal_gaussian(n_iterations=2000):
     }
 
 
-def cone(n_iterations=2000):
+def cone(n_iterations=2000, n_warmup=500):
     """
     Tests :class:`pints.RelativisticMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -183,10 +159,6 @@ def cone(n_iterations=2000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCone(
         method=pints.RelativisticMCMC,
         n_chains=4,
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index aebbdb776b..876c97762b 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -10,7 +10,7 @@
 import pints.functionaltests as ft
 
 
-def two_dim_gaussian(n_iterations=5000):
+def two_dim_gaussian(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional Gaussian distribution with true solution
@@ -19,10 +19,6 @@ def two_dim_gaussian(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
@@ -36,7 +32,7 @@ def two_dim_gaussian(n_iterations=5000):
     }
 
 
-def correlated_gaussian(n_iterations=5000):
+def correlated_gaussian(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a six-dimensional highly correlated Gaussian distribution with true
@@ -46,10 +42,6 @@ def correlated_gaussian(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
@@ -63,7 +55,7 @@ def correlated_gaussian(n_iterations=5000):
     }
 
 
-def banana(n_iterations=5000):
+def banana(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional "twisted Gaussian" distribution with true solution
@@ -72,10 +64,6 @@ def banana(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnBanana(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
@@ -89,7 +77,7 @@ def banana(n_iterations=5000):
     }
 
 
-def high_dim_gaussian(n_iterations=5000):
+def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     """
      Tests :class:`pints.SliceStepoutMCMC`
     on a 20-dimensional Gaussian distribution centered at the origin, and
@@ -98,10 +86,6 @@ def high_dim_gaussian(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
@@ -115,7 +99,7 @@ def high_dim_gaussian(n_iterations=5000):
     }
 
 
-def annulus(n_iterations=10000):
+def annulus(n_iterations=10000, n_warmup=2000):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -124,10 +108,6 @@ def annulus(n_iterations=10000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
-    n_warmup = 2000
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnAnnulus(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
@@ -141,7 +121,7 @@ def annulus(n_iterations=10000):
     }
 
 
-def multimodal_gaussian(n_iterations=5000):
+def multimodal_gaussian(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional multi-modal Gaussian distribution with modes at
@@ -151,10 +131,6 @@ def multimodal_gaussian(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=pints.SliceStepoutMCMC,
         n_chains=4,
@@ -168,7 +144,7 @@ def multimodal_gaussian(n_iterations=5000):
     }
 
 
-def cone(n_iterations=5000):
+def cone(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.SliceStepoutMCMC`
     on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
@@ -177,10 +153,6 @@ def cone(n_iterations=5000):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCone(
         method=pints.SliceStepoutMCMC,
         n_chains=4,

From 2ed963feb0d19268cba040812d0cbe154e784672 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Mon, 16 Aug 2021 11:23:11 +0100
Subject: [PATCH 59/73] Slightly simplified ft code.

---
 .../differential_evolution_mcmc.py            | 28 ++---------
 pints/functionaltests/dram_acmc.py            | 21 ++------
 pints/functionaltests/dream_mcmc.py           | 27 ++--------
 pints/functionaltests/emcee_hammer_mcmc.py    | 42 +++-------------
 pints/functionaltests/haario_acmc.py          | 21 ++------
 pints/functionaltests/haario_bardenet_acmc.py | 28 ++---------
 pints/functionaltests/hamiltonian_mcmc.py     |  9 ++--
 pints/functionaltests/mala_mcmc.py            | 20 +++-----
 .../metropolis_random_walk_mcmc.py            | 21 ++------
 .../monomial_gamma_hamiltonian_mcmc.py        | 25 +++-------
 pints/functionaltests/no_u_turn_mcmc.py       | 21 ++------
 pints/functionaltests/population_mcmc.py      | 15 ++----
 pints/functionaltests/relativistic_mcmc.py    | 21 +++-----
 pints/functionaltests/slice_stepout_mcmc.py   | 49 +++----------------
 14 files changed, 64 insertions(+), 284 deletions(-)

diff --git a/pints/functionaltests/differential_evolution_mcmc.py b/pints/functionaltests/differential_evolution_mcmc.py
index f4510cac45..35ceea8208 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/functionaltests/differential_evolution_mcmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.DifferentialEvolutionMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=5000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.DifferentialEvolutionMCMC,
-        n_chains=20,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.DifferentialEvolutionMCMC,
-        n_chains=20,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -87,12 +72,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.DifferentialEvolutionMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/dram_acmc.py b/pints/functionaltests/dram_acmc.py
index 17f82242f6..2ec83eea66 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/functionaltests/dram_acmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=8000, n_warmup=2000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.DramACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.DramACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.DramACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/functionaltests/dream_mcmc.py
index e8e75bf407..ca6745a4b3 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/functionaltests/dream_mcmc.py
@@ -20,11 +20,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.DreamMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
+        _method, 10, n_iterations, n_warmup)
 
     return {
         'kld': problem.estimate_kld(),
@@ -42,12 +38,7 @@ def banana(n_iterations=5000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.DreamMCMC,
-        n_chains=20,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +56,7 @@ def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.DreamMCMC,
-        n_chains=20,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -87,12 +73,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.DreamMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/functionaltests/emcee_hammer_mcmc.py
index 8071a25080..cc36eecee1 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/functionaltests/emcee_hammer_mcmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.EmceeHammerMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=10000, n_warmup=2000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.EmceeHammerMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.EmceeHammerMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -87,12 +72,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.EmceeHammerMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
@@ -110,12 +90,7 @@ def multimodal_gaussian(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
-        method=pints.EmceeHammerMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -132,12 +107,7 @@ def cone(n_iterations=10000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
-        method=pints.EmceeHammerMCMC,
-        n_chains=10,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/haario_acmc.py b/pints/functionaltests/haario_acmc.py
index c6e8df611f..b3adfeb47e 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/functionaltests/haario_acmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.HaarioACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.HaarioACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.HaarioACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/functionaltests/haario_bardenet_acmc.py
index a6aafd9f09..b55dcf68eb 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/functionaltests/haario_bardenet_acmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.HaarioBardenetACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.HaarioBardenetACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.HaarioBardenetACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -87,12 +72,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.HaarioBardenetACMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/functionaltests/hamiltonian_mcmc.py
index 8720673d91..43cf4ab578 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/functionaltests/hamiltonian_mcmc.py
@@ -20,13 +20,12 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.HamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -43,13 +42,12 @@ def banana(n_iterations=2000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.HamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 2]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -66,13 +64,12 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
-        method=pints.HamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/mala_mcmc.py b/pints/functionaltests/mala_mcmc.py
index 0de389afe4..5bd8c28ad7 100644
--- a/pints/functionaltests/mala_mcmc.py
+++ b/pints/functionaltests/mala_mcmc.py
@@ -20,13 +20,12 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[[1.0, 1.0]]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -43,13 +42,12 @@ def banana(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[[0.8] * 2]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -66,7 +64,7 @@ def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
@@ -90,13 +88,12 @@ def correlated_gaussian(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[[1.0] * 6]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -113,13 +110,12 @@ def annulus(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[[1.2] * 2],
     )
-
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
@@ -137,13 +133,12 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[[2.0] * 2]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -160,13 +155,12 @@ def cone(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
-        method=pints.MALAMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[[1.0, 1.0]],
     )
-
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/functionaltests/metropolis_random_walk_mcmc.py
index a13c3057db..e920a33688 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/functionaltests/metropolis_random_walk_mcmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.MetropolisRandomWalkMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.MetropolisRandomWalkMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.MetropolisRandomWalkMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
index c808c3f81a..1048a21523 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
@@ -20,13 +20,12 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -43,13 +42,12 @@ def banana(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -66,13 +64,12 @@ def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -89,18 +86,13 @@ def correlated_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    n_warmup = 500
-    if n_warmup > n_iterations // 2:
-        n_warmup = n_iterations // 10
-
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -117,13 +109,12 @@ def annulus(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
@@ -141,13 +132,12 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -164,13 +154,12 @@ def cone(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
-        method=pints.MonomialGammaHamiltonianMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.5, 0.2, 1]
     )
-
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/functionaltests/no_u_turn_mcmc.py
index d627690ead..7ca868e942 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/functionaltests/no_u_turn_mcmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.NoUTurnMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -42,12 +37,7 @@ def banana(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.NoUTurnMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -64,12 +54,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
-        method=pints.NoUTurnMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/population_mcmc.py b/pints/functionaltests/population_mcmc.py
index b0390255b6..f525d40fb5 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/functionaltests/population_mcmc.py
@@ -20,11 +20,7 @@ def two_dim_gaussian(n_iterations=20000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.PopulationMCMC,
-        n_chains=1,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup
-    )
+        _method, 1, n_iterations, n_warmup)
 
     return {
         'kld': problem.estimate_kld(),
@@ -42,12 +38,7 @@ def banana(n_iterations=20000, n_warmup=5000):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.PopulationMCMC,
-        n_chains=1,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup
-    )
-
+        _method, 1, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -70,7 +61,7 @@ def multimodal_gaussian(
         method_hyper_parameters = [n_temperatures]
 
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
-        method=pints.PopulationMCMC,
+        method=_method,
         n_chains=1,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/functionaltests/relativistic_mcmc.py
index 711acc6180..bbace567d6 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/functionaltests/relativistic_mcmc.py
@@ -20,13 +20,12 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -43,13 +42,12 @@ def banana(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -66,13 +64,12 @@ def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -90,13 +87,12 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -113,13 +109,12 @@ def annulus(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
@@ -137,13 +132,12 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -160,13 +154,12 @@ def cone(n_iterations=2000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
-        method=pints.RelativisticMCMC,
+        method=_method,
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
         method_hyper_parameters=[20, 1, 0.1, 10]
     )
-
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/functionaltests/slice_stepout_mcmc.py
index 876c97762b..40c78b91c3 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/functionaltests/slice_stepout_mcmc.py
@@ -20,12 +20,7 @@ def two_dim_gaussian(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -43,12 +38,7 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -65,12 +55,7 @@ def banana(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -87,12 +72,7 @@ def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -109,12 +89,7 @@ def annulus(n_iterations=10000, n_warmup=2000):
     :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
@@ -132,12 +107,7 @@ def multimodal_gaussian(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
         'mean-ess': problem.estimate_mean_ess()
@@ -154,12 +124,7 @@ def cone(n_iterations=5000, n_warmup=500):
     :class:`pints.functionaltests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
-        method=pints.SliceStepoutMCMC,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-    )
-
+        _method, 4, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()

From 4d757a38e8a26696c3b837fa1969e5b6a9c96a82 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 17 Aug 2021 12:58:04 +0100
Subject: [PATCH 60/73] Renamed function to change point tests. Closes #1391.

---
 .../{functionaltests => cptests}/__init__.py  |  6 +++---
 .../_discovery.py                             |  8 ++++----
 .../{functionaltests => cptests}/_problems.py |  2 +-
 .../differential_evolution_mcmc.py            | 14 ++++++-------
 .../{functionaltests => cptests}/dram_acmc.py | 12 +++++------
 .../dream_mcmc.py                             | 14 ++++++-------
 .../emcee_hammer_mcmc.py                      | 18 ++++++++---------
 .../haario_acmc.py                            | 12 +++++------
 .../haario_bardenet_acmc.py                   | 14 ++++++-------
 .../hamiltonian_mcmc.py                       | 12 +++++------
 .../{functionaltests => cptests}/mala_mcmc.py | 18 ++++++++---------
 .../metropolis_random_walk_mcmc.py            | 12 +++++------
 .../monomial_gamma_hamiltonian_mcmc.py        | 20 +++++++++----------
 .../no_u_turn_mcmc.py                         | 12 +++++------
 .../population_mcmc.py                        | 12 +++++------
 .../relativistic_mcmc.py                      | 20 +++++++++----------
 .../slice_stepout_mcmc.py                     | 20 +++++++++----------
 17 files changed, 113 insertions(+), 113 deletions(-)
 rename pints/{functionaltests => cptests}/__init__.py (87%)
 rename pints/{functionaltests => cptests}/_discovery.py (83%)
 rename pints/{functionaltests => cptests}/_problems.py (99%)
 rename pints/{functionaltests => cptests}/differential_evolution_mcmc.py (87%)
 rename pints/{functionaltests => cptests}/dram_acmc.py (86%)
 rename pints/{functionaltests => cptests}/dream_mcmc.py (87%)
 rename pints/{functionaltests => cptests}/emcee_hammer_mcmc.py (87%)
 rename pints/{functionaltests => cptests}/haario_acmc.py (86%)
 rename pints/{functionaltests => cptests}/haario_bardenet_acmc.py (87%)
 rename pints/{functionaltests => cptests}/hamiltonian_mcmc.py (87%)
 rename pints/{functionaltests => cptests}/mala_mcmc.py (90%)
 rename pints/{functionaltests => cptests}/metropolis_random_walk_mcmc.py (86%)
 rename pints/{functionaltests => cptests}/monomial_gamma_hamiltonian_mcmc.py (89%)
 rename pints/{functionaltests => cptests}/no_u_turn_mcmc.py (86%)
 rename pints/{functionaltests => cptests}/population_mcmc.py (88%)
 rename pints/{functionaltests => cptests}/relativistic_mcmc.py (89%)
 rename pints/{functionaltests => cptests}/slice_stepout_mcmc.py (87%)

diff --git a/pints/functionaltests/__init__.py b/pints/cptests/__init__.py
similarity index 87%
rename from pints/functionaltests/__init__.py
rename to pints/cptests/__init__.py
index ee5981e634..278054ddff 100644
--- a/pints/functionaltests/__init__.py
+++ b/pints/cptests/__init__.py
@@ -1,5 +1,5 @@
 #
-# "Functional test" module for PINTS.
+# Change point tests for PINTS.
 #
 # 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
@@ -7,7 +7,7 @@
 #
 
 # Import all problem classes straight into this module, so that they can be
-# addressed as e.g. pints.functionaltests.RunMcmcMethodOnAnnulus.
+# addressed as e.g. pints.cptests.RunMcmcMethodOnAnnulus.
 from ._problems import (    # noqa
     RunMcmcMethodOnAnnulus,
     RunMcmcMethodOnBanana,
@@ -20,7 +20,7 @@
 
 # Import all test modules (not methods!) directly into this method, so that
 # they can be addressed as e.g.
-# pints.functionaltests.dram_acmc.two_dim_gaussian().
+# pints.cptests.dram_acmc.two_dim_gaussian().
 from . import (     # noqa
     differential_evolution_mcmc,
     dram_acmc,
diff --git a/pints/functionaltests/_discovery.py b/pints/cptests/_discovery.py
similarity index 83%
rename from pints/functionaltests/_discovery.py
rename to pints/cptests/_discovery.py
index 38227f85ee..71d6585d52 100644
--- a/pints/functionaltests/_discovery.py
+++ b/pints/cptests/_discovery.py
@@ -1,5 +1,5 @@
 #
-# Functional test discovery methods for PINTS.
+# Change point test discovery methods for PINTS.
 #
 # 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
@@ -7,12 +7,12 @@
 #
 import inspect
 
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def tests(method=None):
     """
-    Returns a list of all functional tests, each represented as a tuple
+    Returns a list of all change point tests, each represented as a tuple
     ``(method, test)`` where ``method`` is the PINTS class being tested and
     ``test`` is a callable that returns the test results.
 
@@ -28,7 +28,7 @@ def tests(method=None):
     for module in modules:
         try:
             m_method = module._method
-            m_tests = module._functional_tests
+            m_tests = module._change_point_tests
         except AttributeError:
             continue
 
diff --git a/pints/functionaltests/_problems.py b/pints/cptests/_problems.py
similarity index 99%
rename from pints/functionaltests/_problems.py
rename to pints/cptests/_problems.py
index 7b0409e6c1..8298732852 100644
--- a/pints/functionaltests/_problems.py
+++ b/pints/cptests/_problems.py
@@ -1,5 +1,5 @@
 #
-# Shared problems used in functional testing.
+# Shared problems used in change point testing.
 #
 # 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/functionaltests/differential_evolution_mcmc.py b/pints/cptests/differential_evolution_mcmc.py
similarity index 87%
rename from pints/functionaltests/differential_evolution_mcmc.py
rename to pints/cptests/differential_evolution_mcmc.py
index 35ceea8208..133ecf28e9 100644
--- a/pints/functionaltests/differential_evolution_mcmc.py
+++ b/pints/cptests/differential_evolution_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for DifferentialEvolutionMCMC
+# Change point tests for DifferentialEvolutionMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 10, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=5000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 20, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 20, n_iterations, n_warmup)
@@ -69,7 +69,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         _method, 10, n_iterations, n_warmup)
@@ -80,7 +80,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
 
 
 _method = pints.DifferentialEvolutionMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     correlated_gaussian,
diff --git a/pints/functionaltests/dram_acmc.py b/pints/cptests/dram_acmc.py
similarity index 86%
rename from pints/functionaltests/dram_acmc.py
rename to pints/cptests/dram_acmc.py
index 2ec83eea66..cb8ab9df1f 100644
--- a/pints/functionaltests/dram_acmc.py
+++ b/pints/cptests/dram_acmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for DramACMC
+# Change point tests for DramACMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=8000, n_warmup=2000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=8000, n_warmup=2000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -63,7 +63,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
 
 
 _method = pints.DramACMC
-_functional_tests = [
+_change_point_tests = [
     banana,
     correlated_gaussian,
     two_dim_gaussian,
diff --git a/pints/functionaltests/dream_mcmc.py b/pints/cptests/dream_mcmc.py
similarity index 87%
rename from pints/functionaltests/dream_mcmc.py
rename to pints/cptests/dream_mcmc.py
index ca6745a4b3..2d6293e757 100644
--- a/pints/functionaltests/dream_mcmc.py
+++ b/pints/cptests/dream_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for DreamMCMC
+# Change point tests for DreamMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 10, n_iterations, n_warmup)
@@ -35,7 +35,7 @@ def banana(n_iterations=5000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 20, n_iterations, n_warmup)
@@ -53,7 +53,7 @@ def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 20, n_iterations, n_warmup)
@@ -70,7 +70,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         _method, 10, n_iterations, n_warmup)
@@ -81,7 +81,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
 
 
 _method = pints.DreamMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     correlated_gaussian,
diff --git a/pints/functionaltests/emcee_hammer_mcmc.py b/pints/cptests/emcee_hammer_mcmc.py
similarity index 87%
rename from pints/functionaltests/emcee_hammer_mcmc.py
rename to pints/cptests/emcee_hammer_mcmc.py
index cc36eecee1..94ff62f5fd 100644
--- a/pints/functionaltests/emcee_hammer_mcmc.py
+++ b/pints/cptests/emcee_hammer_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for EmceeHammerMCMC
+# Change point tests for EmceeHammerMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 10, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=10000, n_warmup=2000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 10, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 10, n_iterations, n_warmup)
@@ -69,7 +69,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         _method, 10, n_iterations, n_warmup)
@@ -87,7 +87,7 @@ def multimodal_gaussian(n_iterations=10000, n_warmup=1000):
     "kld" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         _method, 10, n_iterations, n_warmup)
@@ -104,7 +104,7 @@ def cone(n_iterations=10000, n_warmup=1000):
     a dict with entries "distance" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
         _method, 10, n_iterations, n_warmup)
@@ -115,7 +115,7 @@ def cone(n_iterations=10000, n_warmup=1000):
 
 
 _method = pints.EmceeHammerMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     cone,
diff --git a/pints/functionaltests/haario_acmc.py b/pints/cptests/haario_acmc.py
similarity index 86%
rename from pints/functionaltests/haario_acmc.py
rename to pints/cptests/haario_acmc.py
index b3adfeb47e..5023ca1025 100644
--- a/pints/functionaltests/haario_acmc.py
+++ b/pints/cptests/haario_acmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for HaarioACMC
+# Change point tests for HaarioACMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -63,7 +63,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
 
 
 _method = pints.HaarioACMC
-_functional_tests = [
+_change_point_tests = [
     banana,
     correlated_gaussian,
     two_dim_gaussian,
diff --git a/pints/functionaltests/haario_bardenet_acmc.py b/pints/cptests/haario_bardenet_acmc.py
similarity index 87%
rename from pints/functionaltests/haario_bardenet_acmc.py
rename to pints/cptests/haario_bardenet_acmc.py
index b55dcf68eb..ebf409c6b1 100644
--- a/pints/functionaltests/haario_bardenet_acmc.py
+++ b/pints/cptests/haario_bardenet_acmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for HaarioBardenetACMC
+# Change point tests for HaarioBardenetACMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -69,7 +69,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         _method, 4, n_iterations, n_warmup)
@@ -80,7 +80,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
 
 
 _method = pints.HaarioBardenetACMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     correlated_gaussian,
diff --git a/pints/functionaltests/hamiltonian_mcmc.py b/pints/cptests/hamiltonian_mcmc.py
similarity index 87%
rename from pints/functionaltests/hamiltonian_mcmc.py
rename to pints/cptests/hamiltonian_mcmc.py
index 43cf4ab578..1bfcad3f93 100644
--- a/pints/functionaltests/hamiltonian_mcmc.py
+++ b/pints/cptests/hamiltonian_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for HamiltonianMCMC
+# Change point tests for HamiltonianMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
@@ -39,7 +39,7 @@ def banana(n_iterations=2000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         method=_method,
@@ -61,7 +61,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
@@ -77,7 +77,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
 
 
 _method = pints.HamiltonianMCMC
-_functional_tests = [
+_change_point_tests = [
     banana,
     high_dim_gaussian,
     two_dim_gaussian,
diff --git a/pints/functionaltests/mala_mcmc.py b/pints/cptests/mala_mcmc.py
similarity index 90%
rename from pints/functionaltests/mala_mcmc.py
rename to pints/cptests/mala_mcmc.py
index 5bd8c28ad7..23b58fd1ec 100644
--- a/pints/functionaltests/mala_mcmc.py
+++ b/pints/cptests/mala_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
@@ -39,7 +39,7 @@ def banana(n_iterations=2000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         method=_method,
@@ -61,7 +61,7 @@ def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
@@ -85,7 +85,7 @@ def correlated_gaussian(n_iterations=2000, n_warmup=500):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=_method,
@@ -107,7 +107,7 @@ def annulus(n_iterations=2000, n_warmup=500):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         method=_method,
@@ -130,7 +130,7 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     "kld" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
@@ -152,7 +152,7 @@ def cone(n_iterations=2000, n_warmup=500):
     a dict with entries "distance" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
         method=_method,
@@ -168,7 +168,7 @@ def cone(n_iterations=2000, n_warmup=500):
 
 
 _method = pints.MALAMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     cone,
diff --git a/pints/functionaltests/metropolis_random_walk_mcmc.py b/pints/cptests/metropolis_random_walk_mcmc.py
similarity index 86%
rename from pints/functionaltests/metropolis_random_walk_mcmc.py
rename to pints/cptests/metropolis_random_walk_mcmc.py
index e920a33688..23c264bb9f 100644
--- a/pints/functionaltests/metropolis_random_walk_mcmc.py
+++ b/pints/cptests/metropolis_random_walk_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for MetropolisRandomWalkMCMC
+# Change point tests for MetropolisRandomWalkMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -63,7 +63,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
 
 
 _method = pints.MetropolisRandomWalkMCMC
-_functional_tests = [
+_change_point_tests = [
     banana,
     correlated_gaussian,
     two_dim_gaussian,
diff --git a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py b/pints/cptests/monomial_gamma_hamiltonian_mcmc.py
similarity index 89%
rename from pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
rename to pints/cptests/monomial_gamma_hamiltonian_mcmc.py
index 1048a21523..5baec85072 100644
--- a/pints/functionaltests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/cptests/monomial_gamma_hamiltonian_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for MonomialGammaHamiltonianMCMC
+# Change point tests for MonomialGammaHamiltonianMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
@@ -39,7 +39,7 @@ def banana(n_iterations=2000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         method=_method,
@@ -61,7 +61,7 @@ def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
@@ -84,7 +84,7 @@ def correlated_gaussian(n_iterations=2000, n_warmup=500):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=_method,
@@ -106,7 +106,7 @@ def annulus(n_iterations=2000, n_warmup=500):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         method=_method,
@@ -129,7 +129,7 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     "kld" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
@@ -151,7 +151,7 @@ def cone(n_iterations=2000, n_warmup=500):
     a dict with entries "distance" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
         method=_method,
@@ -167,7 +167,7 @@ def cone(n_iterations=2000, n_warmup=500):
 
 
 _method = pints.MonomialGammaHamiltonianMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     cone,
diff --git a/pints/functionaltests/no_u_turn_mcmc.py b/pints/cptests/no_u_turn_mcmc.py
similarity index 86%
rename from pints/functionaltests/no_u_turn_mcmc.py
rename to pints/cptests/no_u_turn_mcmc.py
index 7ca868e942..12a87feb4b 100644
--- a/pints/functionaltests/no_u_turn_mcmc.py
+++ b/pints/cptests/no_u_turn_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for NoUTurnMCMC
+# Change point tests for NoUTurnMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -34,7 +34,7 @@ def banana(n_iterations=2000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
@@ -51,7 +51,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -62,7 +62,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
 
 
 _method = pints.NoUTurnMCMC
-_functional_tests = [
+_change_point_tests = [
     banana,
     high_dim_gaussian,
     two_dim_gaussian,
diff --git a/pints/functionaltests/population_mcmc.py b/pints/cptests/population_mcmc.py
similarity index 88%
rename from pints/functionaltests/population_mcmc.py
rename to pints/cptests/population_mcmc.py
index f525d40fb5..98c5fde185 100644
--- a/pints/functionaltests/population_mcmc.py
+++ b/pints/cptests/population_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for Population MCMC.
+# Change point tests for Population MCMC.
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=20000, n_warmup=500):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=20000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 1, n_iterations, n_warmup)
@@ -35,7 +35,7 @@ def banana(n_iterations=20000, n_warmup=5000):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 1, n_iterations, n_warmup)
@@ -54,7 +54,7 @@ def multimodal_gaussian(
     "kld" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
     method_hyper_parameters = None
     if n_temperatures is not None:
@@ -75,7 +75,7 @@ def multimodal_gaussian(
 
 
 _method = pints.PopulationMCMC
-_functional_tests = [
+_change_point_tests = [
     banana,
     multimodal_gaussian,
     two_dim_gaussian,
diff --git a/pints/functionaltests/relativistic_mcmc.py b/pints/cptests/relativistic_mcmc.py
similarity index 89%
rename from pints/functionaltests/relativistic_mcmc.py
rename to pints/cptests/relativistic_mcmc.py
index bbace567d6..8044241c49 100644
--- a/pints/functionaltests/relativistic_mcmc.py
+++ b/pints/cptests/relativistic_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for RelativisticMCMC
+# Change point tests for RelativisticMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
@@ -39,7 +39,7 @@ def banana(n_iterations=5000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         method=_method,
@@ -61,7 +61,7 @@ def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
@@ -84,7 +84,7 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         method=_method,
@@ -106,7 +106,7 @@ def annulus(n_iterations=5000, n_warmup=500):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         method=_method,
@@ -129,7 +129,7 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     "kld" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
@@ -151,7 +151,7 @@ def cone(n_iterations=2000, n_warmup=500):
     a dict with entries "distance" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
         method=_method,
@@ -167,7 +167,7 @@ def cone(n_iterations=2000, n_warmup=500):
 
 
 _method = pints.RelativisticMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     cone,
diff --git a/pints/functionaltests/slice_stepout_mcmc.py b/pints/cptests/slice_stepout_mcmc.py
similarity index 87%
rename from pints/functionaltests/slice_stepout_mcmc.py
rename to pints/cptests/slice_stepout_mcmc.py
index 40c78b91c3..e893161c2d 100644
--- a/pints/functionaltests/slice_stepout_mcmc.py
+++ b/pints/cptests/slice_stepout_mcmc.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 #
-# Functional tests for SliceStepoutMCMC
+# Change point tests for SliceStepoutMCMC
 #
 # 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 pints
-import pints.functionaltests as ft
+import pints.cptests as ft
 
 
 def two_dim_gaussian(n_iterations=5000, n_warmup=500):
@@ -17,7 +17,7 @@ def two_dim_gaussian(n_iterations=5000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnTwoDimGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
     problem = ft.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -35,7 +35,7 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCorrelatedGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
     problem = ft.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -52,7 +52,7 @@ def banana(n_iterations=5000, n_warmup=500):
     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnBanana`.
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
     problem = ft.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
@@ -69,7 +69,7 @@ def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     returns a dictionary with entries ``kld`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnHighDimensionalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
     problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -86,7 +86,7 @@ def annulus(n_iterations=10000, n_warmup=2000):
     dictionary with entries ``distance`` and ``mean-ess``.
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnAnnulus`.
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = ft.RunMcmcMethodOnAnnulus(
         _method, 4, n_iterations, n_warmup)
@@ -104,7 +104,7 @@ def multimodal_gaussian(n_iterations=5000, n_warmup=500):
     "kld" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnMultimodalGaussian`.
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
     problem = ft.RunMcmcMethodOnMultimodalGaussian(
         _method, 4, n_iterations, n_warmup)
@@ -121,7 +121,7 @@ def cone(n_iterations=5000, n_warmup=500):
     a dict with entries "distance" and "mean-ess".
 
     For details of the solved problem, see
-    :class:`pints.functionaltests.RunMcmcMethodOnCone`.
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
     problem = ft.RunMcmcMethodOnCone(
         _method, 4, n_iterations, n_warmup)
@@ -132,7 +132,7 @@ def cone(n_iterations=5000, n_warmup=500):
 
 
 _method = pints.SliceStepoutMCMC
-_functional_tests = [
+_change_point_tests = [
     annulus,
     banana,
     cone,

From 0fcd400f08f317d4af8c9eea70cd7a0184dfd466 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 24 Aug 2021 12:35:31 +0100
Subject: [PATCH 61/73] Changed 'ft' to 'cpt'.

---
 pints/cptests/_discovery.py                      |  4 ++--
 pints/cptests/differential_evolution_mcmc.py     | 10 +++++-----
 pints/cptests/dram_acmc.py                       |  8 ++++----
 pints/cptests/dream_mcmc.py                      | 10 +++++-----
 pints/cptests/emcee_hammer_mcmc.py               | 14 +++++++-------
 pints/cptests/haario_acmc.py                     |  8 ++++----
 pints/cptests/haario_bardenet_acmc.py            | 10 +++++-----
 pints/cptests/hamiltonian_mcmc.py                |  8 ++++----
 pints/cptests/mala_mcmc.py                       | 16 ++++++++--------
 pints/cptests/metropolis_random_walk_mcmc.py     |  8 ++++----
 pints/cptests/monomial_gamma_hamiltonian_mcmc.py | 16 ++++++++--------
 pints/cptests/no_u_turn_mcmc.py                  |  8 ++++----
 pints/cptests/population_mcmc.py                 |  8 ++++----
 pints/cptests/relativistic_mcmc.py               | 16 ++++++++--------
 pints/cptests/slice_stepout_mcmc.py              | 16 ++++++++--------
 15 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/pints/cptests/_discovery.py b/pints/cptests/_discovery.py
index 71d6585d52..92be3d29e5 100644
--- a/pints/cptests/_discovery.py
+++ b/pints/cptests/_discovery.py
@@ -7,7 +7,7 @@
 #
 import inspect
 
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def tests(method=None):
@@ -20,7 +20,7 @@ def tests(method=None):
     are returned.
     """
     # Get all modules imported into this module
-    modules = [getattr(ft, x) for x in dir(ft) if not x.startswith('_')]
+    modules = [getattr(cpt, x) for x in dir(cpt) if not x.startswith('_')]
     modules = [x for x in modules if inspect.ismodule(x)]
 
     # Look for (explicitly defined) tests
diff --git a/pints/cptests/differential_evolution_mcmc.py b/pints/cptests/differential_evolution_mcmc.py
index 133ecf28e9..8ce44b374b 100644
--- a/pints/cptests/differential_evolution_mcmc.py
+++ b/pints/cptests/differential_evolution_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=5000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -71,7 +71,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
diff --git a/pints/cptests/dram_acmc.py b/pints/cptests/dram_acmc.py
index cb8ab9df1f..137c78ddc3 100644
--- a/pints/cptests/dram_acmc.py
+++ b/pints/cptests/dram_acmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=8000, n_warmup=2000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=8000, n_warmup=2000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
diff --git a/pints/cptests/dream_mcmc.py b/pints/cptests/dream_mcmc.py
index 2d6293e757..0d480a9ef8 100644
--- a/pints/cptests/dream_mcmc.py
+++ b/pints/cptests/dream_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 10, n_iterations, n_warmup)
 
     return {
@@ -37,7 +37,7 @@ def banana(n_iterations=5000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -55,7 +55,7 @@ def correlated_gaussian(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 20, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -72,7 +72,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
diff --git a/pints/cptests/emcee_hammer_mcmc.py b/pints/cptests/emcee_hammer_mcmc.py
index 94ff62f5fd..bd562432ea 100644
--- a/pints/cptests/emcee_hammer_mcmc.py
+++ b/pints/cptests/emcee_hammer_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=10000, n_warmup=2000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -71,7 +71,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
@@ -89,7 +89,7 @@ def multimodal_gaussian(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnMultimodalGaussian(
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
         _method, 10, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -106,7 +106,7 @@ def cone(n_iterations=10000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
-    problem = ft.RunMcmcMethodOnCone(
+    problem = cpt.RunMcmcMethodOnCone(
         _method, 10, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
diff --git a/pints/cptests/haario_acmc.py b/pints/cptests/haario_acmc.py
index 5023ca1025..f0b3feb887 100644
--- a/pints/cptests/haario_acmc.py
+++ b/pints/cptests/haario_acmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
diff --git a/pints/cptests/haario_bardenet_acmc.py b/pints/cptests/haario_bardenet_acmc.py
index ebf409c6b1..e9b6a92569 100644
--- a/pints/cptests/haario_bardenet_acmc.py
+++ b/pints/cptests/haario_bardenet_acmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -71,7 +71,7 @@ def annulus(n_iterations=4000, n_warmup=2000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         _method, 4, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
diff --git a/pints/cptests/hamiltonian_mcmc.py b/pints/cptests/hamiltonian_mcmc.py
index 1bfcad3f93..dc3a87fff8 100644
--- a/pints/cptests/hamiltonian_mcmc.py
+++ b/pints/cptests/hamiltonian_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -41,7 +41,7 @@ def banana(n_iterations=2000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -63,7 +63,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/cptests/mala_mcmc.py b/pints/cptests/mala_mcmc.py
index 23b58fd1ec..2c8910727c 100644
--- a/pints/cptests/mala_mcmc.py
+++ b/pints/cptests/mala_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -41,7 +41,7 @@ def banana(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -63,7 +63,7 @@ def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -87,7 +87,7 @@ def correlated_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -109,7 +109,7 @@ def annulus(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -132,7 +132,7 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnMultimodalGaussian(
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -154,7 +154,7 @@ def cone(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
-    problem = ft.RunMcmcMethodOnCone(
+    problem = cpt.RunMcmcMethodOnCone(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/cptests/metropolis_random_walk_mcmc.py b/pints/cptests/metropolis_random_walk_mcmc.py
index 23c264bb9f..5bd17321b1 100644
--- a/pints/cptests/metropolis_random_walk_mcmc.py
+++ b/pints/cptests/metropolis_random_walk_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def correlated_gaussian(n_iterations=8000, n_warmup=4000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
diff --git a/pints/cptests/monomial_gamma_hamiltonian_mcmc.py b/pints/cptests/monomial_gamma_hamiltonian_mcmc.py
index 5baec85072..d55d929fbd 100644
--- a/pints/cptests/monomial_gamma_hamiltonian_mcmc.py
+++ b/pints/cptests/monomial_gamma_hamiltonian_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -41,7 +41,7 @@ def banana(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -63,7 +63,7 @@ def high_dim_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -86,7 +86,7 @@ def correlated_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -108,7 +108,7 @@ def annulus(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -131,7 +131,7 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnMultimodalGaussian(
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -153,7 +153,7 @@ def cone(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
-    problem = ft.RunMcmcMethodOnCone(
+    problem = cpt.RunMcmcMethodOnCone(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/cptests/no_u_turn_mcmc.py b/pints/cptests/no_u_turn_mcmc.py
index 12a87feb4b..6e778f5524 100644
--- a/pints/cptests/no_u_turn_mcmc.py
+++ b/pints/cptests/no_u_turn_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -36,7 +36,7 @@ def banana(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -53,7 +53,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
diff --git a/pints/cptests/population_mcmc.py b/pints/cptests/population_mcmc.py
index 98c5fde185..bf445b9281 100644
--- a/pints/cptests/population_mcmc.py
+++ b/pints/cptests/population_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=20000, n_warmup=500):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=20000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 1, n_iterations, n_warmup)
 
     return {
@@ -37,7 +37,7 @@ def banana(n_iterations=20000, n_warmup=5000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 1, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -60,7 +60,7 @@ def multimodal_gaussian(
     if n_temperatures is not None:
         method_hyper_parameters = [n_temperatures]
 
-    problem = ft.RunMcmcMethodOnMultimodalGaussian(
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
         n_chains=1,
         n_iterations=n_iterations,
diff --git a/pints/cptests/relativistic_mcmc.py b/pints/cptests/relativistic_mcmc.py
index 8044241c49..2cefeb65f0 100644
--- a/pints/cptests/relativistic_mcmc.py
+++ b/pints/cptests/relativistic_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=1000, n_warmup=200):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -41,7 +41,7 @@ def banana(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -63,7 +63,7 @@ def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -86,7 +86,7 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -108,7 +108,7 @@ def annulus(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -131,7 +131,7 @@ def multimodal_gaussian(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnMultimodalGaussian(
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
@@ -153,7 +153,7 @@ def cone(n_iterations=2000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
-    problem = ft.RunMcmcMethodOnCone(
+    problem = cpt.RunMcmcMethodOnCone(
         method=_method,
         n_chains=4,
         n_iterations=n_iterations,
diff --git a/pints/cptests/slice_stepout_mcmc.py b/pints/cptests/slice_stepout_mcmc.py
index e893161c2d..2ced13d82a 100644
--- a/pints/cptests/slice_stepout_mcmc.py
+++ b/pints/cptests/slice_stepout_mcmc.py
@@ -7,7 +7,7 @@
 # copyright notice and full license details.
 #
 import pints
-import pints.cptests as ft
+import pints.cptests as cpt
 
 
 def two_dim_gaussian(n_iterations=5000, n_warmup=500):
@@ -19,7 +19,7 @@ def two_dim_gaussian(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
     """
-    problem = ft.RunMcmcMethodOnTwoDimGaussian(
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -37,7 +37,7 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
     """
-    problem = ft.RunMcmcMethodOnCorrelatedGaussian(
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +54,7 @@ def banana(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnBanana`.
     """
-    problem = ft.RunMcmcMethodOnBanana(
+    problem = cpt.RunMcmcMethodOnBanana(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -71,7 +71,7 @@ def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnHighDimensionalGaussian(
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -88,7 +88,7 @@ def annulus(n_iterations=10000, n_warmup=2000):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
-    problem = ft.RunMcmcMethodOnAnnulus(
+    problem = cpt.RunMcmcMethodOnAnnulus(
         _method, 4, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),
@@ -106,7 +106,7 @@ def multimodal_gaussian(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
     """
-    problem = ft.RunMcmcMethodOnMultimodalGaussian(
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
         _method, 4, n_iterations, n_warmup)
     return {
         'kld': problem.estimate_kld(),
@@ -123,7 +123,7 @@ def cone(n_iterations=5000, n_warmup=500):
     For details of the solved problem, see
     :class:`pints.cptests.RunMcmcMethodOnCone`.
     """
-    problem = ft.RunMcmcMethodOnCone(
+    problem = cpt.RunMcmcMethodOnCone(
         _method, 4, n_iterations, n_warmup)
     return {
         'distance': problem.estimate_distance(),

From 9aa15921399fecdb505302a9dfda7f3b58becf71 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 24 Aug 2021 12:38:14 +0100
Subject: [PATCH 62/73] Added flag to ignore unused import in cptests.__init__

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

diff --git a/pints/cptests/__init__.py b/pints/cptests/__init__.py
index 278054ddff..ec40159933 100644
--- a/pints/cptests/__init__.py
+++ b/pints/cptests/__init__.py
@@ -40,4 +40,4 @@
 
 
 # Test discovery methods
-from ._discovery import tests
+from ._discovery import tests   # noqa

From 665f21c60018697ff8e2cd282098b4ff4af4aa6f Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 24 Aug 2021 14:38:48 +0100
Subject: [PATCH 63/73] Fixed merge issue in workflows.

---
 .github/workflows/copyright-test.yml            | 1 -
 .github/workflows/coverage-test.yml             | 1 -
 .github/workflows/docs-test.yml                 | 1 -
 .github/workflows/style-test.yml                | 1 -
 .github/workflows/unit-test-os-coverage.yml     | 1 -
 .github/workflows/unit-test-python-coverage.yml | 1 -
 6 files changed, 6 deletions(-)

diff --git a/.github/workflows/copyright-test.yml b/.github/workflows/copyright-test.yml
index 67b72e1075..89fa187994 100644
--- a/.github/workflows/copyright-test.yml
+++ b/.github/workflows/copyright-test.yml
@@ -13,7 +13,6 @@ on:
 jobs:
 
   build-and-test:
-    if: github.event.pull_request.draft == false
     name: Copyright
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/coverage-test.yml b/.github/workflows/coverage-test.yml
index f6cd4648e6..88ccae85e3 100644
--- a/.github/workflows/coverage-test.yml
+++ b/.github/workflows/coverage-test.yml
@@ -13,7 +13,6 @@ on:
 jobs:
 
   build-and-test:
-    if: github.event.pull_request.draft == false
     name: Coverage
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/docs-test.yml b/.github/workflows/docs-test.yml
index 7a147ff19c..16b32d3217 100644
--- a/.github/workflows/docs-test.yml
+++ b/.github/workflows/docs-test.yml
@@ -13,7 +13,6 @@ on:
 jobs:
 
   build-and-test:
-    if: github.event.pull_request.draft == false
     name: Docs
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/style-test.yml b/.github/workflows/style-test.yml
index 2e08f6f6d1..716b46c70d 100644
--- a/.github/workflows/style-test.yml
+++ b/.github/workflows/style-test.yml
@@ -13,7 +13,6 @@ on:
 jobs:
 
   build-and-test:
-    if: github.event.pull_request.draft == false
     name: Style
     runs-on: ubuntu-latest
 
diff --git a/.github/workflows/unit-test-os-coverage.yml b/.github/workflows/unit-test-os-coverage.yml
index 2b89a2334a..728cf39190 100644
--- a/.github/workflows/unit-test-os-coverage.yml
+++ b/.github/workflows/unit-test-os-coverage.yml
@@ -13,7 +13,6 @@ on:
 jobs:
 
   build-and-test:
-    if: github.event.pull_request.draft == false
     name: OS unit tests
     runs-on: ${{ matrix.os }}
 
diff --git a/.github/workflows/unit-test-python-coverage.yml b/.github/workflows/unit-test-python-coverage.yml
index bfe88294db..9037548387 100644
--- a/.github/workflows/unit-test-python-coverage.yml
+++ b/.github/workflows/unit-test-python-coverage.yml
@@ -13,7 +13,6 @@ on:
 jobs:
 
   build-and-test:
-    if: github.event.pull_request.draft == false
     name: Python unit tests
     runs-on: ubuntu-latest
 

From b54bf9a6fce885f7a018b8482422a3c78c121833 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 24 Aug 2021 14:46:19 +0100
Subject: [PATCH 64/73] Updated workflow

---
 .../{functional-tests.yml => change-point-tests.yml}      | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 rename .github/workflows/{functional-tests.yml => change-point-tests.yml} (88%)

diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/change-point-tests.yml
similarity index 88%
rename from .github/workflows/functional-tests.yml
rename to .github/workflows/change-point-tests.yml
index 0ebb90fca1..cc5c99f9be 100644
--- a/.github/workflows/functional-tests.yml
+++ b/.github/workflows/change-point-tests.yml
@@ -1,4 +1,4 @@
-name: Functional testing
+name: Change-point testing
 
 on:
   push:
@@ -8,7 +8,7 @@ on:
 jobs:
 
   run-functional-testing:
-    name: Functional testing
+    name: Change-point testing
     runs-on: ubuntu-latest
 
     steps:
@@ -43,7 +43,7 @@ jobs:
           python -m pip install .
         working-directory: 'functional-testing-2'
 
-      - name: run functional testing
+      - name: run change-point testing
         run: |
           python run_all_the_things.py
         working-directory: 'functional-testing-2'
@@ -53,6 +53,6 @@ jobs:
           git config user.name "github-workflow"
           git config user.email "github-workflow"
           git add --all
-          git commit -m "Run of functional testing" || echo "No changes to commit"
+          git commit -m "Run of change-point testing" || echo "No changes to commit"
           git push
         working-directory: 'functional-testing-2'

From 12e7e67c4258f885b361a28da64e8bbb1b8f900b Mon Sep 17 00:00:00 2001
From: YongchaoHuang <34540771+YongchaoHuang@users.noreply.github.com>
Date: Tue, 5 Dec 2023 14:00:28 +0000
Subject: [PATCH 65/73] Disabled `banana` & added `annulus` in
 `hamiltonian_mcmc`.

---
 pints/cptests/differential_evolution_mcmc.py |  1 +
 pints/cptests/hamiltonian_mcmc.py            | 59 +++++++++++++-------
 2 files changed, 41 insertions(+), 19 deletions(-)

diff --git a/pints/cptests/differential_evolution_mcmc.py b/pints/cptests/differential_evolution_mcmc.py
index 8ce44b374b..90cb43047d 100644
--- a/pints/cptests/differential_evolution_mcmc.py
+++ b/pints/cptests/differential_evolution_mcmc.py
@@ -79,6 +79,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
     }
 
 
+
 _method = pints.DifferentialEvolutionMCMC
 _change_point_tests = [
     annulus,
diff --git a/pints/cptests/hamiltonian_mcmc.py b/pints/cptests/hamiltonian_mcmc.py
index dc3a87fff8..b1aeae96a6 100644
--- a/pints/cptests/hamiltonian_mcmc.py
+++ b/pints/cptests/hamiltonian_mcmc.py
@@ -32,26 +32,26 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     }
 
 
-def banana(n_iterations=2000, n_warmup=1000):
-    """
-    Tests :class:`pints.HamiltonianMCMC`
-    on a two-dimensional "twisted Gaussian" distribution with true solution
-    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+# def banana(n_iterations=2000, n_warmup=1000):
+#     """
+#     Tests :class:`pints.HamiltonianMCMC`
+#     on a two-dimensional "twisted Gaussian" distribution with true solution
+#     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
 
-    For details of the solved problem, see
-    :class:`pints.cptests.RunMcmcMethodOnBanana`.
-    """
-    problem = cpt.RunMcmcMethodOnBanana(
-        method=_method,
-        n_chains=4,
-        n_iterations=n_iterations,
-        n_warmup=n_warmup,
-        method_hyper_parameters=[20, 2]
-    )
-    return {
-        'kld': problem.estimate_kld(),
-        'mean-ess': problem.estimate_mean_ess()
-    }
+#     For details of the solved problem, see
+#     :class:`pints.cptests.RunMcmcMethodOnBanana`.
+#     """
+#     problem = cpt.RunMcmcMethodOnBanana(
+#         method=_method,
+#         n_chains=4,
+#         n_iterations=n_iterations,
+#         n_warmup=n_warmup,
+#         method_hyper_parameters=[20, 2]
+#     )
+#     return {
+#         'kld': problem.estimate_kld(),
+#         'mean-ess': problem.estimate_mean_ess()
+#     }
 
 
 def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
@@ -75,10 +75,31 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
         'mean-ess': problem.estimate_mean_ess()
     }
 
+# TODO (Yong): add more test cases 
+def annulus(n_iterations=10000, n_warmup=1000):
+    """
+    Tests :class:`pints.HamiltonianMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
+    """
+    problem = cpt.RunMcmcMethodOnAnnulus(
+        method=_method, 
+        n_chains=10, 
+        n_iterations=n_iterations, 
+        n_warmup=n_warmup)
+    return {
+        'kld': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
 
 _method = pints.HamiltonianMCMC
 _change_point_tests = [
     banana,
     high_dim_gaussian,
     two_dim_gaussian,
+    annulus,
 ]

From 8275e17bafa8ecfa011eae207f13059db5c4dfbd Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 12 Dec 2023 12:31:22 +0000
Subject: [PATCH 66/73] Style fix and hmc cptest fix

---
 pints/cptests/differential_evolution_mcmc.py |  1 -
 pints/cptests/hamiltonian_mcmc.py            | 33 +++-----------------
 2 files changed, 5 insertions(+), 29 deletions(-)

diff --git a/pints/cptests/differential_evolution_mcmc.py b/pints/cptests/differential_evolution_mcmc.py
index 90cb43047d..8ce44b374b 100644
--- a/pints/cptests/differential_evolution_mcmc.py
+++ b/pints/cptests/differential_evolution_mcmc.py
@@ -79,7 +79,6 @@ def annulus(n_iterations=10000, n_warmup=1000):
     }
 
 
-
 _method = pints.DifferentialEvolutionMCMC
 _change_point_tests = [
     annulus,
diff --git a/pints/cptests/hamiltonian_mcmc.py b/pints/cptests/hamiltonian_mcmc.py
index b1aeae96a6..767262cee0 100644
--- a/pints/cptests/hamiltonian_mcmc.py
+++ b/pints/cptests/hamiltonian_mcmc.py
@@ -32,28 +32,6 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
     }
 
 
-# def banana(n_iterations=2000, n_warmup=1000):
-#     """
-#     Tests :class:`pints.HamiltonianMCMC`
-#     on a two-dimensional "twisted Gaussian" distribution with true solution
-#     ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
-
-#     For details of the solved problem, see
-#     :class:`pints.cptests.RunMcmcMethodOnBanana`.
-#     """
-#     problem = cpt.RunMcmcMethodOnBanana(
-#         method=_method,
-#         n_chains=4,
-#         n_iterations=n_iterations,
-#         n_warmup=n_warmup,
-#         method_hyper_parameters=[20, 2]
-#     )
-#     return {
-#         'kld': problem.estimate_kld(),
-#         'mean-ess': problem.estimate_mean_ess()
-#     }
-
-
 def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     """
      Tests :class:`pints.HamiltonianMCMC`
@@ -75,7 +53,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
         'mean-ess': problem.estimate_mean_ess()
     }
 
-# TODO (Yong): add more test cases 
+
 def annulus(n_iterations=10000, n_warmup=1000):
     """
     Tests :class:`pints.HamiltonianMCMC`
@@ -86,9 +64,9 @@ def annulus(n_iterations=10000, n_warmup=1000):
     :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
     """
     problem = cpt.RunMcmcMethodOnAnnulus(
-        method=_method, 
-        n_chains=10, 
-        n_iterations=n_iterations, 
+        method=_method,
+        n_chains=10,
+        n_iterations=n_iterations,
         n_warmup=n_warmup)
     return {
         'kld': problem.estimate_distance(),
@@ -98,8 +76,7 @@ def annulus(n_iterations=10000, n_warmup=1000):
 
 _method = pints.HamiltonianMCMC
 _change_point_tests = [
-    banana,
-    high_dim_gaussian,
     two_dim_gaussian,
+    high_dim_gaussian,
     annulus,
 ]

From ad9e422455375b87454ec7938cbe7ed7055640a1 Mon Sep 17 00:00:00 2001
From: FarmHJ <hui.farm@cs.ox.ac.uk>
Date: Tue, 12 Dec 2023 14:03:14 +0000
Subject: [PATCH 67/73] Remove banana and multimodal gaussian problem for slice
 stepout mcmc

---
 pints/cptests/slice_stepout_mcmc.py | 37 -----------------------------
 1 file changed, 37 deletions(-)

diff --git a/pints/cptests/slice_stepout_mcmc.py b/pints/cptests/slice_stepout_mcmc.py
index 2ced13d82a..b6355ce3e6 100644
--- a/pints/cptests/slice_stepout_mcmc.py
+++ b/pints/cptests/slice_stepout_mcmc.py
@@ -45,23 +45,6 @@ def correlated_gaussian(n_iterations=5000, n_warmup=500):
     }
 
 
-def banana(n_iterations=5000, n_warmup=500):
-    """
-    Tests :class:`pints.SliceStepoutMCMC`
-    on a two-dimensional "twisted Gaussian" distribution with true solution
-    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
-
-    For details of the solved problem, see
-    :class:`pints.cptests.RunMcmcMethodOnBanana`.
-    """
-    problem = cpt.RunMcmcMethodOnBanana(
-        _method, 4, n_iterations, n_warmup)
-    return {
-        'kld': problem.estimate_kld(),
-        'mean-ess': problem.estimate_mean_ess()
-    }
-
-
 def high_dim_gaussian(n_iterations=5000, n_warmup=500):
     """
      Tests :class:`pints.SliceStepoutMCMC`
@@ -96,24 +79,6 @@ def annulus(n_iterations=10000, n_warmup=2000):
     }
 
 
-def multimodal_gaussian(n_iterations=5000, n_warmup=500):
-    """
-    Tests :class:`pints.SliceStepoutMCMC`
-    on a two-dimensional multi-modal Gaussian distribution with modes at
-    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
-    "kld" and "mean-ess".
-
-    For details of the solved problem, see
-    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
-    """
-    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
-        _method, 4, n_iterations, n_warmup)
-    return {
-        'kld': problem.estimate_kld(),
-        'mean-ess': problem.estimate_mean_ess()
-    }
-
-
 def cone(n_iterations=5000, n_warmup=500):
     """
     Tests :class:`pints.SliceStepoutMCMC`
@@ -134,10 +99,8 @@ def cone(n_iterations=5000, n_warmup=500):
 _method = pints.SliceStepoutMCMC
 _change_point_tests = [
     annulus,
-    banana,
     cone,
     correlated_gaussian,
     high_dim_gaussian,
-    multimodal_gaussian,
     two_dim_gaussian,
 ]

From 66e58f3d5f11a7b01a578051adfa68b78db7b680 Mon Sep 17 00:00:00 2001
From: FarmHJ <hui.farm@cs.ox.ac.uk>
Date: Tue, 12 Dec 2023 14:03:49 +0000
Subject: [PATCH 68/73] Add problems for functional test of slice doubling

---
 pints/cptests/__init__.py            |   1 +
 pints/cptests/slice_doubling_mcmc.py | 106 +++++++++++++++++++++++++++
 2 files changed, 107 insertions(+)
 create mode 100644 pints/cptests/slice_doubling_mcmc.py

diff --git a/pints/cptests/__init__.py b/pints/cptests/__init__.py
index ec40159933..17a247dce8 100644
--- a/pints/cptests/__init__.py
+++ b/pints/cptests/__init__.py
@@ -36,6 +36,7 @@
     population_mcmc,
     relativistic_mcmc,
     slice_stepout_mcmc,
+    slice_doubling_mcmc,
 )
 
 
diff --git a/pints/cptests/slice_doubling_mcmc.py b/pints/cptests/slice_doubling_mcmc.py
new file mode 100644
index 0000000000..21db5c2e37
--- /dev/null
+++ b/pints/cptests/slice_doubling_mcmc.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+#
+# Change point tests for SliceDoublingMCMC
+#
+# 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 pints
+import pints.cptests as cpt
+
+
+def two_dim_gaussian(n_iterations=5000, n_warmup=500):
+    """
+    Tests :class:`pints.SliceDoublingMCMC`
+    on a two-dimensional Gaussian distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnTwoDimGaussian`.
+    """
+    problem = cpt.RunMcmcMethodOnTwoDimGaussian(
+        _method, 4, n_iterations, n_warmup)
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def correlated_gaussian(n_iterations=5000, n_warmup=500):
+    """
+    Tests :class:`pints.SliceDoublingMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
+        _method, 4, n_iterations, n_warmup)
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def high_dim_gaussian(n_iterations=5000, n_warmup=500):
+    """
+     Tests :class:`pints.SliceDoublingMCMC`
+    on a 20-dimensional Gaussian distribution centered at the origin, and
+    returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnHighDimensionalGaussian`.
+    """
+    problem = cpt.RunMcmcMethodOnHighDimensionalGaussian(
+        _method, 4, n_iterations, n_warmup)
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def annulus(n_iterations=10000, n_warmup=2000):
+    """
+    Tests :class:`pints.SliceDoublingMCMC`
+    on a two-dimensional annulus distribution with radius 10, and returns a
+    dictionary with entries ``distance`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnAnnulus`.
+    """
+    problem = cpt.RunMcmcMethodOnAnnulus(
+        _method, 4, n_iterations, n_warmup)
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def cone(n_iterations=5000, n_warmup=500):
+    """
+    Tests :class:`pints.SliceDoublingMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
+    """
+    problem = cpt.RunMcmcMethodOnCone(
+        _method, 4, n_iterations, n_warmup)
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+_method = pints.SliceStepoutMCMC
+_change_point_tests = [
+    annulus,
+    cone,
+    correlated_gaussian,
+    high_dim_gaussian,
+    two_dim_gaussian,
+]

From 3b2864d00f2150ccdc6b21b6948d9419704b1344 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Thu, 14 Dec 2023 10:20:39 +0000
Subject: [PATCH 69/73] Added optimiser problems and tests on CMAES

---
 pints/cptests/__init__.py  |   6 ++
 pints/cptests/_problems.py | 184 +++++++++++++++++++++++++++++++++++--
 pints/cptests/cmaes.py     |  81 ++++++++++++++++
 3 files changed, 265 insertions(+), 6 deletions(-)
 create mode 100644 pints/cptests/cmaes.py

diff --git a/pints/cptests/__init__.py b/pints/cptests/__init__.py
index 17a247dce8..552682013d 100644
--- a/pints/cptests/__init__.py
+++ b/pints/cptests/__init__.py
@@ -15,7 +15,13 @@
     RunMcmcMethodOnCorrelatedGaussian,
     RunMcmcMethodOnHighDimensionalGaussian,
     RunMcmcMethodOnMultimodalGaussian,
+    RunMcmcMethodOnProblem,
     RunMcmcMethodOnTwoDimGaussian,
+    RunOptimiserOnBoundedFitzhughNagumo,
+    RunOptimiserOnBoundedUntransformedLogistic,
+    RunOptimiserOnProblem,
+    RunOptimiserOnRosenbrockError,
+    RunOptimiserOnTwoDimParabola,
 )
 
 # Import all test modules (not methods!) directly into this method, so that
diff --git a/pints/cptests/_problems.py b/pints/cptests/_problems.py
index 8298732852..47149e76b3 100644
--- a/pints/cptests/_problems.py
+++ b/pints/cptests/_problems.py
@@ -243,6 +243,184 @@ def __init__(self, method, n_chains, n_iterations, n_warmup,
                          n_warmup, method_hyper_parameters)
 
 
+class RunOptimiserOnProblem(object):
+    """
+    Base class for tests that run an optimiser on an error function or log-PDF.
+
+    Parameters
+    ----------
+    error : pints.Error or pints.LogPDF
+        The function to opimise. Will be passed to a
+        :class:`pints.OptimisationController`.
+    x0
+        A starting point to be passed to the controller.
+    sigma0
+        An optional ``sigma0`` argument to pass to the controller.
+    method : pints.Optimiser
+        The method to test.
+    n_iterations : int
+        The number of iterations to run.
+    use_guessed : bool
+        Set to true to use ``f_guessed_tracking`` (see
+        :meth:`Optimiser.set_f_guessed_tracking`).
+    method_hyper_parameters : list
+        A list of hyperparameter values.
+
+    """
+
+    def __init__(self, error, x0, sigma0, boundaries, transformation, method,
+                 xtrue, n_iterations, use_guessed=False,
+                 method_hyper_parameters=None):
+        self._error = error
+        self._xtrue = pints.vector(xtrue)
+
+        controller = pints.OptimisationController(
+            error, x0, sigma0, boundaries, transformation, method)
+        controller.set_max_iterations(n_iterations)
+        controller.set_max_unchanged_iterations(None)
+        controller.set_log_to_screen(False)
+        if method_hyper_parameters is not None:
+            controller.optimiser().set_hyperparameters(method_hyper_parameters)
+        self._x, self._f = controller.run()
+
+    def distance(self):
+        """
+        Calculates the distance between the obtained solution and the true
+        solution.
+        """
+        return np.sqrt(np.sum((self._x - self._xtrue)**2))
+
+    def error(self):
+        """
+        Returns the final error.
+        """
+        return self._f
+
+
+class RunOptimiserOnBoundedFitzhughNagumo(RunOptimiserOnProblem):
+    """
+    Tests a given Optimiser on a fully observable (multi-output)
+    Fitzhugh-Nagumo model, using boundaries but no transformations (the scales
+    of the parameters are relatively similar).
+    """
+    def __init__(self, method, n_iterations, use_guessed=False,
+                 method_hyper_parameters=None):
+
+        # Choose starting point. The loss surface does not suggest any sensible
+        # way to do this, so just sampling in a small sphere around a chosen x.
+        x0 = [1, 1.5, 3]                    # Center
+        r = np.random.uniform(0, 0.2)       # Sphere radius
+        t = np.random.uniform(0, 2 * np.pi)
+        p = np.random.uniform(0, 2 * np.pi)
+        x0[0] += r * np.sin(t) * np.cos(p)
+        x0[1] += r * np.sin(t) * np.sin(p)
+        x0[2] += r * np.cos(t)
+        # Note that this is not a uniform sampling from the sphere!
+        sigma0 = 0.05
+
+        # Create a seeded generator to get consistent noise
+        r = np.random.default_rng(1)
+
+        # Create problem
+        model = pints.toy.FitzhughNagumoModel()
+        xtrue = model.suggested_parameters()
+        times = model.suggested_times()
+        values = model.simulate(xtrue, times)
+        values += r.normal(0, 0.25, values.shape)
+        problem = pints.MultiOutputProblem(model, times, values)
+        error = pints.SumOfSquaresError(problem)
+
+        # Add boundaries
+        boundaries = pints.RectangularBoundaries(
+            [1e-3, 1e-3, 1e-3], [2, 2, 10])
+
+        super().__init__(error, x0, sigma0, boundaries, None, method, xtrue,
+                         n_iterations, use_guessed, method_hyper_parameters)
+
+
+class RunOptimiserOnBoundedUntransformedLogistic(RunOptimiserOnProblem):
+    """
+    Tests a given Optimiser on a logistic model inference problem with
+    boundaries and very different scalings for the parameters (no sigma0
+    information is given).
+    """
+    def __init__(self, method, n_iterations, use_guessed=False,
+                 method_hyper_parameters=None):
+        # Choose starting point
+        # For the default parameters, the contours of the score function with
+        # x[1] = 15 are almost horizontal after x[0] = 0.1, so we can fix Y and
+        # vary X to get starting points with similar errors.
+        x0 = np.array([np.random.uniform(0.15, 9), 15])
+
+        # Create random generator to add consistent noise
+        r = np.random.default_rng(1)
+
+        # Create problem
+        model = pints.toy.LogisticModel()
+        xtrue = model.suggested_parameters()
+        times = model.suggested_times()
+        values = model.simulate(xtrue, times)
+        values += r.normal(0, 5, values.shape)
+        problem = pints.SingleOutputProblem(model, times, values)
+        error = pints.SumOfSquaresError(problem)
+
+        # Add boundaries
+        boundaries = pints.RectangularBoundaries([0, 0.5], [10, 100])
+
+        super().__init__(error, x0, None, boundaries, None, method, xtrue,
+                         n_iterations, use_guessed, method_hyper_parameters)
+
+
+class RunOptimiserOnRosenbrockError(RunOptimiserOnProblem):
+    """
+    Tests a given Optimiser on a Rosenbrock error, starting from a randomly
+    sampled point with error 10.
+
+    For constructor arguments, see :class:`RunOptimiserOnProblem`.
+    """
+
+    def __init__(self, method, n_iterations, use_guessed=False,
+                 method_hyper_parameters=None):
+
+        # Choose starting point
+        c = 10
+        x = np.random.uniform(-1, 3)
+        y = np.sqrt((c - (1 - x)**2) / 100) + x**2
+        x0 = np.array([x, y])
+        sigma0 = 0.1
+
+        # Create error
+        e = pints.toy.RosenbrockError()
+        x = e.optimum()
+        super().__init__(e, x0, sigma0, None, None, method, x, n_iterations,
+                         use_guessed, method_hyper_parameters)
+
+
+class RunOptimiserOnTwoDimParabola(RunOptimiserOnProblem):
+    """
+    Tests a given Optimiser on a two-dimensional parabola with mean ``[0, 0]``,
+    starting at a randomly chosen point 10 distance units away.
+
+    For constructor arguments, see :class:`RunOptimiserOnProblem`.
+    """
+
+    def __init__(self, method, n_iterations, use_guessed=False,
+                 method_hyper_parameters=None):
+        x = np.array([0, 0])
+        e = pints.toy.ParabolicError(x)
+        t = np.random.uniform(0, 2 * np.pi)
+        x0 = 10 * np.array([np.cos(t), np.sin(t)])
+        sigma0 = 1
+        super().__init__(e, x0, sigma0, None, None, method, x, n_iterations,
+                         use_guessed, method_hyper_parameters)
+
+
+def run_and_throw_away_warmup(controller, n_warmup):
+    """ Runs sampling then throws away warmup. """
+    chains = controller.run()
+    return chains[:, n_warmup:]
+
+
 def set_hyperparameters_for_any_mcmc_class(controller, method,
                                            method_hyper_parameters):
     """ Sets hyperparameters for any MCMC class. """
@@ -253,9 +431,3 @@ def set_hyperparameters_for_any_mcmc_class(controller, method,
         else:
             for sampler in controller.samplers():
                 sampler.set_hyper_parameters(method_hyper_parameters)
-
-
-def run_and_throw_away_warmup(controller, n_warmup):
-    """ Runs sampling then throws away warmup. """
-    chains = controller.run()
-    return chains[:, n_warmup:]
diff --git a/pints/cptests/cmaes.py b/pints/cptests/cmaes.py
new file mode 100644
index 0000000000..c7e6fd7018
--- /dev/null
+++ b/pints/cptests/cmaes.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+#
+# Change point tests for CMAES.
+#
+# 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 pints
+import pints.cptests as cpt
+
+
+def bounded_fitzhugh_nagumo(n_iterations=100):
+    """
+    Tests :class:`pints.CMAES` on a bounded Fitzhugh-Nagumo model, and returns
+    a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedFitzhughNagumo(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def bounded_untransformed_logistic(n_iterations=300):
+    """
+    Tests :class:`pints.CMAES` on a bounded logistic model without
+    transformations, and returns a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedUntransformedLogistic(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def rosenbrock(n_iterations=100):
+    """
+    Tests :class:`pints.CMAES` on a Rosenbrock error and returns a dictionary
+    with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnRosenbrockError`.
+    """
+    problem = cpt.RunOptimiserOnRosenbrockError(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def two_dim_parabola(n_iterations=50):
+    """
+    Tests :class:`pints.CMAES` on a two-dimensional parabolic error and returns
+    a dictionary with entries ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnTwoDimParabola`.
+    """
+    problem = cpt.RunOptimiserOnTwoDimParabola(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+_method = pints.CMAES
+_fguess = True
+_change_point_tests = [
+    bounded_untransformed_logistic,
+    rosenbrock,
+    two_dim_parabola,
+]

From 6bb02555f495e4cbca89536b5dc677b9fc129d79 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Thu, 14 Dec 2023 12:18:47 +0000
Subject: [PATCH 70/73] Added cmaes-bare cptests

---
 pints/cptests/__init__.py   |  2 +
 pints/cptests/_problems.py  |  2 +-
 pints/cptests/cmaes.py      |  1 +
 pints/cptests/cmaes_bare.py | 82 +++++++++++++++++++++++++++++++++++++
 4 files changed, 86 insertions(+), 1 deletion(-)
 create mode 100644 pints/cptests/cmaes_bare.py

diff --git a/pints/cptests/__init__.py b/pints/cptests/__init__.py
index 552682013d..660173f71f 100644
--- a/pints/cptests/__init__.py
+++ b/pints/cptests/__init__.py
@@ -28,6 +28,8 @@
 # they can be addressed as e.g.
 # pints.cptests.dram_acmc.two_dim_gaussian().
 from . import (     # noqa
+    cmaes,
+    cmaes_bare,
     differential_evolution_mcmc,
     dram_acmc,
     dream_mcmc,
diff --git a/pints/cptests/_problems.py b/pints/cptests/_problems.py
index 47149e76b3..46fa6028ef 100644
--- a/pints/cptests/_problems.py
+++ b/pints/cptests/_problems.py
@@ -308,7 +308,7 @@ def __init__(self, method, n_iterations, use_guessed=False,
 
         # Choose starting point. The loss surface does not suggest any sensible
         # way to do this, so just sampling in a small sphere around a chosen x.
-        x0 = [1, 1.5, 3]                    # Center
+        x0 = [0.75, 1.5, 3]                 # Center
         r = np.random.uniform(0, 0.2)       # Sphere radius
         t = np.random.uniform(0, 2 * np.pi)
         p = np.random.uniform(0, 2 * np.pi)
diff --git a/pints/cptests/cmaes.py b/pints/cptests/cmaes.py
index c7e6fd7018..f16f6bac5d 100644
--- a/pints/cptests/cmaes.py
+++ b/pints/cptests/cmaes.py
@@ -75,6 +75,7 @@ def two_dim_parabola(n_iterations=50):
 _method = pints.CMAES
 _fguess = True
 _change_point_tests = [
+    bounded_fitzhugh_nagumo,
     bounded_untransformed_logistic,
     rosenbrock,
     two_dim_parabola,
diff --git a/pints/cptests/cmaes_bare.py b/pints/cptests/cmaes_bare.py
new file mode 100644
index 0000000000..aec1c6fa5a
--- /dev/null
+++ b/pints/cptests/cmaes_bare.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+#
+# Change point tests for bare-bones CMAES reimplementation.
+#
+# 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 pints
+import pints.cptests as cpt
+
+
+def bounded_fitzhugh_nagumo(n_iterations=100):
+    """
+    Tests :class:`pints.BareCMAES` on a bounded Fitzhugh-Nagumo model, and
+    returns a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedFitzhughNagumo(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def bounded_untransformed_logistic(n_iterations=300):
+    """
+    Tests :class:`pints.BareCMAES` on a bounded logistic model without
+    transformations, and returns a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedUntransformedLogistic(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def rosenbrock(n_iterations=100):
+    """
+    Tests :class:`pints.BareCMAES` on a Rosenbrock error and returns a
+    dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnRosenbrockError`.
+    """
+    problem = cpt.RunOptimiserOnRosenbrockError(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def two_dim_parabola(n_iterations=50):
+    """
+    Tests :class:`pints.BareCMAES` on a two-dimensional parabolic error and
+    returns a dictionary with entries ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnTwoDimParabola`.
+    """
+    problem = cpt.RunOptimiserOnTwoDimParabola(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+_method = pints.BareCMAES
+_fguess = True
+_change_point_tests = [
+    bounded_fitzhugh_nagumo,
+    bounded_untransformed_logistic,
+    rosenbrock,
+    two_dim_parabola,
+]

From 6970872f38ba226339bcd4fec218c857ea18dcc2 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 2 Jan 2024 20:10:17 +0000
Subject: [PATCH 71/73] Added xNES tests (requires fix from #1517).

---
 pints/cptests/_problems.py |  2 +
 pints/cptests/xnes.py      | 82 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+)
 create mode 100644 pints/cptests/xnes.py

diff --git a/pints/cptests/_problems.py b/pints/cptests/_problems.py
index 46fa6028ef..57ad1619d2 100644
--- a/pints/cptests/_problems.py
+++ b/pints/cptests/_problems.py
@@ -279,6 +279,8 @@ def __init__(self, error, x0, sigma0, boundaries, transformation, method,
         controller.set_max_iterations(n_iterations)
         controller.set_max_unchanged_iterations(None)
         controller.set_log_to_screen(False)
+        if use_guessed:
+            controller.set_f_guessed_tracking(True)
         if method_hyper_parameters is not None:
             controller.optimiser().set_hyperparameters(method_hyper_parameters)
         self._x, self._f = controller.run()
diff --git a/pints/cptests/xnes.py b/pints/cptests/xnes.py
new file mode 100644
index 0000000000..25f1029cfe
--- /dev/null
+++ b/pints/cptests/xnes.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+#
+# Change point tests for XNES.
+#
+# 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 pints
+import pints.cptests as cpt
+
+
+def bounded_fitzhugh_nagumo(n_iterations=100):
+    """
+    Tests :class:`pints.XNES` on a bounded Fitzhugh-Nagumo model, and returns
+    a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedFitzhughNagumo(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def bounded_untransformed_logistic(n_iterations=300):
+    """
+    Tests :class:`pints.XNES` on a bounded logistic model without
+    transformations, and returns a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedUntransformedLogistic(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def rosenbrock(n_iterations=100):
+    """
+    Tests :class:`pints.XNES` on a Rosenbrock error and returns a dictionary
+    with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnRosenbrockError`.
+    """
+    problem = cpt.RunOptimiserOnRosenbrockError(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def two_dim_parabola(n_iterations=50):
+    """
+    Tests :class:`pints.XNES` on a two-dimensional parabolic error and returns
+    a dictionary with entries ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnTwoDimParabola`.
+    """
+    problem = cpt.RunOptimiserOnTwoDimParabola(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+_method = pints.XNES
+_fguess = True
+_change_point_tests = [
+    bounded_fitzhugh_nagumo,
+    bounded_untransformed_logistic,
+    rosenbrock,
+    two_dim_parabola,
+]

From 0294abc90315c19e2fb039f4d50dbd0b41f469a8 Mon Sep 17 00:00:00 2001
From: Michael Clerx <michael.clerx@nottingham.ac.uk>
Date: Tue, 2 Jan 2024 20:51:07 +0000
Subject: [PATCH 72/73] Added SNES tests

---
 pints/cptests/snes.py | 66 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 pints/cptests/snes.py

diff --git a/pints/cptests/snes.py b/pints/cptests/snes.py
new file mode 100644
index 0000000000..2040a95d18
--- /dev/null
+++ b/pints/cptests/snes.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+#
+# Change point tests for SNES.
+#
+# 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 pints
+import pints.cptests as cpt
+
+
+def bounded_fitzhugh_nagumo(n_iterations=100):
+    """
+    Tests :class:`pints.SNES` on a bounded Fitzhugh-Nagumo model, and returns
+    a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedFitzhughNagumo(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def bounded_untransformed_logistic(n_iterations=300):
+    """
+    Tests :class:`pints.SNES` on a bounded logistic model without
+    transformations, and returns a dictionary with ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnBoundedUntransformedLogistic`.
+    """
+    problem = cpt.RunOptimiserOnBoundedUntransformedLogistic(
+        _method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+def two_dim_parabola(n_iterations=50):
+    """
+    Tests :class:`pints.SNES` on a two-dimensional parabolic error and returns
+    a dictionary with entries ``error`` and ``distance``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunOptimiserOnTwoDimParabola`.
+    """
+    problem = cpt.RunOptimiserOnTwoDimParabola(_method, n_iterations, _fguess)
+    return {
+        'error': problem.error(),
+        'distance': problem.distance()
+    }
+
+
+_method = pints.SNES
+_fguess = True
+_change_point_tests = [
+    bounded_fitzhugh_nagumo,
+    bounded_untransformed_logistic,
+    two_dim_parabola,
+]

From f7e6b6b8da55922b2137eeef2b7dd94d9ee62fc8 Mon Sep 17 00:00:00 2001
From: FarmHJ <hui.farm@cs.ox.ac.uk>
Date: Tue, 9 Apr 2024 21:45:31 +0100
Subject: [PATCH 73/73] Add test for HMC

---
 pints/cptests/hamiltonian_mcmc.py | 112 +++++++++++++++++++++++++++---
 1 file changed, 104 insertions(+), 8 deletions(-)

diff --git a/pints/cptests/hamiltonian_mcmc.py b/pints/cptests/hamiltonian_mcmc.py
index 767262cee0..1cd7e3f63b 100644
--- a/pints/cptests/hamiltonian_mcmc.py
+++ b/pints/cptests/hamiltonian_mcmc.py
@@ -24,7 +24,52 @@ def two_dim_gaussian(n_iterations=1000, n_warmup=200):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
-        method_hyper_parameters=[20, 1]
+        method_hyper_parameters=[20, 0.5]
+    )
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def correlated_gaussian(n_iterations=2000, n_warmup=500):
+    """
+    Tests :class:`pints.HamiltonianMCMC`
+    on a six-dimensional highly correlated Gaussian distribution with true
+    solution ``[0, 0, 0, 0, 0, 0]`` and returns a dictionary with entries
+    ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnCorrelatedGaussian`.
+    """
+    problem = cpt.RunMcmcMethodOnCorrelatedGaussian(
+        method=_method,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=n_warmup,
+        method_hyper_parameters=[20, 0.5]
+    )
+    return {
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def banana(n_iterations=2000, n_warmup=1000):
+    """
+    Tests :class:`pints.HamiltonianMCMC`
+    on a two-dimensional "twisted Gaussian" distribution with true solution
+    ``[0, 0]`` and returns a dictionary with entries ``kld`` and ``mean-ess``.
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnBanana`.
+    """
+    problem = cpt.RunMcmcMethodOnBanana(
+        method=_method,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=n_warmup,
+        method_hyper_parameters=[20, 0.5]
     )
     return {
         'kld': problem.estimate_kld(),
@@ -46,7 +91,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
         n_chains=4,
         n_iterations=n_iterations,
         n_warmup=n_warmup,
-        method_hyper_parameters=[20, 1]
+        method_hyper_parameters=[20, 0.5]
     )
     return {
         'kld': problem.estimate_kld(),
@@ -54,7 +99,7 @@ def high_dim_gaussian(n_iterations=4000, n_warmup=1000):
     }
 
 
-def annulus(n_iterations=10000, n_warmup=1000):
+def annulus(n_iterations=5000, n_warmup=1000):
     """
     Tests :class:`pints.HamiltonianMCMC`
     on a two-dimensional annulus distribution with radius 10, and returns a
@@ -65,18 +110,69 @@ def annulus(n_iterations=10000, n_warmup=1000):
     """
     problem = cpt.RunMcmcMethodOnAnnulus(
         method=_method,
-        n_chains=10,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=n_warmup,
+        method_hyper_parameters=[20, 0.5]
+    )
+    return {
+        'distance': problem.estimate_distance(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def multimodal_gaussian(n_iterations=2000, n_warmup=500):
+    """
+    Tests :class:`pints.HamiltonianMCMC`
+    on a two-dimensional multi-modal Gaussian distribution with modes at
+    ``[0, 0]``, ``[5, 10]``, and ``[10, 0]``, and returns a dict with entries
+    "kld" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnMultimodalGaussian`.
+    """
+    problem = cpt.RunMcmcMethodOnMultimodalGaussian(
+        method=_method,
+        n_chains=4,
         n_iterations=n_iterations,
-        n_warmup=n_warmup)
+        n_warmup=n_warmup,
+        method_hyper_parameters=[20, 0.5]
+    )
     return {
-        'kld': problem.estimate_distance(),
+        'kld': problem.estimate_kld(),
+        'mean-ess': problem.estimate_mean_ess()
+    }
+
+
+def cone(n_iterations=2000, n_warmup=500):
+    """
+    Tests :class:`pints.MonomialGammaHamiltonianMCMC`
+    on a two-dimensional cone distribution centered at ``[0, 0]``, and returns
+    a dict with entries "distance" and "mean-ess".
+
+    For details of the solved problem, see
+    :class:`pints.cptests.RunMcmcMethodOnCone`.
+    """
+    problem = cpt.RunMcmcMethodOnCone(
+        method=_method,
+        n_chains=4,
+        n_iterations=n_iterations,
+        n_warmup=n_warmup,
+        method_hyper_parameters=[20, 0.5]
+    )
+    return {
+        'distance': problem.estimate_distance(),
         'mean-ess': problem.estimate_mean_ess()
     }
 
 
 _method = pints.HamiltonianMCMC
 _change_point_tests = [
-    two_dim_gaussian,
-    high_dim_gaussian,
     annulus,
+    banana,
+    cone,
+    correlated_gaussian,
+    high_dim_gaussian,
+    multimodal_gaussian,
+    two_dim_gaussian,
 ]