From 48ca86c9f168a13be9352b1e5d9df25065dcf6e5 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Thu, 4 Jul 2019 10:37:19 +0200
Subject: [PATCH 01/38] Catch update.

---
 test/catch.hpp | 6323 +++++++++++++++++++++++++++++++++---------------
 1 file changed, 4413 insertions(+), 1910 deletions(-)

diff --git a/test/catch.hpp b/test/catch.hpp
index b1b2411..303f664 100644
--- a/test/catch.hpp
+++ b/test/catch.hpp
@@ -1,9 +1,9 @@
 /*
- *  Catch v2.5.0
- *  Generated: 2018-11-26 20:46:12.165372
+ *  Catch v2.9.1
+ *  Generated: 2019-06-17 11:59:24.363643
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2018 Two Blue Cubes Ltd. All rights reserved.
+ *  Copyright (c) 2019 Two Blue Cubes Ltd. All rights reserved.
  *
  *  Distributed under the Boost Software License, Version 1.0. (See accompanying
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -14,8 +14,8 @@
 
 
 #define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 5
-#define CATCH_VERSION_PATCH 0
+#define CATCH_VERSION_MINOR 9
+#define CATCH_VERSION_PATCH 1
 
 #ifdef __clang__
 #    pragma clang system_header
@@ -36,10 +36,11 @@
 #       pragma clang diagnostic ignored "-Wcovered-switch-default"
 #    endif
 #elif defined __GNUC__
-     // GCC likes to warn on REQUIREs, and we cannot suppress them
-     // locally because g++'s support for _Pragma is lacking in older,
-     // still supported, versions
-#    pragma GCC diagnostic ignored "-Wparentheses"
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wunused-variable"
 #    pragma GCC diagnostic ignored "-Wpadded"
@@ -156,6 +157,12 @@ namespace Catch {
 #       define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \
             _Pragma( "clang diagnostic pop" )
 
+#       define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+
 #endif // __clang__
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -203,9 +210,9 @@ namespace Catch {
 // some versions of cygwin (most) do not support std::to_string. Use the libstd check.
 // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-	       && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
 
-#	define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
 
 # endif
 #endif // __CYGWIN__
@@ -232,7 +239,11 @@ namespace Catch {
 #  if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
 #    define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #  endif
+#endif // _MSC_VER
 
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
 #endif // _MSC_VER
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -273,6 +284,14 @@ namespace Catch {
 #endif
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// Check if optional is available and usable
+#if defined(__has_include)
+#  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+#  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
+
 ////////////////////////////////////////////////////////////////////////////////
 // Check if variant is available and usable
 #if defined(__has_include)
@@ -283,9 +302,11 @@ namespace Catch {
 #      include <ciso646>
 #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
 #        define CATCH_CONFIG_NO_CPP17_VARIANT
-#     else
+#      else
 #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
 #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#    else
+#      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
 #    endif // defined(__clang__) && (__clang_major__ < 8)
 #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
 #endif // __has_include
@@ -309,6 +330,10 @@ namespace Catch {
 #    define CATCH_CONFIG_CPP11_TO_STRING
 #endif
 
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
 #if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
 #  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #endif
@@ -337,6 +362,10 @@ namespace Catch {
 #  define CATCH_CONFIG_POLYFILL_ISNAN
 #endif
 
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
 #   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
@@ -349,6 +378,10 @@ namespace Catch {
 #   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
 #   define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 #endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
 
 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
 #define CATCH_TRY if ((true))
@@ -407,10 +440,10 @@ namespace Catch {
             line( _line )
         {}
 
-        SourceLineInfo( SourceLineInfo const& other )        = default;
-        SourceLineInfo( SourceLineInfo && )                  = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
-        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
 
         bool empty() const noexcept;
         bool operator == ( SourceLineInfo const& other ) const noexcept;
@@ -463,7 +496,6 @@ namespace Catch {
 // start catch_interfaces_testcase.h
 
 #include <vector>
-#include <memory>
 
 namespace Catch {
 
@@ -474,8 +506,6 @@ namespace Catch {
         virtual ~ITestInvoker();
     };
 
-    using ITestCasePtr = std::shared_ptr<ITestInvoker>;
-
     class TestCase;
     struct IConfig;
 
@@ -500,8 +530,6 @@ namespace Catch {
 
 namespace Catch {
 
-    class StringData;
-
     /// A non-owning string class (similar to the forthcoming std::string_view)
     /// Note that, because a StringRef may be a substring of another string,
     /// it may not be null terminated. c_str() must return a null terminated
@@ -621,6 +649,8 @@ inline auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noex
 // start catch_type_traits.hpp
 
 
+#include <type_traits>
+
 namespace Catch{
 
 #ifdef CATCH_CPP17_OR_GREATER
@@ -699,21 +729,199 @@ struct is_unique<T0, T1, Rest...> : std::integral_constant
 #define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
 #define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
 #define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
 
 #define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
 
-#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name, __VA_ARGS__)
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name,...) Name " - " #__VA_ARGS__
-#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME(Name,...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    \
+    template<template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2> \
+    constexpr auto append(L1<E1...>, L2<E2...>) noexcept -> L1<E1...,E2...> { return {}; }\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    constexpr auto append(L1<E1...>, L2<E2...>, Rest...) noexcept -> decltype(append(L1<E1...,E2...>{}, Rest{}...)) { return {}; }\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    constexpr auto append(L1<E1...>, TypeList<mpl_::na>, Rest...) noexcept -> L1<E1...> { return {}; }\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    constexpr auto rewrap(List<elems...>) noexcept -> TypeList<Container<elems...>> { return {}; }\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    constexpr auto rewrap(List<Elems...>,Elements...) noexcept -> decltype(append(TypeList<Container<Elems...>>{}, rewrap<Container>(Elements{}...))) { return {}; }\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    constexpr auto create(TypeList<Types...>) noexcept -> decltype(append(Final<>{}, rewrap<Containers>(Types{}...)...)) { return {}; }\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    constexpr auto convert(List<Ts...>) noexcept -> decltype(append(Final<>{},TypeList<Ts>{}...)) { return {}; }
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto rewrap(List<__VA_ARGS__>) noexcept -> TypeList<Container<__VA_ARGS__>> { return {}; }\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    constexpr auto rewrap(List<__VA_ARGS__>,Elements...elems) noexcept -> decltype(append(TypeList<Container<__VA_ARGS__>>{}, rewrap<Container>(elems...))) { return {}; }\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    constexpr auto create(TypeList<Types...>) noexcept -> decltype(append(Final<>{}, rewrap<Containers>(Types{}...)...)) { return {}; }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
 #else
-// MSVC is adding extra space and needs more calls to properly remove ()
-#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name,...) Name " -" #__VA_ARGS__
-#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME1(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, __VA_ARGS__)
-#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME1(Name, INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
 #endif
 
 // end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+template<typename T>
+struct always_false : std::false_type {};
+
+template <typename> struct true_given : std::true_type {};
+struct is_callable_tester {
+    template <typename Fun, typename... Args>
+    true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+    template <typename...>
+    std::false_type static test(...);
+};
+
+template <typename T>
+struct is_callable;
+
+template <typename Fun, typename... Args>
+struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
 namespace Catch {
 
 template<typename C>
@@ -758,18 +966,47 @@ struct AutoReg : NonCopyable {
             };                            \
         }                                 \
         void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION( TestName, ... )  \
-        template<typename TestType>                                             \
-        static void TestName()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... )    \
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
         namespace{                                                                                  \
-            template<typename TestType>                                                             \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) {     \
-                void test();                                                                        \
-            };                                                                                      \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
         }                                                                                           \
-        template<typename TestType>                                                                 \
-        void TestName::test()
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
 #endif
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -809,76 +1046,252 @@ struct AutoReg : NonCopyable {
         CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
     ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, ... )\
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> \
-        static void TestFunc();\
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
         namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
             template<typename...Types> \
             struct TestName{\
-                template<typename...Ts> \
-                TestName(Ts...names){\
-                    CATCH_INTERNAL_CHECK_UNIQUE_TYPES(CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)) \
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
                     using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ names, Tags } ), 0)... };/* NOLINT */ \
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
                 }\
             };\
-            INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestName, Name, __VA_ARGS__) \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
         }\
         CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> \
-        static void TestFunc()
+        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
 
-#if defined(CATCH_CPP17_OR_GREATER)
-#define CATCH_INTERNAL_CHECK_UNIQUE_TYPES(...) static_assert(Catch::is_unique<__VA_ARGS__>,"Duplicate type detected in declaration of template test case");
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
 #else
-#define CATCH_INTERNAL_CHECK_UNIQUE_TYPES(...) static_assert(Catch::is_unique<__VA_ARGS__>::value,"Duplicate type detected in declaration of template test case");
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
 #endif
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ )
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
 #else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ ) )
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
 #endif
 
-    #define INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestName, Name, ...)\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)>(CATCH_REC_LIST_UD(INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME,Name, __VA_ARGS__));\
-            return 0;\
-        }();
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = decltype(create<TestName, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>{})); \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                    \
+        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS              \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
 
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, ... ) \
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            template<typename TestType> \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = decltype(convert<TestName>(TmplList {})); \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                        \
+        }}\
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                    \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS\
+        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS\
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        template<typename TestType> \
             struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
                 void test();\
             };\
-            template<typename...Types> \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
             struct TestNameClass{\
-                template<typename...Ts> \
-                TestNameClass(Ts...names){\
-                    CATCH_INTERNAL_CHECK_UNIQUE_TYPES(CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)) \
+                void reg_tests(){\
+                    int index = 0;\
                     using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ names, Tags } ), 0)... };/* NOLINT */ \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
                 }\
             };\
-            INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestNameClass, Name, __VA_ARGS__)\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = decltype(create<TestNameClass, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>{}));\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
         }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS\
+        }\
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
         template<typename TestType> \
         void TestName<TestType>::test()
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, __VA_ARGS__ )
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
 #else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, __VA_ARGS__ ) )
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
 #endif
 
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = decltype(convert<TestNameClass>(TmplList {}));\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
+
 // end catch_test_registry.h
 // start catch_capture.hpp
 
@@ -997,6 +1410,41 @@ namespace Catch {
 }
 
 // end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, std::string>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
 
 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
 #include <string_view>
@@ -1282,10 +1730,13 @@ namespace Catch {
     template<>
     struct StringMaker<float> {
         static std::string convert(float value);
+        static int precision;
     };
+
     template<>
     struct StringMaker<double> {
         static std::string convert(double value);
+        static int precision;
     };
 
     template <typename T>
@@ -1370,6 +1821,7 @@ namespace Catch {
 #  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
 #  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
 #  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
 #endif
 
 // Separate std::pair specialization
@@ -1391,6 +1843,24 @@ namespace Catch {
 }
 #endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
 
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
 // Separate std::tuple specialization
 #if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
 #include <tuple>
@@ -1639,6 +2109,18 @@ struct ratio_string<std::milli> {
 }
 #endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
 
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return enumInfo.lookup( static_cast<int>( value ) ); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
@@ -1652,6 +2134,7 @@ struct ratio_string<std::milli> {
 #pragma warning(disable:4018) // more "signed/unsigned mismatch"
 #pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
 #pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
 #endif
 
 namespace Catch {
@@ -1695,6 +2178,62 @@ namespace Catch {
             m_op( op ),
             m_rhs( rhs )
         {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
     };
 
     template<typename LhsT>
@@ -1707,7 +2246,7 @@ namespace Catch {
 
     public:
         explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, lhs ? true : false },
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
             m_lhs( lhs )
         {}
     };
@@ -1774,6 +2313,20 @@ namespace Catch {
             return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
         }
 
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
         auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
             return UnaryExpr<LhsT>{ m_lhs };
         }
@@ -1807,6 +2360,7 @@ namespace Catch {
 // start catch_interfaces_capture.h
 
 #include <string>
+#include <chrono>
 
 namespace Catch {
 
@@ -1815,15 +2369,20 @@ namespace Catch {
     struct SectionInfo;
     struct SectionEndInfo;
     struct MessageInfo;
+    struct MessageBuilder;
     struct Counts;
-    struct BenchmarkInfo;
-    struct BenchmarkStats;
     struct AssertionReaction;
     struct SourceLineInfo;
 
     struct ITransientExpression;
     struct IGeneratorTracker;
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
     struct IResultCapture {
 
         virtual ~IResultCapture();
@@ -1835,12 +2394,18 @@ namespace Catch {
 
         virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
         virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats const& stats ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
         virtual void pushScopedMessage( MessageInfo const& message ) = 0;
         virtual void popScopedMessage( MessageInfo const& message ) = 0;
 
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
         virtual void handleFatalErrorCondition( StringRef message ) = 0;
 
         virtual void handleExpr
@@ -2004,9 +2569,12 @@ namespace Catch {
     class ScopedMessage {
     public:
         explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
         ~ScopedMessage();
 
         MessageInfo m_info;
+        bool m_moved;
     };
 
     class Capturer {
@@ -2069,7 +2637,7 @@ namespace Catch {
             CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, false && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
     // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2150,6 +2718,10 @@ namespace Catch {
 #define INTERNAL_CATCH_INFO( macroName, log ) \
     Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
 
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
 ///////////////////////////////////////////////////////////////////////////////
 // Although this is matcher-based, it can be used with just a string
 #define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
@@ -2293,52 +2865,6 @@ namespace Catch {
     CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 
 // end catch_section.h
-// start catch_benchmark.h
-
-#include <cstdint>
-#include <string>
-
-namespace Catch {
-
-    class BenchmarkLooper {
-
-        std::string m_name;
-        std::size_t m_count = 0;
-        std::size_t m_iterationsToRun = 1;
-        uint64_t m_resolution;
-        Timer m_timer;
-
-        static auto getResolution() -> uint64_t;
-    public:
-        // Keep most of this inline as it's on the code path that is being timed
-        BenchmarkLooper( StringRef name )
-        :   m_name( name ),
-            m_resolution( getResolution() )
-        {
-            reportStart();
-            m_timer.start();
-        }
-
-        explicit operator bool() {
-            if( m_count < m_iterationsToRun )
-                return true;
-            return needsMoreIterations();
-        }
-
-        void increment() {
-            ++m_count;
-        }
-
-        void reportStart();
-        auto needsMoreIterations() -> bool;
-    };
-
-} // end namespace Catch
-
-#define BENCHMARK( name ) \
-    for( Catch::BenchmarkLooper looper( name ); looper; looper.increment() )
-
-// end catch_benchmark.h
 // start catch_interfaces_exception.h
 
 // start catch_interfaces_registry_hub.h
@@ -2355,6 +2881,8 @@ namespace Catch {
     struct IReporterRegistry;
     struct IReporterFactory;
     struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
     class StartupExceptionRegistry;
 
     using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
@@ -2365,7 +2893,6 @@ namespace Catch {
         virtual IReporterRegistry const& getReporterRegistry() const = 0;
         virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
         virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-
         virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
 
         virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
@@ -2379,6 +2906,7 @@ namespace Catch {
         virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
         virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
         virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
     };
 
     IRegistryHub const& getRegistryHub();
@@ -2585,6 +3113,7 @@ struct StringMaker<Catch::Detail::Approx> {
 
 #include <string>
 #include <iosfwd>
+#include <vector>
 
 namespace Catch {
 
@@ -2596,6 +3125,9 @@ namespace Catch {
     void toLowerInPlace( std::string& s );
     std::string toLower( std::string const& s );
     std::string trim( std::string const& str );
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
     bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
 
     struct pluralise {
@@ -2844,7 +3376,7 @@ class PredicateMatcher : public MatcherBase<T> {
 
     // The following functions create the actual matcher objects.
     // The user has to explicitly specify type to the function, because
-    // infering std::function<bool(T const&)> is hard (but possible) and
+    // inferring std::function<bool(T const&)> is hard (but possible) and
     // requires a lot of TMP.
     template<typename T>
     Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
@@ -2932,28 +3464,6 @@ namespace Catch {
 namespace Matchers {
 
     namespace Vector {
-        namespace Detail {
-            template <typename InputIterator, typename T>
-            size_t count(InputIterator first, InputIterator last, T const& item) {
-                size_t cnt = 0;
-                for (; first != last; ++first) {
-                    if (*first == item) {
-                        ++cnt;
-                    }
-                }
-                return cnt;
-            }
-            template <typename InputIterator, typename T>
-            bool contains(InputIterator first, InputIterator last, T const& item) {
-                for (; first != last; ++first) {
-                    if (*first == item) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-        }
-
         template<typename T>
         struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
 
@@ -3029,37 +3539,52 @@ namespace Matchers {
         };
 
         template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
+        struct ApproxMatcher : MatcherBase<std::vector<T>> {
+
+            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                if (m_comparator.size() != v.size())
                     return false;
-                }
-                auto lfirst = m_target.begin(), llast = m_target.end();
-                auto rfirst = vec.begin(), rlast = vec.end();
-                // Cut common prefix to optimize checking of permuted parts
-                while (lfirst != llast && *lfirst == *rfirst) {
-                    ++lfirst; ++rfirst;
-                }
-                if (lfirst == llast) {
-                    return true;
-                }
-
-                for (auto mid = lfirst; mid != llast; ++mid) {
-                    // Skip already counted items
-                    if (Detail::contains(lfirst, mid, *mid)) {
-                        continue;
-                    }
-                    size_t num_vec = Detail::count(rfirst, rlast, *mid);
-                    if (num_vec == 0 || Detail::count(lfirst, llast, *mid) != num_vec) {
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
                         return false;
-                    }
-                }
-
                 return true;
             }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
+            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
+            bool match(std::vector<T> const& vec) const override {
+                // Note: This is a reimplementation of std::is_permutation,
+                //       because I don't want to include <algorithm> inside the common path
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
 
             std::string describe() const override {
                 return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
@@ -3088,6 +3613,11 @@ namespace Matchers {
         return Vector::EqualsMatcher<T>( comparator );
     }
 
+    template<typename T>
+    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
+        return Vector::ApproxMatcher<T>( comparator );
+    }
+
     template<typename T>
     Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
         return Vector::UnorderedEqualsMatcher<T>(target);
@@ -3175,16 +3705,17 @@ namespace Catch {
 namespace Catch {
 
     namespace Generators {
-        class GeneratorBase {
-        protected:
-            size_t m_size = 0;
-
+        class GeneratorUntypedBase {
         public:
-            GeneratorBase( size_t size ) : m_size( size ) {}
-            virtual ~GeneratorBase();
-            auto size() const -> size_t { return m_size; }
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
         };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorBase>;
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
 
     } // namespace Generators
 
@@ -3193,7 +3724,6 @@ namespace Catch {
         virtual auto hasGenerator() const -> bool = 0;
         virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
         virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-        virtual auto getIndex() const -> std::size_t = 0;
     };
 
 } // namespace Catch
@@ -3201,7 +3731,7 @@ namespace Catch {
 // end catch_interfaces_generatortracker.h
 // start catch_enforce.h
 
-#include <stdexcept>
+#include <exception>
 
 namespace Catch {
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
@@ -3214,18 +3744,30 @@ namespace Catch {
     [[noreturn]]
     void throw_exception(std::exception const& e);
 #endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
 } // namespace Catch;
 
-#define CATCH_PREPARE_EXCEPTION( type, msg ) \
-    type( ( Catch::ReusableStringStream() << msg ).str() )
-#define CATCH_INTERNAL_ERROR( msg ) \
-    Catch::throw_exception(CATCH_PREPARE_EXCEPTION( std::logic_error, CATCH_INTERNAL_LINEINFO << ": Internal Catch error: " << msg))
-#define CATCH_ERROR( msg ) \
-    Catch::throw_exception(CATCH_PREPARE_EXCEPTION( std::domain_error, msg ))
-#define CATCH_RUNTIME_ERROR( msg ) \
-    Catch::throw_exception(CATCH_PREPARE_EXCEPTION( std::runtime_error, msg ))
-#define CATCH_ENFORCE( condition, msg ) \
-    do{ if( !(condition) ) CATCH_ERROR( msg ); } while(false)
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__));
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
 
 // end catch_enforce.h
 #include <memory>
@@ -3233,8 +3775,21 @@ namespace Catch {
 #include <cassert>
 
 #include <utility>
+#include <exception>
 
 namespace Catch {
+
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
+
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
+
+    const char* what() const noexcept override final;
+};
+
 namespace Generators {
 
     // !TBD move this into its own location?
@@ -3246,196 +3801,139 @@ namespace Generators {
     }
 
     template<typename T>
-    struct IGenerator {
-        virtual ~IGenerator() {}
-        virtual auto get( size_t index ) const -> T = 0;
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
     };
 
     template<typename T>
-    class SingleValueGenerator : public IGenerator<T> {
+    class SingleValueGenerator final : public IGenerator<T> {
         T m_value;
     public:
-        SingleValueGenerator( T const& value ) : m_value( value ) {}
+        SingleValueGenerator(T const& value) : m_value( value ) {}
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
 
-        auto get( size_t ) const -> T override {
+        T const& get() const override {
             return m_value;
         }
+        bool next() override {
+            return false;
+        }
     };
 
     template<typename T>
-    class FixedValuesGenerator : public IGenerator<T> {
+    class FixedValuesGenerator final : public IGenerator<T> {
         std::vector<T> m_values;
-
+        size_t m_idx = 0;
     public:
         FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
 
-        auto get( size_t index ) const -> T override {
-            return m_values[index];
-        }
-    };
-
-    template<typename T>
-    class RangeGenerator : public IGenerator<T> {
-        T const m_first;
-        T const m_last;
-
-    public:
-        RangeGenerator( T const& first, T const& last ) : m_first( first ), m_last( last ) {
-            assert( m_last > m_first );
-        }
-
-        auto get( size_t index ) const -> T override {
-            // ToDo:: introduce a safe cast to catch potential overflows
-            return static_cast<T>(m_first+index);
+        T const& get() const override {
+            return m_values[m_idx];
         }
-    };
-
-    template<typename T>
-    struct NullGenerator : IGenerator<T> {
-        auto get( size_t ) const -> T override {
-            CATCH_INTERNAL_ERROR("A Null Generator is always empty");
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
         }
     };
 
-    template<typename T>
-    class Generator {
+    template <typename T>
+    class GeneratorWrapper final {
         std::unique_ptr<IGenerator<T>> m_generator;
-        size_t m_size;
-
     public:
-        Generator( size_t size, std::unique_ptr<IGenerator<T>> generator )
-        :   m_generator( std::move( generator ) ),
-            m_size( size )
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
         {}
-
-        auto size() const -> size_t { return m_size; }
-        auto operator[]( size_t index ) const -> T {
-            assert( index < m_size );
-            return m_generator->get( index );
+        T const& get() const {
+            return m_generator->get();
         }
-    };
-
-    std::vector<size_t> randomiseIndices( size_t selectionSize, size_t sourceSize );
-
-    template<typename T>
-    class GeneratorRandomiser : public IGenerator<T> {
-        Generator<T> m_baseGenerator;
-
-        std::vector<size_t> m_indices;
-    public:
-        GeneratorRandomiser( Generator<T>&& baseGenerator, size_t numberOfItems )
-        :   m_baseGenerator( std::move( baseGenerator ) ),
-            m_indices( randomiseIndices( numberOfItems, m_baseGenerator.size() ) )
-        {}
-
-        auto get( size_t index ) const -> T override {
-            return m_baseGenerator[m_indices[index]];
+        bool next() {
+            return m_generator->next();
         }
     };
 
-    template<typename T>
-    struct RequiresASpecialisationFor;
-
-    template<typename T>
-    auto all() -> Generator<T> { return RequiresASpecialisationFor<T>(); }
-
-    template<>
-    auto all<int>() -> Generator<int>;
-
-    template<typename T>
-    auto range( T const& first, T const& last ) -> Generator<T> {
-        return Generator<T>( (last-first), pf::make_unique<RangeGenerator<T>>( first, last ) );
-    }
-
-    template<typename T>
-    auto random( T const& first, T const& last ) -> Generator<T> {
-        auto gen = range( first, last );
-        auto size = gen.size();
-
-        return Generator<T>( size, pf::make_unique<GeneratorRandomiser<T>>( std::move( gen ), size ) );
-    }
-    template<typename T>
-    auto random( size_t size ) -> Generator<T> {
-        return Generator<T>( size, pf::make_unique<GeneratorRandomiser<T>>( all<T>(), size ) );
-    }
-
-    template<typename T>
-    auto values( std::initializer_list<T> values ) -> Generator<T> {
-        return Generator<T>( values.size(), pf::make_unique<FixedValuesGenerator<T>>( values ) );
-    }
-    template<typename T>
-    auto value( T const& val ) -> Generator<T> {
-        return Generator<T>( 1, pf::make_unique<SingleValueGenerator<T>>( val ) );
-    }
-
-    template<typename T>
-    auto as() -> Generator<T> {
-        return Generator<T>( 0, pf::make_unique<NullGenerator<T>>() );
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
     }
-
-    template<typename... Ts>
-    auto table( std::initializer_list<std::tuple<Ts...>>&& tuples ) -> Generator<std::tuple<Ts...>> {
-        return values<std::tuple<Ts...>>( std::forward<std::initializer_list<std::tuple<Ts...>>>( tuples ) );
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
     }
 
     template<typename T>
-    struct Generators : GeneratorBase {
-        std::vector<Generator<T>> m_generators;
-
-        using type = T;
-
-        Generators() : GeneratorBase( 0 ) {}
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
 
-        void populate( T&& val ) {
-            m_size += 1;
-            m_generators.emplace_back( value( std::move( val ) ) );
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::move(val)));
         }
         template<typename U>
-        void populate( U&& val ) {
-            populate( T( std::move( val ) ) );
+        void populate(U&& val) {
+            populate(T(std::move(val)));
         }
-        void populate( Generator<T>&& generator ) {
-            m_size += generator.size();
-            m_generators.emplace_back( std::move( generator ) );
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
         }
 
-        template<typename U, typename... Gs>
-        void populate( U&& valueOrGenerator, Gs... moreGenerators ) {
-            populate( std::forward<U>( valueOrGenerator ) );
-            populate( std::forward<Gs>( moreGenerators )... );
+    public:
+        template <typename... Gs>
+        Generators(Gs... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
         }
 
-        auto operator[]( size_t index ) const -> T {
-            size_t sizes = 0;
-            for( auto const& gen : m_generators ) {
-                auto localIndex = index-sizes;
-                sizes += gen.size();
-                if( index < sizes )
-                    return gen[localIndex];
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
             }
-            CATCH_INTERNAL_ERROR("Index '" << index << "' is out of range (" << sizes << ')');
+            return m_current < m_generators.size();
         }
     };
 
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
     template<typename T, typename... Gs>
-    auto makeGenerators( Generator<T>&& generator, Gs... moreGenerators ) -> Generators<T> {
-        Generators<T> generators;
-        generators.m_generators.reserve( 1+sizeof...(Gs) );
-        generators.populate( std::move( generator ), std::forward<Gs>( moreGenerators )... );
-        return generators;
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
     }
     template<typename T>
-    auto makeGenerators( Generator<T>&& generator ) -> Generators<T> {
-        Generators<T> generators;
-        generators.populate( std::move( generator ) );
-        return generators;
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
     }
     template<typename T, typename... Gs>
     auto makeGenerators( T&& val, Gs... moreGenerators ) -> Generators<T> {
         return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
     }
     template<typename T, typename U, typename... Gs>
-    auto makeGenerators( U&& val, Gs... moreGenerators ) -> Generators<T> {
+    auto makeGenerators( as<T>, U&& val, Gs... moreGenerators ) -> Generators<T> {
         return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
     }
 
@@ -3444,1693 +3942,3152 @@ namespace Generators {
     template<typename L>
     // Note: The type after -> is weird, because VS2015 cannot parse
     //       the expression used in the typedef inside, when it is in
-    //       return type. Yeah, ¯\_(ツ)_/¯
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>()[0]) {
+    //       return type. Yeah.
+    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
         using UnderlyingType = typename decltype(generatorExpression())::type;
 
         IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if( !tracker.hasGenerator() )
-            tracker.setGenerator( pf::make_unique<Generators<UnderlyingType>>( generatorExpression() ) );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
 
-        auto const& generator = static_cast<Generators<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator[tracker.getIndex()];
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
     }
 
 } // namespace Generators
 } // namespace Catch
 
 #define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, []{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
 
 // end catch_generators.hpp
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
+// start catch_generators_generic.hpp
 
 namespace Catch {
+namespace Generators {
 
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
 
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
 
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
 
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
+                }
+            }
+        }
 
-        std::string tagsAsString() const;
+        T const& get() const override {
+            return m_generator.get();
+        }
 
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
     };
 
-    class TestCase : public TestCaseInfo {
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
+
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
     public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
 
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
 
-        TestCase withName( std::string const& _newName ) const;
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
 
-        void invoke() const;
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
 
-        TestCaseInfo const& getTestCaseInfo() const;
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
 
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
 
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
 
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
 
-#ifdef __clang__
-#pragma clang diagnostic pop
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here. Also *_t format is preferred over
+    // typename *::type format.
+    template <typename Func, typename U>
+    using MapFunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+#else
+    template <typename Func, typename U>
+    using MapFunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
 #endif
 
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
+    template <typename Func, typename U, typename T = MapFunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
 
-namespace Catch {
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
 
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            m_chunk.push_back(m_generator.get());
+            for (size_t i = 1; i < m_chunk_size; ++i) {
+                if (!m_generator.next()) {
+                    Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
     };
-}
-
-// end catch_interfaces_runner.h
 
-#ifdef __OBJC__
-// start catch_objc.hpp
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
 
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
+} // namespace Generators
+} // namespace Catch
 
-@optional
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
 
--(void) setUp;
--(void) tearDown;
+// start catch_context.h
 
-@end
+#include <memory>
 
 namespace Catch {
 
-    class OcMethod : public ITestInvoker {
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
 
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+    using IConfigPtr = std::shared_ptr<IConfig const>;
 
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
+    struct IContext
+    {
+        virtual ~IContext();
 
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
 
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
 
-        Class m_cls;
-        SEL m_sel;
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
     };
 
-    namespace Detail{
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        return *IMutableContext::currentContext;
+    }
 
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
     }
 
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
+    void cleanUpContext();
+}
 
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
+// end catch_context.h
+// start catch_interfaces_config.h
 
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
+// start catch_option.hpp
 
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
+namespace Catch {
 
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( nullptr ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
 
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
+        ~Option() {
+            reset();
+        }
 
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
 
-                bool match( NSString* arg ) const override {
-                    return false;
-                }
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
 
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
 
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
 
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
 
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
+    private:
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
 
-                bool match( NSString* str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
+} // end namespace Catch
 
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+// end catch_option.hpp
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <memory>
 
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
+namespace Catch {
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
 
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
 
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+    class TestSpec;
 
-        } // namespace NSStringMatchers
-        } // namespace Impl
+    struct IConfig : NonCopyable {
 
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+        virtual ~IConfig();
 
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
 
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+    };
 
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
 
-    } // namespace Matchers
+// end catch_interfaces_config.h
+#include <random>
 
-    using namespace Matchers;
+namespace Catch {
+namespace Generators {
 
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    // FIXME: What is the right seed?
+    std::minstd_rand m_rand;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
 
-} // namespace Catch
+    RandomFloatingGenerator(Float a, Float b):
+        m_rand(getCurrentContext().getConfig()->rngSeed()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
 
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rand);
+        return true;
+    }
+};
 
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    std::minstd_rand m_rand;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
 
-// end catch_objc.hpp
-#endif
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rand(getCurrentContext().getConfig()->rngSeed()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
 
-#ifdef CATCH_CONFIG_EXTERNAL_INTERFACES
-// start catch_external_interfaces.h
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rand);
+        return true;
+    }
+};
 
-// start catch_reporter_bases.hpp
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
 
-// start catch_interfaces_reporter.h
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
 
-// start catch_config.hpp
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
 
-// start catch_test_spec_parser.h
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
 
-// start catch_test_spec.h
+    T const& get() const override {
+        return m_current;
+    }
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
 
-// start catch_wildcard_pattern.h
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
 
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
 
-    public:
+} // namespace Generators
+} // namespace Catch
 
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
+// end catch_generators_specific.hpp
 
-    private:
-        std::string adjustCase( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// start catch_test_case_info.h
 
-// end catch_wildcard_pattern.h
 #include <string>
 #include <vector>
 #include <memory>
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
 namespace Catch {
 
-    class TestSpec {
-        struct Pattern {
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
+    struct ITestInvoker;
 
-        class NamePattern : public Pattern {
-        public:
-            NamePattern( std::string const& name );
-            virtual ~NamePattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
         };
 
-        class TagPattern : public Pattern {
-        public:
-            TagPattern( std::string const& tag );
-            virtual ~TagPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::vector<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
 
-        class ExcludedPattern : public Pattern {
-        public:
-            ExcludedPattern( PatternPtr const& underlyingPattern );
-            virtual ~ExcludedPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
 
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
 
-            bool matches( TestCaseInfo const& testCase ) const;
-        };
+        std::string tagsAsString() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
 
+    class TestCase : public TestCaseInfo {
     public:
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
 
-    private:
-        std::vector<Filter> m_filters;
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
 
-        friend class TestSpecParser;
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+
+    private:
+        std::shared_ptr<ITestInvoker> test;
     };
+
+    TestCase makeTestCase(  ITestInvoker* testCase,
+                            std::string const& className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& lineInfo );
 }
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
-
-#include <string>
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
 
 namespace Catch {
 
-    struct TagAlias;
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
 
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+// end catch_interfaces_runner.h
 
-        static ITagAliasRegistry const& get();
-    };
+#ifdef __OBJC__
+// start catch_objc.hpp
 
-} // end namespace Catch
+#import <objc/runtime.h>
 
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
+#include <string>
 
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        bool m_exclusion = false;
-        std::size_t m_start = std::string::npos, m_pos = 0;
-        std::string m_arg;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
 
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
 
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
+@optional
 
-    private:
-        void visitChar( char c );
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public ITestInvoker {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                bool match( NSString* const& str ) const override {
+                    return false;
+                }
+
+                NSString* CATCH_ARC_STRONG m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* const& str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* const& str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* const& str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* const& str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
+return @ name; \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
+{ \
+return @ desc; \
+} \
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
+#endif
+
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
+
+// start catch_reporter_bases.hpp
+
+// start catch_interfaces_reporter.h
+
+// start catch_config.hpp
+
+// start catch_test_spec_parser.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_test_spec.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_wildcard_pattern.h
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
+
+    private:
+        std::string adjustCase( std::string const& str ) const;
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+// end catch_wildcard_pattern.h
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    class TestSpec {
+        struct Pattern {
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+        };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
+        class NamePattern : public Pattern {
+        public:
+            NamePattern( std::string const& name );
+            virtual ~NamePattern();
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            TagPattern( std::string const& tag );
+            virtual ~TagPattern();
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            ExcludedPattern( PatternPtr const& underlyingPattern );
+            virtual ~ExcludedPattern();
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            PatternPtr m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<PatternPtr> m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+        };
+
+    public:
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+
+    private:
+        std::vector<Filter> m_filters;
+
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        bool m_exclusion = false;
+        std::size_t m_start = std::string::npos, m_pos = 0;
+        std::string m_arg;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        void visitChar( char c );
         void startNewMode( Mode mode, std::size_t start );
         void escape();
         std::string subString() const;
 
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
+        template<typename T>
+        void addPattern() {
+            std::string token = subString();
+            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
+                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
+            m_escapeChars.clear();
+            if( startsWith( token, "exclude:" ) ) {
+                m_exclusion = true;
+                token = token.substr( 8 );
+            }
+            if( !token.empty() ) {
+                TestSpec::PatternPtr pattern = std::make_shared<T>( token );
+                if( m_exclusion )
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
+                m_currentFilter.m_patterns.push_back( pattern );
+            }
+            m_exclusion = false;
+            m_mode = None;
+        }
+
+        void addFilter();
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct IStream;
+
+    struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
+
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
+
+        std::string const& getFilename() const;
+
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
+
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+
+    private:
+
+        IStream const* openStream();
+        ConfigData m_data;
+
+        std::unique_ptr<IStream const> m_stream;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+
+} // end namespace Catch
+
+// end catch_config.hpp
+// start catch_assertionresult.h
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
+
+// Outlier information
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
+
+    private:
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used = false;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result);
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
             }
-            if( !token.empty() ) {
-                TestSpec::PatternPtr pattern = std::make_shared<T>( token );
-                if( m_exclusion )
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
             }
-            m_exclusion = false;
-            m_mode = None;
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
         }
 
-        void addFilter();
-    };
-    TestSpec parseTestSpec( std::string const& arg );
+        void assertionStarting(AssertionInfo const&) override {}
 
-} // namespace Catch
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
 
-// end catch_test_spec_parser.h
-// start catch_interfaces_config.h
+        void skipTest(TestCaseInfo const&) override {}
 
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
 
-namespace Catch {
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
 
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
     };
 
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
 
-    struct IConfig : NonCopyable {
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
 
-        virtual ~IConfig();
+        static std::set<Verbosity> getSupportedVerbosities();
 
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual int benchmarkResolutionMultiple() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
     };
 
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
+} // end namespace Catch
 
-// end catch_interfaces_config.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
 
-#include <memory>
-#include <vector>
-#include <string>
+namespace Catch {
 
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
+    struct Colour {
+        enum Code {
+            None = 0,
 
-namespace Catch {
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
 
-    struct IStream;
+            Bright = 0x10,
 
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
 
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
 
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-        int benchmarkResolutionMultiple = 100;
+            Error = BrightRed,
+            Success = Green,
 
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
 
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
+            SecondaryText = LightGrey,
+            Headers = White
+        };
 
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
+        ~Colour();
 
-    class Config : public IConfig {
-    public:
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
 
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
+    private:
+        bool m_moved = false;
+    };
 
-        std::string const& getFilename() const;
+    std::ostream& operator << ( std::ostream& os, Colour const& );
 
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
+} // end namespace Catch
 
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
 
-        std::vector<std::string> const& getTestsOrTags() const;
-        std::vector<std::string> const& getSectionsToRun() const override;
 
-        virtual TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
+namespace Catch {
 
-        bool showHelp() const;
+    template<typename T>
+    class ReporterRegistrar {
 
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        int benchmarkResolutionMultiple() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
+        class ReporterFactory : public IReporterFactory {
 
-    private:
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
 
-        IStream const* openStream();
-        ConfigData m_data;
+            std::string getDescription() const override {
+                return T::getDescription();
+            }
+        };
 
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
+    public:
+
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+        }
     };
 
-} // end namespace Catch
+    template<typename T>
+    class ListenerRegistrar {
 
-// end catch_config.hpp
-// start catch_assertionresult.h
+        class ListenerFactory : public IReporterFactory {
 
-#include <string>
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
 
-namespace Catch {
+    public:
 
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        }
+    };
+}
 
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+#if !defined(CATCH_CONFIG_DISABLE)
 
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
-        std::string reconstructExpression() const;
-    };
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS   \
+     namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#else // CATCH_CONFIG_DISABLE
 
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
 
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
+#endif // CATCH_CONFIG_DISABLE
 
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
 
-} // end namespace Catch
+namespace Catch {
 
-// end catch_assertionresult.h
-// start catch_option.hpp
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
 
-namespace Catch {
+        using StreamingReporterBase::StreamingReporterBase;
 
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
+        ~CompactReporter() override;
 
-        ~Option() {
-            reset();
-        }
+        static std::string getDescription();
 
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
+        ReporterPreferences getPreferences() const override;
 
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
+        void noMatchingTestCases(std::string const& spec) override;
 
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
+        void assertionStarting(AssertionInfo const&) override;
 
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
 
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
+        void sectionEnded(SectionStats const& _sectionStats) override;
 
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
+        void testRunEnded(TestRunStats const& _testRunStats) override;
 
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
     };
 
 } // end namespace Catch
 
-// end catch_option.hpp
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-
-namespace Catch {
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
 
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
 
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
 
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
 
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
 
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
+        void noMatchingTestCases(std::string const& spec) override;
 
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
+        void assertionStarting(AssertionInfo const&) override;
 
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
 
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
 
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = default;
-        AssertionStats& operator = ( AssertionStats && )     = default;
-        virtual ~AssertionStats();
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
 
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
+        void lazyPrint();
 
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
 
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
 
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
 
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
 
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
     };
 
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
+} // end namespace Catch
 
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
 
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
+// start catch_xmlwriter.h
 
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
+#include <vector>
 
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
+namespace Catch {
 
-    struct BenchmarkInfo {
-        std::string name;
-    };
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-        std::size_t iterations;
-        uint64_t elapsedTimeInNanoseconds;
-    };
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
 
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
 
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
+        void encodeTo( std::ostream& os ) const;
 
-        virtual ReporterPreferences getPreferences() const = 0;
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
 
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
 
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+    class XmlWriter {
+    public:
 
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer );
 
-        // *** experimental ***
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
 
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+            ~ScopedElement();
 
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+            ScopedElement& writeText( std::string const& text, bool indent = true );
 
-        // *** experimental ***
-        virtual void benchmarkEnded( BenchmarkStats const& ) {}
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
 
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+        };
 
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
 
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
 
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+        XmlWriter& startElement( std::string const& name );
 
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+        ScopedElement scopedElement( std::string const& name );
 
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
+        XmlWriter& endElement();
 
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
 
-} // end namespace Catch
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
 
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
 
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
+        XmlWriter& writeText( std::string const& text, bool indent = true );
 
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
+        XmlWriter& writeComment( std::string const& text );
 
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
+        void writeStylesheetRef( std::string const& url );
 
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
+        XmlWriter& writeBlankLine();
 
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
+        void ensureTagClosed();
 
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
+    private:
 
-        ~StreamingReporterBase() override = default;
+        void writeDeclaration();
 
-        void noMatchingTestCases(std::string const&) override {}
+        void newlineIfNecessary();
 
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
 
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
+}
 
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
+// end catch_xmlwriter.h
+namespace Catch {
 
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
 
-        IConfigPtr m_config;
-        std::ostream& stream;
+        ~JunitReporter() override;
 
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
+        static std::string getDescription();
 
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
+        void noMatchingTestCases(std::string const& /*spec*/) override;
 
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
+        void testRunStarting(TestRunInfo const& runInfo) override;
 
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
+        void testGroupStarting(GroupInfo const& groupInfo) override;
 
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
 
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
 
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
 
-        private:
-            SectionInfo const& m_other;
-        };
+        void testRunEndedCumulative() override;
 
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
 
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
+        void writeTestCase(TestCaseNode const& testCaseNode);
 
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
+        void writeSection(std::string const& className,
+                          std::string const& rootName,
+                          SectionNode const& sectionNode);
 
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
 
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
 
-        void testCaseStarting( TestCaseInfo const& ) override {}
+} // end namespace Catch
 
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
 
-        void assertionStarting(AssertionInfo const&) override {}
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
 
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
+        ~XmlReporter() override;
 
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
+        static std::string getDescription();
 
-        void skipTest(TestCaseInfo const&) override {}
+        virtual std::string getStylesheetRef() const;
 
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
 
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+    public: // StreamingReporterBase
 
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
+        void noMatchingTestCases(std::string const& s) override;
 
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
+        void testRunStarting(TestRunInfo const& testInfo) override;
 
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
+        void testGroupStarting(GroupInfo const& groupInfo) override;
 
-        static std::set<Verbosity> getSupportedVerbosities();
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
 
         void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
 
-} // end namespace Catch
+        bool assertionEnded(AssertionStats const& assertionStats) override;
 
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
+        void sectionEnded(SectionStats const& sectionStats) override;
 
-namespace Catch {
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
 
-    struct Colour {
-        enum Code {
-            None = 0,
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
 
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
+        void testRunEnded(TestRunStats const& testRunStats) override;
 
-            Bright = 0x10,
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
 
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
+} // end namespace Catch
 
-            Error = BrightRed,
-            Success = Green,
+// end catch_reporter_xml.h
 
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
+// end catch_external_interfaces.h
+#endif
 
-            SecondaryText = LightGrey,
-            Headers = White
-        };
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmark.hpp
 
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
+ // Benchmark
 
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
+// start catch_chronometer.hpp
 
-    private:
-        bool m_moved = false;
-    };
+// User-facing chronometer
 
-    std::ostream& operator << ( std::ostream& os, Colour const& );
 
-} // end namespace Catch
+// start catch_clock.hpp
 
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
+// Clocks
 
 
-namespace Catch {
+#include <chrono>
+#include <ratio>
 
-    template<typename T>
-    class ReporterRegistrar {
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
 
-        class ReporterFactory : public IReporterFactory {
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
 
-            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
+        using default_clock = std::chrono::steady_clock;
 
-            virtual std::string getDescription() const override {
-                return T::getDescription();
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
             }
         };
 
-    public:
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
 
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+// end catch_clock.hpp
+// start catch_optimizer.hpp
+
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
         }
-    };
 
-    template<typename T>
-    class ListenerRegistrar {
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
 
-        class ListenerFactory : public IReporterFactory {
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
 
-            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            virtual std::string getDescription() const override {
-                return std::string();
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
             }
-        };
+        } // namespace Detail
 
-    public:
+#endif
 
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
         }
-    };
-}
 
-#if !defined(CATCH_CONFIG_DISABLE)
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
 
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
+        }
+    } // namespace Benchmark
+} // namespace Catch
 
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS   \
-     namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#else // CATCH_CONFIG_DISABLE
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
 
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
+// Invoke with a special case for void
 
-#endif // CATCH_CONFIG_DISABLE
 
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
+#include <type_traits>
+#include <utility>
 
 namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
+            template <typename Sig>
+            using ResultOf_t = typename std::result_of<Sig>::type;
 
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
 
-        using StreamingReporterBase::StreamingReporterBase;
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
 
-        ~CompactReporter() override;
+        template <typename Fun>
+        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
 
-        static std::string getDescription();
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
 
-        ReporterPreferences getPreferences() const override;
+                ClockDuration<Clock> elapsed() const { return finished - started; }
 
-        void noMatchingTestCases(std::string const& spec) override;
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
 
-        void assertionStarting(AssertionInfo const&) override;
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
 
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
+            int runs() const { return k; }
 
-        void sectionEnded(SectionStats const& _sectionStats) override;
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
 
-        void testRunEnded(TestRunStats const& _testRunStats) override;
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
 
-    };
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
 
-} // end namespace Catch
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
+// end catch_chronometer.hpp
+// start catch_environment.hpp
+
+// Environment information
 
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
 
 namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
 
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
+ // Execution plan
 
-        void noMatchingTestCases(std::string const& spec) override;
 
-        void assertionStarting(AssertionInfo const&) override;
+// start catch_benchmark_function.hpp
 
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
+ // Dumb std::function implementation for consistent call overhead
 
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
 
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats const& stats) override;
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
 
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
 
-    private:
+                    Fun fun;
+                };
 
-        void lazyPrint();
+                struct do_nothing { void operator()() const {} };
 
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
 
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
 
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
 
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
 
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
 
-    private:
-        bool m_headerPrinted = false;
-    };
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
 
-} // end namespace Catch
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
 
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
+                void operator()(Chronometer meter) const { f->call(meter); }
 
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-// start catch_xmlwriter.h
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
+
+// repeat algorithm
 
-#include <vector>
+
+#include <type_traits>
+#include <utility>
 
 namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
 
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+// Run a function for a minimum amount of time
 
-        void encodeTo( std::ostream& os ) const;
 
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+// start catch_measure.hpp
 
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
+// Measure
 
-    class XmlWriter {
-    public:
 
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer );
+// start catch_timing.hpp
 
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+// Timing
 
-            ~ScopedElement();
 
-            ScopedElement& writeText( std::string const& text, bool indent = true );
+#include <tuple>
+#include <type_traits>
 
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Sig>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_timing.hpp
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
             }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-        };
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
 
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
 
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
+                return { meter.elapsed(), std::move(result), iters };
+            }
 
-        XmlWriter& startElement( std::string const& name );
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
 
-        ScopedElement scopedElement( std::string const& name );
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
 
-        XmlWriter& endElement();
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
 
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw optimized_away_error{};
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+// end catch_run_for_at_least.hpp
+#include <algorithm>
 
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
+
+ // Environment measurement
+
+
+// start catch_stats.hpp
 
-        XmlWriter& writeText( std::string const& text, bool indent = true );
+// Statistical analysis tools
 
-        XmlWriter& writeComment( std::string const& text );
 
-        void writeStylesheetRef( std::string const& url );
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
 
-        XmlWriter& writeBlankLine();
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
 
-        void ensureTagClosed();
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
 
-    private:
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
 
-        void writeDeclaration();
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
 
-        void newlineIfNecessary();
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
 
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
 
-}
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
 
-// end catch_xmlwriter.h
-namespace Catch {
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
 
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
 
-        ~JunitReporter() override;
+                return results;
+            }
 
-        static std::string getDescription();
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
 
-        void noMatchingTestCases(std::string const& /*spec*/) override;
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = std::max(cumn(a1), 0);
+                auto hi = std::min(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
 
-        void testRunStarting(TestRunInfo const& runInfo) override;
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
 
-        void testGroupStarting(GroupInfo const& groupInfo) override;
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
 
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
 
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
 
-        void testRunEndedCumulative() override;
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
 
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
 
-        void writeTestCase(TestCaseNode const& testCaseNode);
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
 
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
 
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
+ // Run and analyse one benchmark
 
-} // end namespace Catch
 
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
+// start catch_sample_analysis.hpp
 
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
+// Benchmark results
 
-        ~XmlReporter() override;
 
-        static std::string getDescription();
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
 
-        virtual std::string getStylesheetRef() const;
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
 
-    public: // StreamingReporterBase
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        void noMatchingTestCases(std::string const& s) override;
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
 
-        void testRunStarting(TestRunInfo const& testInfo) override;
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(Detail::warmup_time));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time), Detail::warmup_iterations };
+            }
 
-        void testGroupStarting(GroupInfo const& groupInfo) override;
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
 
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
+                auto env = Detail::measure_environment<Clock>();
 
-        void sectionStarting(SectionInfo const& sectionInfo) override;
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
 
-        void assertionStarting(AssertionInfo const&) override;
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
 
-        bool assertionEnded(AssertionStats const& assertionStats) override;
+                    getResultCapture().benchmarkStarting(info);
 
-        void sectionEnded(SectionStats const& sectionStats) override;
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
 
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<std::chrono::duration<double, std::nano>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
 
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
 
-        void testRunEnded(TestRunStats const& testRunStats) override;
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
 
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
+            explicit operator bool() {
+                return true;
+            }
 
-} // end namespace Catch
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
 
-// end catch_reporter_xml.h
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
 
-// end catch_external_interfaces.h
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+// end catch_benchmark.hpp
 #endif
 
 #endif // ! CATCH_CONFIG_IMPL_ONLY
@@ -5189,7 +7146,7 @@ namespace TestCaseTracking {
 
         // Debug/ checking
         virtual bool isSectionTracker() const = 0;
-        virtual bool isIndexTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
     };
 
     class TrackerContext {
@@ -5206,8 +7163,6 @@ namespace TestCaseTracking {
 
     public:
 
-        static TrackerContext& instance();
-
         ITracker& startRun();
         void endRun();
 
@@ -5254,7 +7209,7 @@ namespace TestCaseTracking {
         void openChild() override;
 
         bool isSectionTracker() const override;
-        bool isIndexTracker() const override;
+        bool isGeneratorTracker() const override;
 
         void open();
 
@@ -5274,6 +7229,8 @@ namespace TestCaseTracking {
 
         bool isSectionTracker() const override;
 
+        bool isComplete() const override;
+
         static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
 
         void tryOpen();
@@ -5282,28 +7239,11 @@ namespace TestCaseTracking {
         void addNextFilters( std::vector<std::string> const& filters );
     };
 
-    class IndexTracker : public TrackerBase {
-        int m_size;
-        int m_index = -1;
-    public:
-        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size );
-
-        bool isIndexTracker() const override;
-        void close() override;
-
-        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size );
-
-        int index() const;
-
-        void moveNext();
-    };
-
 } // namespace TestCaseTracking
 
 using TestCaseTracking::ITracker;
 using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
 
 } // namespace Catch
 
@@ -5321,6 +7261,216 @@ namespace Catch {
 }
 // end catch_leak_detector.h
 // Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
 // start catch_approx.cpp
 
 #include <cmath>
@@ -5368,18 +7518,18 @@ namespace Detail {
         return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
     }
 
-    void Approx::setMargin(double margin) {
-        CATCH_ENFORCE(margin >= 0,
-            "Invalid Approx::margin: " << margin << '.'
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
             << " Approx::Margin has to be non-negative.");
-        m_margin = margin;
+        m_margin = newMargin;
     }
 
-    void Approx::setEpsilon(double epsilon) {
-        CATCH_ENFORCE(epsilon >= 0 && epsilon <= 1.0,
-            "Invalid Approx::epsilon: " << epsilon << '.'
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
             << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = epsilon;
+        m_epsilon = newEpsilon;
     }
 
 } // end namespace Detail
@@ -5388,71 +7538,19 @@ namespace literals {
     Detail::Approx operator "" _a(long double val) {
         return Detail::Approx(val);
     }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
-
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
     }
+} // end namespace literals
 
-    void cleanUpContext();
+std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+    return value.toString();
 }
 
-// end catch_context.h
+} // end namespace Catch
+// end catch_approx.cpp
+// start catch_assertionhandler.cpp
+
 // start catch_debugger.h
 
 namespace Catch {
@@ -5482,12 +7580,9 @@ namespace Catch {
 #endif
 
 #ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
+    #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
 #else
-    namespace Catch {
-        inline void doNothing() {}
-    }
-    #define CATCH_BREAK_INTO_DEBUGGER() Catch::doNothing()
+    #define CATCH_BREAK_INTO_DEBUGGER() []{}()
 #endif
 
 // end catch_debugger.h
@@ -5636,12 +7731,18 @@ namespace Catch {
 
         auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
         void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats const& stats ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
         void pushScopedMessage( MessageInfo const& message ) override;
         void popScopedMessage( MessageInfo const& message ) override;
 
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
         std::string getCurrentTestName() const override;
 
         const AssertionResult* getLastResult() const override;
@@ -5682,13 +7783,14 @@ namespace Catch {
         TestRunInfo m_runInfo;
         IMutableContext& m_context;
         TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker;
+        ITracker* m_testCaseTracker = nullptr;
         Option<AssertionResult> m_lastResult;
 
         IConfigPtr m_config;
         Totals m_totals;
         IStreamingReporterPtr m_reporter;
         std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
         AssertionInfo m_lastAssertionInfo;
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
@@ -5896,32 +7998,6 @@ namespace Catch {
 
 } // end namespace Catch
 // end catch_assertionresult.cpp
-// start catch_benchmark.cpp
-
-namespace Catch {
-
-    auto BenchmarkLooper::getResolution() -> uint64_t {
-        return getEstimatedClockResolution() * getCurrentContext().getConfig()->benchmarkResolutionMultiple();
-    }
-
-    void BenchmarkLooper::reportStart() {
-        getResultCapture().benchmarkStarting( { m_name } );
-    }
-    auto BenchmarkLooper::needsMoreIterations() -> bool {
-        auto elapsed = m_timer.getElapsedNanoseconds();
-
-        // Exponentially increasing iterations until we're confident in our timer resolution
-        if( elapsed < m_resolution ) {
-            m_iterationsToRun *= 10;
-            return true;
-        }
-
-        getResultCapture().benchmarkEnded( { { m_name }, m_count, elapsed } );
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_benchmark.cpp
 // start catch_capture_matchers.cpp
 
 namespace Catch {
@@ -6067,6 +8143,9 @@ class Column {
 			m_suffix = false;
 			auto width = m_column.m_width - indent();
 			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
 			while (m_end < line().size() && line()[m_end] != '\n')
 				++m_end;
 
@@ -6325,6 +8404,7 @@ inline auto Column::operator + (Column const& other) -> Columns {
 // ----------- end of #include from clara_textflow.hpp -----------
 // ........... back in clara.hpp
 
+#include <cctype>
 #include <string>
 #include <memory>
 #include <set>
@@ -6617,7 +8697,7 @@ namespace detail {
     }
     inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
         std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
         if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
             target = true;
         else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
@@ -7412,11 +9492,19 @@ namespace Catch {
             | Opt( setWaitForKeypress, "start|exit|both" )
                 ["--wait-for-keypress"]
                 ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkResolutionMultiple, "multiplier" )
-                ["--benchmark-resolution-multiple"]
-                ( "multiple of clock resolution to run benchmarks" )
-
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+			| Arg( config.testsOrTags, "test name|pattern|tags" )
                 ( "which test or tests to use" );
 
         return cli;
@@ -7470,10 +9558,7 @@ namespace Catch {
         m_stream( openStream() )
     {
         TestSpecParser parser(ITagAliasRegistry::get());
-        if (data.testsOrTags.empty()) {
-            parser.parse("~[.]"); // All not hidden tests
-        }
-        else {
+        if (!data.testsOrTags.empty()) {
             m_hasTestFilters = true;
             for( auto const& testOrTags : data.testsOrTags )
                 parser.parse( testOrTags );
@@ -7511,13 +9596,17 @@ namespace Catch {
     ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
     RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
     unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    int Config::benchmarkResolutionMultiple() const    { return m_data.benchmarkResolutionMultiple; }
     UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
     bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
     int Config::abortAfter() const                     { return m_data.abortAfter; }
     bool Config::showInvisibles() const                { return m_data.showInvisibles; }
     Verbosity Config::verbosity() const                { return m_data.verbosity; }
 
+    bool Config::benchmarkNoAnalysis() const           { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const               { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const    { return m_data.benchmarkResamples; }
+
     IStream const* Config::openStream() {
         return Catch::makeStream(m_data.outputFilename);
     }
@@ -7591,7 +9680,7 @@ namespace {
             originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
         }
 
-        virtual void use( Colour::Code _colourCode ) override {
+        void use( Colour::Code _colourCode ) override {
             switch( _colourCode ) {
                 case Colour::None:      return setTextAttribute( originalForegroundAttributes );
                 case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
@@ -7654,7 +9743,7 @@ namespace {
     // https://github.com/philsquared/Catch/pull/131
     class PosixColourImpl : public IColourImpl {
     public:
-        virtual void use( Colour::Code _colourCode ) override {
+        void use( Colour::Code _colourCode ) override {
             switch( _colourCode ) {
                 case Colour::None:
                 case Colour::White:     return setColour( "[0m" );
@@ -7682,7 +9771,8 @@ namespace {
 
     private:
         void setColour( const char* _escapeCode ) {
-            Catch::cout() << '\033' << _escapeCode;
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
         }
     };
 
@@ -7743,7 +9833,13 @@ namespace Catch {
 
     void Colour::use( Code _colourCode ) {
         static IColourImpl* impl = platformColourInstance();
-        impl->use( _colourCode );
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != NULL) {
+            impl->use( _colourCode );
+        }
     }
 
     std::ostream& operator << ( std::ostream& os, Colour const& ) {
@@ -7764,27 +9860,27 @@ namespace Catch {
     class Context : public IMutableContext, NonCopyable {
 
     public: // IContext
-        virtual IResultCapture* getResultCapture() override {
+        IResultCapture* getResultCapture() override {
             return m_resultCapture;
         }
-        virtual IRunner* getRunner() override {
+        IRunner* getRunner() override {
             return m_runner;
         }
 
-        virtual IConfigPtr const& getConfig() const override {
+        IConfigPtr const& getConfig() const override {
             return m_config;
         }
 
-        virtual ~Context() override;
+        ~Context() override;
 
     public: // IMutableContext
-        virtual void setResultCapture( IResultCapture* resultCapture ) override {
+        void setResultCapture( IResultCapture* resultCapture ) override {
             m_resultCapture = resultCapture;
         }
-        virtual void setRunner( IRunner* runner ) override {
+        void setRunner( IRunner* runner ) override {
             m_runner = runner;
         }
-        virtual void setConfig( IConfigPtr const& config ) override {
+        void setConfig( IConfigPtr const& config ) override {
             m_config = config;
         }
 
@@ -7850,19 +9946,23 @@ namespace Catch {
 #  include <stdbool.h>
 #  include <sys/types.h>
 #  include <unistd.h>
-#  include <sys/sysctl.h>
 #  include <cstddef>
 #  include <ostream>
 
-namespace Catch {
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
 
+    namespace Catch {
+        #ifdef __apple_build_version__
         // The following function is taken directly from the following technical note:
-        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
 
         // Returns true if the current process is being debugged (either
         // running under the debugger or has a debugger attached post facto).
         bool isDebuggerActive(){
-
             int                 mib[4];
             struct kinfo_proc   info;
             std::size_t         size;
@@ -7892,6 +9992,12 @@ namespace Catch {
 
             return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
         }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
     } // namespace Catch
 
 #elif defined(CATCH_PLATFORM_LINUX)
@@ -7962,6 +10068,8 @@ namespace Catch {
 // end catch_decomposer.cpp
 // start catch_enforce.cpp
 
+#include <stdexcept>
+
 namespace Catch {
 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
     [[noreturn]]
@@ -7971,8 +10079,106 @@ namespace Catch {
         std::terminate();
     }
 #endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
 } // namespace Catch;
 // end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<std::string> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        std::vector<std::string> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<std::string> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                auto identifiers = splitStringRef( enumValue, ':' );
+                parsed.push_back( Catch::trim( identifiers.back() ) );
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}";
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.push_back({ value, valueNames[i++] });
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            auto enumInfo = makeEnumInfo( enumName, allValueNames, values );
+            EnumInfo* raw = enumInfo.get();
+            m_enumInfos.push_back( std::move( enumInfo ) );
+            return *raw;
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
 // start catch_errno_guard.cpp
 
 #include <cerrno>
@@ -7996,7 +10202,7 @@ namespace Catch {
     public:
         ~ExceptionTranslatorRegistry();
         virtual void registerTranslator( const IExceptionTranslator* translator );
-        virtual std::string translateActiveException() const override;
+        std::string translateActiveException() const override;
         std::string tryTranslators() const;
 
     private:
@@ -8061,18 +10267,24 @@ namespace Catch {
         }
     }
 
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        if (m_translators.empty()) {
+            std::rethrow_exception(std::current_exception());
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
 #else // ^^ Exceptions are enabled // Exceptions are disabled vv
     std::string ExceptionTranslatorRegistry::translateActiveException() const {
         CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
     }
-#endif
 
     std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if( m_translators.empty() )
-            std::rethrow_exception(std::current_exception());
-        else
-            return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
     }
+#endif
+
 }
 // end catch_exception_translator_registry.cpp
 // start catch_fatal_condition.cpp
@@ -8102,10 +10314,10 @@ namespace Catch {
     // Windows can easily distinguish between SO and SigSegV,
     // but SigInt, SigTerm, etc are handled differently.
     static SignalDefs signalDefs[] = {
-        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
-        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
-        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
-        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
     };
 
     LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
@@ -8261,36 +10473,18 @@ namespace Catch {
 
 IGeneratorTracker::~IGeneratorTracker() {}
 
-namespace Generators {
-
-    GeneratorBase::~GeneratorBase() {}
-
-    std::vector<size_t> randomiseIndices( size_t selectionSize, size_t sourceSize ) {
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
 
-        assert( selectionSize <= sourceSize );
-        std::vector<size_t> indices;
-        indices.reserve( selectionSize );
-        std::uniform_int_distribution<size_t> uid( 0, sourceSize-1 );
+namespace Generators {
 
-        std::set<size_t> seen;
-        // !TBD: improve this algorithm
-        while( indices.size() < selectionSize ) {
-            auto index = uid( rng() );
-            if( seen.insert( index ).second )
-                indices.push_back( index );
-        }
-        return indices;
-    }
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
 
     auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
         return getResultCapture().acquireGeneratorTracker( lineInfo );
     }
 
-    template<>
-    auto all<int>() -> Generator<int> {
-        return range( std::numeric_limits<int>::min(), std::numeric_limits<int>::max() );
-    }
-
 } // namespace Generators
 } // namespace Catch
 // end catch_generators.cpp
@@ -8346,8 +10540,12 @@ namespace Catch {
 
         static std::set<Verbosity> getSupportedVerbosities();
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
         void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats const& benchmarkStats ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
         void testRunStarting( TestRunInfo const& testRunInfo ) override;
         void testGroupStarting( GroupInfo const& groupInfo ) override;
@@ -8538,7 +10736,7 @@ namespace Catch {
 
     std::size_t listReporters();
 
-    Option<std::size_t> list( Config const& config );
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
 
 } // end namespace Catch
 
@@ -8676,15 +10874,16 @@ namespace Catch {
         return factories.size();
     }
 
-    Option<std::size_t> list( Config const& config ) {
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
         Option<std::size_t> listedCount;
-        if( config.listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( config );
-        if( config.listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
-        if( config.listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( config );
-        if( config.listReporters() )
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
             listedCount = listedCount.valueOr(0) + listReporters();
         return listedCount;
     }
@@ -8744,6 +10943,9 @@ namespace Catch {
 #include <cstdlib>
 #include <cstdint>
 #include <cstring>
+#include <sstream>
+#include <iomanip>
+#include <limits>
 
 namespace Catch {
 namespace Matchers {
@@ -8804,8 +11006,16 @@ bool almostEqualUlps(FP lhs, FP rhs, int maxUlpDiff) {
     return ulpDiff <= maxUlpDiff;
 }
 
+template <typename FP>
+FP step(FP start, FP direction, int steps) {
+    for (int i = 0; i < steps; ++i) {
+        start = std::nextafter(start, direction);
+    }
+    return start;
 }
 
+} // end anonymous namespace
+
 namespace Catch {
 namespace Matchers {
 namespace Floating {
@@ -8853,7 +11063,29 @@ namespace Floating {
 #endif
 
     std::string WithinUlpsMatcher::describe() const {
-        return "is within " + Catch::to_string(m_ulps) + " ULPs of " + ::Catch::Detail::stringify(m_target) + ((m_type == FloatingPointKind::Float)? "f" : "");
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of " << ::Catch::Detail::stringify(m_target);
+
+        if (m_type == FloatingPointKind::Float) {
+            ret << 'f';
+        }
+
+        ret << " ([";
+        ret << std::fixed << std::setprecision(std::numeric_limits<double>::max_digits10);
+        if (m_type == FloatingPointKind::Double) {
+            ret << step(m_target, static_cast<double>(-INFINITY), m_ulps)
+                << ", "
+                << step(m_target, static_cast<double>(INFINITY), m_ulps);
+        } else {
+            ret << step<float>(static_cast<float>(m_target), -INFINITY, m_ulps)
+                << ", "
+                << step<float>(static_cast<float>(m_target), INFINITY, m_ulps);
+        }
+        ret << "])";
+
+        return ret.str();
+        //return "is within " + Catch::to_string(m_ulps) + " ULPs of " + ::Catch::Detail::stringify(m_target) + ((m_type == FloatingPointKind::Float)? "f" : "");
     }
 
 }// namespace Floating
@@ -9030,14 +11262,20 @@ namespace Catch {
     ////////////////////////////////////////////////////////////////////////////
 
     ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info )
+    : m_info( builder.m_info ), m_moved()
     {
         m_info.message = builder.m_stream.str();
         getResultCapture().pushScopedMessage( m_info );
     }
 
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
+    }
+
     ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() ){
+        if ( !uncaught_exceptions() && !m_moved ){
             getResultCapture().popScopedMessage(m_info);
         }
     }
@@ -9052,6 +11290,15 @@ namespace Catch {
             }
             return names.substr(start, end - start + 1);
         };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
 
         size_t start = 0;
         std::stack<char> openings;
@@ -9072,6 +11319,10 @@ namespace Catch {
 //           case '>':
                 openings.pop();
                 break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
             case ',':
                 if (start != pos && openings.size() == 0) {
                     m_messages.emplace_back(macroName, lineInfo, resultType);
@@ -9145,6 +11396,22 @@ namespace Catch {
         auto str() const -> std::string;
     };
 
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
 #if defined(CATCH_CONFIG_NEW_CAPTURE)
 
     // Windows's implementation of std::tmpfile is terrible (it tries
@@ -9236,6 +11503,16 @@ namespace Catch {
     {}
     auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
 
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
 #if defined(CATCH_CONFIG_NEW_CAPTURE)
 
 #if defined(_MSC_VER)
@@ -9248,7 +11525,7 @@ namespace Catch {
             if (strerror_s(buffer, errno)) {
                 CATCH_RUNTIME_ERROR("Could not translate errno to a string");
             }
-            CATCH_RUNTIME_ERROR("Coul dnot open the temp file: '" << m_buffer << "' because: " << buffer);
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
         }
     }
 #else
@@ -9584,6 +11861,9 @@ namespace Catch {
             void registerStartupException() noexcept override {
                 m_exceptionRegistry.add(std::current_exception());
             }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
 
         private:
             TestRegistry m_testCaseRegistry;
@@ -9591,6 +11871,7 @@ namespace Catch {
             ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
             TagAliasRegistry m_tagAliasRegistry;
             StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
         };
     }
 
@@ -9671,7 +11952,6 @@ namespace Catch {
 
     namespace Generators {
         struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            size_t m_index = static_cast<size_t>( -1 );
             GeneratorBasePtr m_generator;
 
             GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
@@ -9685,7 +11965,7 @@ namespace Catch {
                 ITracker& currentTracker = ctx.currentTracker();
                 if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
                     assert( childTracker );
-                    assert( childTracker->isIndexTracker() );
+                    assert( childTracker->isGeneratorTracker() );
                     tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
                 }
                 else {
@@ -9694,28 +11974,24 @@ namespace Catch {
                 }
 
                 if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
-                        tracker->moveNext();
                     tracker->open();
                 }
 
                 return *tracker;
             }
 
-            void moveNext() {
-                m_index++;
-                m_children.clear();
-            }
-
             // TrackerBase interface
-            bool isIndexTracker() const override { return true; }
+            bool isGeneratorTracker() const override { return true; }
             auto hasGenerator() const -> bool override {
                 return !!m_generator;
             }
             void close() override {
                 TrackerBase::close();
-                if( m_runState == CompletedSuccessfully && m_index < m_generator->size()-1 )
+                // Generator interface only finds out if it has another item on atual move
+                if (m_runState == CompletedSuccessfully && m_generator->next()) {
+                    m_children.clear();
                     m_runState = Executing;
+                }
             }
 
             // IGeneratorTracker interface
@@ -9725,9 +12001,6 @@ namespace Catch {
             void setGenerator( GeneratorBasePtr&& generator ) override {
                 m_generator = std::move( generator );
             }
-            auto getIndex() const -> size_t override {
-                return m_index;
-            }
         };
         GeneratorTracker::~GeneratorTracker() {}
     }
@@ -9825,6 +12098,9 @@ namespace Catch {
         // and should be let to clear themselves out.
         static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
 
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
         // Reset working state
         resetAssertionInfo();
         m_lastResult = result;
@@ -9879,6 +12155,7 @@ namespace Catch {
 
         m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
         m_messages.clear();
+        m_messageScopes.clear();
     }
 
     void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
@@ -9890,12 +12167,21 @@ namespace Catch {
 
         m_unfinishedSections.push_back(endInfo);
     }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+		m_reporter->benchmarkPreparing(name);
+	}
     void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
         m_reporter->benchmarkStarting( info );
     }
-    void RunContext::benchmarkEnded( BenchmarkStats const& stats ) {
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
         m_reporter->benchmarkEnded( stats );
     }
+	void RunContext::benchmarkFailed(std::string const & error) {
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
     void RunContext::pushScopedMessage(MessageInfo const & message) {
         m_messages.push_back(message);
@@ -9905,6 +12191,10 @@ namespace Catch {
         m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
     }
 
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
     std::string RunContext::getCurrentTestName() const {
         return m_activeTestCase
             ? m_activeTestCase->getTestCaseInfo().name
@@ -9965,6 +12255,7 @@ namespace Catch {
         m_lastAssertionPassed = true;
         ++m_totals.assertions.passed;
         resetAssertionInfo();
+        m_messageScopes.clear();
     }
 
     bool RunContext::aborting() const {
@@ -9986,13 +12277,10 @@ namespace Catch {
         CATCH_TRY {
             if (m_reporter->getPreferences().shouldRedirectStdOut) {
 #if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStdOut redirectedStdOut;
-                RedirectedStdErr redirectedStdErr;
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
 
                 timer.start();
                 invokeActiveTestCase();
-                redirectedCout += redirectedStdOut.str();
-                redirectedCerr += redirectedStdErr.str();
 #else
                 OutputRedirect r(redirectedCout, redirectedCerr);
                 timer.start();
@@ -10019,6 +12307,7 @@ namespace Catch {
         m_testCaseTracker->close();
         handleUnfinishedSections();
         m_messages.clear();
+        m_messageScopes.clear();
 
         SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
         m_reporter->sectionEnded(testCaseSectionStats);
@@ -10299,14 +12588,19 @@ namespace Catch {
                 return createReporter(config->getReporterName(), config);
             }
 
-            auto multi = std::unique_ptr<ListeningReporter>(new ListeningReporter);
-
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
             auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
             for (auto const& listener : listeners) {
-                multi->addListener(listener->create(Catch::ReporterConfig(config)));
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
             }
-            multi->addReporter(createReporter(config->getReporterName(), config));
-            return std::move(multi);
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
         }
 
         Catch::Totals runTests(std::shared_ptr<Config> const& config) {
@@ -10322,7 +12616,10 @@ namespace Catch {
 
             auto const& allTestCases = getAllTestCasesSorted(*config);
             for (auto const& testCase : allTestCases) {
-                if (!context.aborting() && matchTest(testCase, testSpec, *config))
+                bool matching = (!testSpec.hasFilters() && !testCase.isHidden()) ||
+                                 (testSpec.hasFilters() && matchTest(testCase, testSpec, *config));
+
+                if (!context.aborting() && matching)
                     totals += context.runTest(testCase);
                 else
                     context.reporter().skipTest(testCase);
@@ -10381,6 +12678,9 @@ namespace Catch {
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
         const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
         if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+
             m_startupExceptions = true;
             Colour colourGuard( Colour::Red );
             Catch::cerr() << "Errors occurred during startup!" << '\n';
@@ -10422,6 +12722,8 @@ namespace Catch {
 
         auto result = m_cli.parse( clara::Args( argc, argv ) );
         if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
             Catch::cerr()
                 << Colour( Colour::Red )
                 << "\nError(s) in input:\n"
@@ -10513,7 +12815,7 @@ namespace Catch {
                 applyFilenamesAsTags( *m_config );
 
             // Handle list request
-            if( Option<std::size_t> listed = list( config() ) )
+            if( Option<std::size_t> listed = list( m_config ) )
                 return static_cast<int>( *listed );
 
             auto totals = runTests( m_config );
@@ -10593,7 +12895,7 @@ namespace Catch {
 
     Catch::IStream::~IStream() = default;
 
-    namespace detail { namespace {
+    namespace Detail { namespace {
         template<typename WriterF, std::size_t bufferSize=256>
         class StreamBufImpl : public std::streambuf {
             char data[bufferSize];
@@ -10692,15 +12994,15 @@ namespace Catch {
 
     auto makeStream( StringRef const &filename ) -> IStream const* {
         if( filename.empty() )
-            return new detail::CoutStream();
+            return new Detail::CoutStream();
         else if( filename[0] == '%' ) {
             if( filename == "%debug" )
-                return new detail::DebugOutStream();
+                return new Detail::DebugOutStream();
             else
                 CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
         }
         else
-            return new detail::FileStream( filename );
+            return new Detail::FileStream( filename );
     }
 
     // This class encapsulates the idea of a pool of ostringstreams that can be reused.
@@ -10757,6 +13059,7 @@ namespace Catch {
 #include <ostream>
 #include <cstring>
 #include <cctype>
+#include <vector>
 
 namespace Catch {
 
@@ -10811,6 +13114,21 @@ namespace Catch {
         return replaced;
     }
 
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
     pluralise::pluralise( std::size_t count, std::string const& label )
     :   m_count( count ),
         m_label( label )
@@ -10858,9 +13176,11 @@ namespace Catch {
     }
 
     auto StringRef::c_str() const -> char const* {
-        if( isSubstring() )
-           const_cast<StringRef*>( this )->takeOwnership();
-        return m_start;
+        if( !isSubstring() )
+            return m_start;
+
+        const_cast<StringRef *>( this )->takeOwnership();
+        return m_data;
     }
     auto StringRef::currentData() const noexcept -> char const* {
         return m_start;
@@ -10878,7 +13198,6 @@ namespace Catch {
             m_data = new char[m_size+1];
             memcpy( m_data, m_start, m_size );
             m_data[m_size] = '\0';
-            m_start = m_data;
         }
     }
     auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
@@ -11046,7 +13365,7 @@ namespace Catch {
         void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
             CATCH_ENFORCE( !isReservedTag(tag),
                           "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alpha-numeric characters are reserved\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
                           << _lineInfo );
         }
     }
@@ -11078,6 +13397,12 @@ namespace Catch {
                     else if( prop == TestCaseInfo::None )
                         enforceNotReservedTag( tag, _lineInfo );
 
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
                     tags.push_back( tag );
                     tag.clear();
                     inTag = false;
@@ -11222,9 +13547,12 @@ namespace Catch {
     std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
         std::vector<TestCase> filtered;
         filtered.reserve( testCases.size() );
-        for( auto const& testCase : testCases )
-            if( matchTest( testCase, testSpec, config ) )
-                filtered.push_back( testCase );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
         return filtered;
     }
     std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
@@ -11300,11 +13628,6 @@ namespace TestCaseTracking {
 
     ITracker::~ITracker() = default;
 
-    TrackerContext& TrackerContext::instance() {
-        static TrackerContext s_instance;
-        return s_instance;
-    }
-
     ITracker& TrackerContext::startRun() {
         m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
         m_currentTracker = nullptr;
@@ -11387,7 +13710,7 @@ namespace TestCaseTracking {
     }
 
     bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isIndexTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
 
     void TrackerBase::open() {
         m_runState = Executing;
@@ -11456,6 +13779,17 @@ namespace TestCaseTracking {
         }
     }
 
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if ((m_filters.empty() || m_filters[0] == "") ||
+             std::find(m_filters.begin(), m_filters.end(),
+                       m_nameAndLocation.name) != m_filters.end())
+            complete = TrackerBase::isComplete();
+        return complete;
+
+    }
+
     bool SectionTracker::isSectionTracker() const { return true; }
 
     SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
@@ -11493,55 +13827,11 @@ namespace TestCaseTracking {
             m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
     }
 
-    IndexTracker::IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_size( size )
-    {}
-
-    bool IndexTracker::isIndexTracker() const { return true; }
-
-    IndexTracker& IndexTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
-        std::shared_ptr<IndexTracker> tracker;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isIndexTracker() );
-            tracker = std::static_pointer_cast<IndexTracker>( childTracker );
-        }
-        else {
-            tracker = std::make_shared<IndexTracker>( nameAndLocation, ctx, &currentTracker, size );
-            currentTracker.addChild( tracker );
-        }
-
-        if( !ctx.completedCycle() && !tracker->isComplete() ) {
-            if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
-                tracker->moveNext();
-            tracker->open();
-        }
-
-        return *tracker;
-    }
-
-    int IndexTracker::index() const { return m_index; }
-
-    void IndexTracker::moveNext() {
-        m_index++;
-        m_children.clear();
-    }
-
-    void IndexTracker::close() {
-        TrackerBase::close();
-        if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
-            m_runState = Executing;
-    }
-
 } // namespace TestCaseTracking
 
 using TestCaseTracking::ITracker;
 using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
 
 } // namespace Catch
 
@@ -11744,7 +14034,7 @@ namespace Catch {
                 // is terrible and we should move on.
                 // TBD: How to signal that the measured resolution is probably wrong?
                 if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / i;
+                    return sum / ( i + 1u );
                 }
             }
 
@@ -11997,11 +14287,16 @@ std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
     return "nullptr";
 }
 
+int StringMaker<float>::precision = 5;
+
 std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, 5) + 'f';
+    return fpToString(value, precision) + 'f';
 }
+
+int StringMaker<double>::precision = 10;
+
 std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, 10);
+    return fpToString(value, precision);
 }
 
 std::string ratio_string<std::atto>::symbol() { return "a"; }
@@ -12119,7 +14414,7 @@ namespace Catch {
     }
 
     Version const& libraryVersion() {
-        static Version version( 2, 5, 0, "", 0 );
+        static Version version( 2, 9, 1, "", 0 );
         return version;
     }
 
@@ -12203,9 +14498,11 @@ namespace {
     }
 
     void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
         os << "\\x"
             << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
             << static_cast<int>(c);
+        os.flags(f);
     }
 
 } // anonymous namespace
@@ -12469,11 +14766,26 @@ namespace Catch {
 #ifdef _MSC_VER
         sprintf_s(buffer, "%.3f", duration);
 #else
-        sprintf(buffer, "%.3f", duration);
+        std::sprintf(buffer, "%.3f", duration);
 #endif
         return std::string(buffer);
     }
 
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
+            else
+                first = false;
+
+            oss << filter;
+        }
+        return oss.str();
+    }
+
     TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
         :StreamingReporterBase(_config) {}
 
@@ -12779,8 +15091,13 @@ class AssertionPrinter {
 #if defined(_MSC_VER)
 #pragma warning(push)
 #pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled
- // and default is missing) is enabled
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
 namespace Catch {
@@ -12966,6 +15283,10 @@ class Duration {
     Unit m_units;
 
 public:
+	explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : Duration(static_cast<uint64_t>(inNanoseconds), units) {
+    }
+
     explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
         : m_inNanoseconds(inNanoseconds),
         m_units(units) {
@@ -13003,7 +15324,7 @@ class Duration {
         case Unit::Nanoseconds:
             return "ns";
         case Unit::Microseconds:
-            return "µs";
+            return "us";
         case Unit::Milliseconds:
             return "ms";
         case Unit::Seconds:
@@ -13041,9 +15362,15 @@ class TablePrinter {
         if (!m_isOpen) {
             m_isOpen = true;
             *this << RowBreak();
-            for (auto const& info : m_columnInfos)
-                *this << info.name << ColumnBreak();
-            *this << RowBreak();
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << "\n";
+
             m_os << Catch::getLineOfChars<'-'>() << "\n";
         }
     }
@@ -13098,9 +15425,9 @@ ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
     m_tablePrinter(new TablePrinter(config.stream(),
     {
         { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-        { "iters", 8, ColumnInfo::Right },
-        { "elapsed ns", 14, ColumnInfo::Right },
-        { "average", 14, ColumnInfo::Right }
+        { "samples      mean       std dev", 14, ColumnInfo::Right },
+        { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+        { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
     })) {}
 ConsoleReporter::~ConsoleReporter() = default;
 
@@ -13132,6 +15459,7 @@ bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
 }
 
 void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
     m_headerPrinted = false;
     StreamingReporterBase::sectionStarting(_sectionInfo);
 }
@@ -13155,28 +15483,45 @@ void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
     StreamingReporterBase::sectionEnded(_sectionStats);
 }
 
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    lazyPrintWithoutClosingBenchmarkTable();
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
 
-    auto nameCol = Column( info.name ).width( static_cast<std::size_t>( m_tablePrinter->columnInfos()[0].width - 2 ) );
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
 
-    bool firstLine = true;
-    for (auto line : nameCol) {
-        if (!firstLine)
-            (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-        else
-            firstLine = false;
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
 
-        (*m_tablePrinter) << line << ColumnBreak();
-    }
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
 }
-void ConsoleReporter::benchmarkEnded(BenchmarkStats const& stats) {
-    Duration average(stats.elapsedTimeInNanoseconds / stats.iterations);
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+	(*m_tablePrinter) << info.samples << ColumnBreak()
+		<< info.iterations << ColumnBreak()
+		<< Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+	(*m_tablePrinter) << ColumnBreak()
+		<< Duration(stats.mean.point.count()) << ColumnBreak()
+		<< Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+		<< Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+		<< Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+		<< Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+		<< Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+}
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
     (*m_tablePrinter)
-        << stats.iterations << ColumnBreak()
-        << stats.elapsedTimeInNanoseconds << ColumnBreak()
-        << average << ColumnBreak();
+        << "Benchmark failed (" << error << ")"
+        << ColumnBreak() << RowBreak();
 }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
     m_tablePrinter->close();
@@ -13198,6 +15543,10 @@ void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
     stream << std::endl;
     StreamingReporterBase::testRunEnded(_testRunStats);
 }
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
 
 void ConsoleReporter::lazyPrint() {
 
@@ -13379,6 +15728,11 @@ void ConsoleReporter::printSummaryDivider() {
     stream << getLineOfChars<'-'>() << '\n';
 }
 
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters())
+        stream << Colour(Colour::BrightYellow) << "Filters: " << serializeFilters( m_config->getTestsOrTags() ) << '\n';
+}
+
 CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 
 } // end namespace Catch
@@ -13386,6 +15740,10 @@ CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 #if defined(_MSC_VER)
 #pragma warning(pop)
 #endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
 // end catch_reporter_console.cpp
 // start catch_reporter_junit.cpp
 
@@ -13490,6 +15848,7 @@ namespace Catch {
 
     void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
         XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
         TestGroupStats const& stats = groupNode.value;
         xml.writeAttribute( "name", stats.groupInfo.name );
         xml.writeAttribute( "errors", unexpectedExceptions );
@@ -13502,6 +15861,21 @@ namespace Catch {
             xml.writeAttribute( "time", suiteTime );
         xml.writeAttribute( "timestamp", getCurrentTimestamp() );
 
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
         // Write test cases
         for( auto const& child : groupNode.children )
             writeTestCase( *child );
@@ -13659,19 +16033,34 @@ namespace Catch {
         m_reporter->noMatchingTestCases( spec );
     }
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
     void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
         for ( auto const& listener : m_listeners ) {
             listener->benchmarkStarting( benchmarkInfo );
         }
         m_reporter->benchmarkStarting( benchmarkInfo );
     }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats const& benchmarkStats ) {
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
         for ( auto const& listener : m_listeners ) {
             listener->benchmarkEnded( benchmarkStats );
         }
         m_reporter->benchmarkEnded( benchmarkStats );
     }
 
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
     void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
         for ( auto const& listener : m_listeners ) {
             listener->testRunStarting( testRunInfo );
@@ -13802,6 +16191,8 @@ namespace Catch {
         m_xml.startElement( "Catch" );
         if( !m_config->name().empty() )
             m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
         if( m_config->rngSeed() != 0 )
             m_xml.scopedElement( "Randomness" )
                 .writeAttribute( "seed", m_config->rngSeed() );
@@ -13963,6 +16354,48 @@ namespace Catch {
         m_xml.endElement();
     }
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", info.name)
+            .writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", static_cast<uint64_t>(info.clockResolution))
+            .writeAttribute("estimatedDuration", static_cast<uint64_t>(info.estimatedDuration))
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", static_cast<uint64_t>(benchmarkStats.mean.point.count()))
+            .writeAttribute("lowerBound", static_cast<uint64_t>(benchmarkStats.mean.lower_bound.count()))
+            .writeAttribute("upperBound", static_cast<uint64_t>(benchmarkStats.mean.upper_bound.count()))
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
     CATCH_REGISTER_REPORTER( "xml", XmlReporter )
 
 } // end namespace Catch
@@ -14036,7 +16469,7 @@ int main (int argc, char * const argv[]) {
 #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
 
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
 #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
@@ -14050,7 +16483,7 @@ int main (int argc, char * const argv[]) {
 #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
 
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", __VA_ARGS__ )
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
 #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
@@ -14065,6 +16498,7 @@ int main (int argc, char * const argv[]) {
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
 #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
 
@@ -14082,10 +16516,22 @@ int main (int argc, char * const argv[]) {
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
 #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
 #else
 #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
 #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
 #endif
 
 #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -14106,6 +16552,13 @@ int main (int argc, char * const argv[]) {
 #define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
 #define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
@@ -14141,6 +16594,7 @@ int main (int argc, char * const argv[]) {
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
 #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
 #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
 
@@ -14157,10 +16611,26 @@ int main (int argc, char * const argv[]) {
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
 #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #else
 #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
 #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
 #endif
 
 #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -14186,6 +16656,13 @@ int main (int argc, char * const argv[]) {
 #define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
 #define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
 using Catch::Detail::Approx;
 
 #else // CATCH_CONFIG_DISABLE
@@ -14225,9 +16702,10 @@ using Catch::Detail::Approx;
 #define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
-#define CATCH_INFO( msg )    (void)(0)
-#define CATCH_WARN( msg )    (void)(0)
-#define CATCH_CAPTURE( msg ) (void)(0)
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
 
 #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
@@ -14242,11 +16720,23 @@ using Catch::Detail::Approx;
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className )
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className ) )
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #endif
 
 // "BDD-style" convenience wrappers
@@ -14297,6 +16787,7 @@ using Catch::Detail::Approx;
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
 #define WARN( msg ) (void)(0)
 #define CAPTURE( msg ) (void)(0)
 
@@ -14312,11 +16803,23 @@ using Catch::Detail::Approx;
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className )
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className ) )
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #endif
 
 #define STATIC_REQUIRE( ... )       (void)(0)

From 9954a3a11e6419672e1b567efd7109b3c5e146ed Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Thu, 4 Jul 2019 16:54:57 +0200
Subject: [PATCH 02/38] Initial bits.

---
 include/rakau/tree.hpp | 21 ++++++++++++++
 test/CMakeLists.txt    |  1 +
 test/coll.cpp          | 64 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 86 insertions(+)
 create mode 100644 test/coll.cpp

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index bfe088e..e999697 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -535,6 +535,27 @@ inline constexpr unsigned default_ncrit =
     128
 #endif
     ;
+
+// Return a vector of indices into the input vector of nodes, t,
+// representing the ordered set of leaf nodes.
+template <typename Nodes>
+inline auto coll_leaves_permutation(const Nodes &t)
+{
+    using idx_t = typename Nodes::size_type;
+
+    // Prepare the output.
+    std::vector<idx_t> retval;
+    retval.reserve(static_cast<decltype(retval.size())>(t.size()));
+
+    for (idx_t i = 0; i < t.size(); ++i) {
+        if (!t[i].n_children) {
+            retval.push_back(i);
+        }
+    }
+
+    return retval;
+}
+
 } // namespace detail
 
 namespace kwargs
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 900b108..bcc7e3d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -28,6 +28,7 @@ ADD_RAKAU_TESTCASE(accuracy_acc_pot)
 ADD_RAKAU_TESTCASE(accuracy_pot)
 ADD_RAKAU_TESTCASE(auto_box_size)
 ADD_RAKAU_TESTCASE(basic)
+ADD_RAKAU_TESTCASE(coll)
 ADD_RAKAU_TESTCASE(g_constant_acc)
 ADD_RAKAU_TESTCASE(g_constant_acc_pot)
 ADD_RAKAU_TESTCASE(g_constant_pot)
diff --git a/test/coll.cpp b/test/coll.cpp
new file mode 100644
index 0000000..1e9b974
--- /dev/null
+++ b/test/coll.cpp
@@ -0,0 +1,64 @@
+// Copyright 2018 Francesco Biscani (bluescarni@gmail.com)
+//
+// This file is part of the rakau library.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <rakau/tree.hpp>
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include <algorithm>
+#include <numeric>
+// #include <array>
+// #include <initializer_list>
+#include <random>
+#include <tuple>
+// #include <type_traits>
+// #include <vector>
+
+#include <boost/iterator/permutation_iterator.hpp>
+// #include <boost/tuple/tuple.hpp>
+
+// #include <rakau/config.hpp>
+
+#include "test_utils.hpp"
+
+using namespace rakau;
+using namespace rakau::kwargs;
+using namespace rakau_test;
+
+std::mt19937 rng;
+
+TEST_CASE("coll_init_leaves")
+{
+    // Empty tree.
+    octree<double> t;
+    auto perm = detail::coll_leaves_permutation(t.nodes());
+    REQUIRE(perm.empty());
+
+    // Fill it in with some particles.
+    const auto bsize = 1.;
+    const auto s = 10000u;
+    auto parts = get_uniform_particles<3>(s, bsize, rng);
+    t = octree<double>{x_coords = parts.begin() + s,
+                       y_coords = parts.begin() + 2u * s,
+                       z_coords = parts.begin() + 3u * s,
+                       masses = parts.begin(),
+                       nparts = s,
+                       box_size = bsize};
+    perm = detail::coll_leaves_permutation(t.nodes());
+    auto p_begin = boost::make_permutation_iterator(t.nodes().begin(), perm.begin());
+    auto p_end = boost::make_permutation_iterator(t.nodes().end(), perm.end());
+    // Check the output is sorted.
+    auto node_sorter = [](const auto &n1, const auto &n2) { return detail::node_compare<3>(n1.code, n2.code); };
+    REQUIRE(std::is_sorted(p_begin, p_end, node_sorter));
+    // Check the output contains all particles.
+    REQUIRE(std::accumulate(p_begin, p_end, 0u,
+                            [](auto cur, const auto &n) { return cur + static_cast<unsigned>(n.end - n.begin); })
+            == s);
+    std::cout << std::distance(p_begin, p_end) << '\n';
+}
\ No newline at end of file

From 3a74e4bfac5fd545bf8b14357d7fb5c9732bd16f Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Fri, 5 Jul 2019 15:26:14 +0200
Subject: [PATCH 03/38] GCC 9 warning fixes.

---
 include/rakau/detail/di_aligned_allocator.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/rakau/detail/di_aligned_allocator.hpp b/include/rakau/detail/di_aligned_allocator.hpp
index 961e62b..d8e86f5 100644
--- a/include/rakau/detail/di_aligned_allocator.hpp
+++ b/include/rakau/detail/di_aligned_allocator.hpp
@@ -100,7 +100,7 @@ struct di_aligned_allocator {
     }
     // The construction function.
     template <typename U>
-    void construct(U *p) const
+    void construct(U *p) const noexcept(noexcept(::new (static_cast<void *>(p)) U))
     {
         // When no construction arguments are supplied, do default
         // initialisation rather than value initialisation.
@@ -108,6 +108,7 @@ struct di_aligned_allocator {
     }
     template <typename U, typename... Args>
     void construct(U *p, Args &&... args) const
+        noexcept(noexcept(::new (static_cast<void *>(p)) U(std::forward<Args>(args)...)))
     {
         // This is the standard std::allocator implementation.
         // http://en.cppreference.com/w/cpp/memory/allocator/construct

From a7b688317a9b5bb54cf7ffb2b75d81eec3de8d7d Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 12:36:00 +0200
Subject: [PATCH 04/38] Replace a couple of divisions with multiplications.

---
 include/rakau/tree.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index e999697..ba559ca 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -402,7 +402,7 @@ inline void get_node_centre(F (&out)[NDim], UInt node_code, F box_size)
     const auto c_code = static_cast<UInt>((node_code - (UInt(1) << (node_level * NDim)))
                                           << ((cbits_v<UInt, NDim> - node_level) * NDim));
     // Get the size/2 of the node.
-    const auto node_dim_2 = get_node_dim(node_level, box_size) / 2;
+    const auto node_dim_2 = get_node_dim(node_level, box_size) * (F(1) / F(2));
     // Get the size of the cell.
     const auto cell_size = box_size / static_cast<F>(UInt(1) << cbits_v<UInt, NDim>);
 
@@ -419,7 +419,7 @@ inline void get_node_centre(F (&out)[NDim], UInt node_code, F box_size)
     // - offset by -box_size/2 to refer everything to the centre of the box,
     // - add half of the node dimension to reach the centre of the node.
     for (std::size_t j = 0; j < NDim; ++j) {
-        out[j] = fma_wrap(static_cast<F>(d_code[j]), cell_size, node_dim_2 - box_size / 2);
+        out[j] = fma_wrap(static_cast<F>(d_code[j]), cell_size, node_dim_2 - box_size * (F(1) / F(2)));
     }
 }
 

From 76d2b0e261a384e4597de6bbe885e110f3aa14e7 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 12:48:19 +0200
Subject: [PATCH 05/38] More.

---
 include/rakau/tree.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index ba559ca..8e55070 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -404,7 +404,7 @@ inline void get_node_centre(F (&out)[NDim], UInt node_code, F box_size)
     // Get the size/2 of the node.
     const auto node_dim_2 = get_node_dim(node_level, box_size) * (F(1) / F(2));
     // Get the size of the cell.
-    const auto cell_size = box_size / static_cast<F>(UInt(1) << cbits_v<UInt, NDim>);
+    const auto cell_size = box_size * (F(1) / static_cast<F>(UInt(1) << cbits_v<UInt, NDim>));
 
     // Do the decoding. This will produce the discretized coordinates
     // of the first cell in the node.
@@ -1200,7 +1200,7 @@ class tree
             const auto x = m_parts[j][idx];
             // Translate and rescale the coordinate so that -box_size/2 becomes zero
             // and box_size/2 becomes 1.
-            auto tmp = x / m_box_size + F(.5);
+            auto tmp = x / m_box_size + F(1) / F(2);
             // Rescale by factor.
             tmp *= factor;
             // Check: don't end up with a nonfinite value.
@@ -1293,7 +1293,7 @@ class tree
         // Pick the max of the NDim coordinates, multiply by 2 to get the box size.
         auto retval = *std::max_element(mc.begin(), mc.end()) * F(2);
         // Add a 5% slack.
-        retval += retval / F(20);
+        retval += retval * (F(1) / F(20));
         // Final check.
         if (!std::isfinite(retval)) {
             throw std::invalid_argument("The automatic deduction of the domain size produced the non-finite value "
@@ -2878,7 +2878,8 @@ class tree
             const auto pad_coord = [this, mac_value]() {
                 if constexpr (MAC == mac::bh) {
                     // NOTE: for the bh mac, mac_value is theta**-2.
-                    const auto M = m_box_size / (std::sqrt(F(1) / mac_value) * std::sqrt(F(NDim))) + m_box_size / F(2);
+                    const auto M
+                        = m_box_size / (std::sqrt(F(1) / mac_value) * std::sqrt(F(NDim))) + m_box_size * (F(1) / F(2));
                     // NOTE: M is mathematically always >= m_box_size / F(2), which puts it on the top right
                     // corner of the box for theta2 == inf. To make it completely safe with respect to the requirement
                     // of avoiding singularities in the self interaction routine, we double it.

From 100b9c0408432379da15d6df8b955b415c7db486 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 12:57:39 +0200
Subject: [PATCH 06/38] Some initial collision-related code.

---
 include/rakau/tree.hpp | 103 +++++++++++++++++++++++++++++++++++++++++
 test/coll.cpp          |  92 ++++++++++++++++++++++++++++++++++--
 2 files changed, 191 insertions(+), 4 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 8e55070..da5549b 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -556,6 +556,109 @@ inline auto coll_leaves_permutation(const Nodes &t)
     return retval;
 }
 
+// Given a particle with position p_pos and a rectangular bounding box
+// whose edges have sizes aabb_sizes, return the list of
+// the vertices of the bounding box.
+// The coordinates of the returned
+// points will be clamped in the [min_coord, max_coord] range for
+// every dimension.
+template <typename F, std::size_t NDim>
+inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::array<F, NDim> &aabb_sizes,
+                                   const F &min_coord, const F &max_coord)
+{
+    // min/max coord must be finite.
+    assert(std::isfinite(min_coord) && std::isfinite(max_coord));
+    // min_coord < max_coord.
+    assert(min_coord < max_coord);
+    // p_pos must contain finite values in the [min_coord, max_coord] range.
+    assert(std::all_of(p_pos.begin(), p_pos.end(),
+                       [min_coord, max_coord](F x) { return std::isfinite(x) && x >= min_coord && x <= max_coord; }));
+    // aabb_sizes all finite and non-negative.
+    // NOTE: empty AABBs are allowed.
+    assert(std::all_of(aabb_sizes.begin(), aabb_sizes.end(), [](F x) { return std::isfinite(x) && x >= F(0); }));
+
+    // The number of vertices of the AABB is 2**NDim.
+    static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
+    constexpr auto n_points = std::size_t(1) << NDim;
+
+    // Compute the min/max coordinates of the AABB (in 2D, the lower-left
+    // and upper-right corners of the AABB).
+    // NOTE: these will *not* be clamped.
+    const auto aabb_minmax_coords = [&aabb_sizes, &p_pos]() {
+        std::array<std::array<F, NDim>, 2> retval;
+
+        for (std::size_t i = 0; i < NDim; ++i) {
+            const auto min_c = fma_wrap(aabb_sizes[i], -F(1) / F(2), p_pos[i]);
+            const auto max_c = fma_wrap(aabb_sizes[i], F(1) / F(2), p_pos[i]);
+
+            // Check them.
+            if (rakau_unlikely(!std::isfinite(min_c) || !std::isfinite(max_c) || min_c > max_c)) {
+                throw std::invalid_argument(
+                    "The computation of the min/max coordinates of an AABB produced the invalid pair of values ("
+                    + std::to_string(min_c) + ", " + std::to_string(max_c) + ")");
+            }
+
+            retval[0][i] = min_c;
+            retval[1][i] = max_c;
+        }
+
+        return retval;
+    }();
+
+    // The coordinates of all the points of the AABB.
+    std::array<std::array<F, NDim>, n_points> aabb_points;
+
+    // Fill in aabb_points. The idea here is that
+    // we need to generate all the 2**NDim possible combinations of min/max
+    // aabb coordinates. We do it via the bit-level representation
+    // of the numbers from 0 to 2**NDim - 1u. For instance, in 3 dimensions,
+    // we have the numbers from 0 to 7 included:
+    //
+    // 0 0 0 | i = 0
+    // 0 0 1 | i = 1
+    // 0 1 0 | i = 2
+    // 0 1 1 | i = 3
+    // ...
+    // 1 1 1 | i = 7
+    //
+    // We interpret a zero bit as setting the min aabb coordinate,
+    // a one bit as setting the max aabb coordinate. So, for instance,
+    // i = 3 corresponds to the aabb point (min, max, max).
+    for (std::size_t i = 0; i < n_points; ++i) {
+        for (std::size_t j = 0; j < NDim; ++j) {
+            const auto idx = (i >> j) & 1u;
+            // NOTE: we asserted that min_coord < max_coord, and that they
+            // are finite. Moreover, we also checked that aabb_minmax_coords[idx][j]
+            // is a finite value. Gonna assume that std::clamp() does not do anything weird
+            // FP-wise, so we don't check its output.
+            aabb_points[i][j] = std::clamp(aabb_minmax_coords[idx][j], min_coord, max_coord);
+        }
+    }
+
+    return aabb_points;
+
+    // // The [min, max] coordinates allowed for the aabb points.
+    // const auto min_coord = -b_size / 2;
+    // // NOTE: the domain size in a tree is understood to be a half-open range,
+    // // thus the maximum coordinate is not b_size / 2 but the number
+    // // immediately before it.
+    // const auto max_coord = std::nextafter(b_size / 2, F(-1));
+
+    // // Get the coordinates of the NDim * 2 points of the bounding box.
+    // std::array<std::array<std::array<F, NDim>, 2>, NDim> bb_points;
+    // for (std::size_t i = 0; i < NDim; ++i) {
+    //     // Size of the aabb in the i-th dimension.
+    //     const auto size = aabb[i];
+
+    //     // The
+    //     auto &bb_min = bb_points[i][0];
+    //     auto &bb_max = bb_points[i][1];
+
+    //     for (std::size_t j = 0; j < NDim; ++j) {
+    //     }
+    // }
+}
+
 } // namespace detail
 
 namespace kwargs
diff --git a/test/coll.cpp b/test/coll.cpp
index 1e9b974..87f1fda 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -12,9 +12,9 @@
 #include "catch.hpp"
 
 #include <algorithm>
+#include <array>
+#include <initializer_list>
 #include <numeric>
-// #include <array>
-// #include <initializer_list>
 #include <random>
 #include <tuple>
 // #include <type_traits>
@@ -33,7 +33,7 @@ using namespace rakau_test;
 
 std::mt19937 rng;
 
-TEST_CASE("coll_init_leaves")
+TEST_CASE("coll_leaves_permutation")
 {
     // Empty tree.
     octree<double> t;
@@ -60,5 +60,89 @@ TEST_CASE("coll_init_leaves")
     REQUIRE(std::accumulate(p_begin, p_end, 0u,
                             [](auto cur, const auto &n) { return cur + static_cast<unsigned>(n.end - n.begin); })
             == s);
-    std::cout << std::distance(p_begin, p_end) << '\n';
+}
+
+TEST_CASE("coll_get_aabb_vertices_2d")
+{
+    using v2d = std::array<double, 2>;
+
+    // Empty aabb.
+    v2d p_pos = {.5, .5};
+    v2d aabb_sizes = {0., 0.};
+
+    auto ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::all_of(ret.begin(), ret.end(), [p_pos](const auto &v) { return v == p_pos; }));
+
+    aabb_sizes = {.25, .25};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .375}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .625}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .625}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .375}) != ret.end());
+
+    aabb_sizes = {.25, .25 / 2};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .4375}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .5625}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .5625}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .4375}) != ret.end());
+
+    // Try a negative coord.
+    p_pos = {-.5, .5};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.625, .4375}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.375, .5625}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.625, .5625}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.375, .4375}) != ret.end());
+
+    // Clamping.
+    p_pos = {9., 9.};
+    aabb_sizes = {4., 4.};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 10.}) != ret.end());
+
+    p_pos = {9., -9.};
+    aabb_sizes = {4., 4.};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -10.}) != ret.end());
+
+    p_pos = {-9., 9.};
+    aabb_sizes = {4., 4.};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., 7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., 10.}) != ret.end());
+
+    p_pos = {-9., -9.};
+    aabb_sizes = {4., 4.};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -10.}) != ret.end());
+
+    // Clamp in all directions.
+    p_pos = {0., 0.};
+    aabb_sizes = {40., 40.};
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., 10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 10.}) != ret.end());
 }
\ No newline at end of file

From 6d183943e7c0f02c96c9a41f7fd331c44a2f14fb Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 12:58:28 +0200
Subject: [PATCH 07/38] clang-format fallout.

---
 include/rakau/tree.hpp | 44 ++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index da5549b..7370adb 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -1505,11 +1505,12 @@ class tree
                 }
             }
             // Generate the initial m_perm data (this is just a iota).
-            tbb::parallel_for(tbb::blocked_range(size_type(0), np, boost::numeric_cast<size_type>(data_chunking)),
-                              [this](const auto &range) {
-                                  std::iota(m_perm.data() + range.begin(), m_perm.data() + range.end(), range.begin());
-                              },
-                              tbb::simple_partitioner());
+            tbb::parallel_for(
+                tbb::blocked_range(size_type(0), np, boost::numeric_cast<size_type>(data_chunking)),
+                [this](const auto &range) {
+                    std::iota(m_perm.data() + range.begin(), m_perm.data() + range.end(), range.begin());
+                },
+                tbb::simple_partitioner());
         }
 
         // Deduce the box size, if needed.
@@ -1554,12 +1555,13 @@ class tree
             tg.run([this]() { perm_to_inv_perm(); });
             // Copy over m_perm to m_last_perm.
             tg.run([this, np]() {
-                tbb::parallel_for(tbb::blocked_range(size_type(0), np, boost::numeric_cast<size_type>(data_chunking)),
-                                  [this](const auto &range) {
-                                      std::copy(m_perm.data() + range.begin(), m_perm.data() + range.end(),
-                                                m_last_perm.data() + range.begin());
-                                  },
-                                  tbb::simple_partitioner());
+                tbb::parallel_for(
+                    tbb::blocked_range(size_type(0), np, boost::numeric_cast<size_type>(data_chunking)),
+                    [this](const auto &range) {
+                        std::copy(m_perm.data() + range.begin(), m_perm.data() + range.end(),
+                                  m_last_perm.data() + range.begin());
+                    },
+                    tbb::simple_partitioner());
             });
             tg.wait();
         }
@@ -3116,8 +3118,8 @@ class tree
 
         if constexpr ((NDim == 3u || NDim == 2u)
                       && std::conjunction_v<
-                             std::disjunction<std::is_same<UInt, std::uint64_t>, std::is_same<UInt, std::uint32_t>>,
-                             std::disjunction<std::is_same<F, float>, std::is_same<F, double>>>) {
+                          std::disjunction<std::is_same<UInt, std::uint64_t>, std::is_same<UInt, std::uint32_t>>,
+                          std::disjunction<std::is_same<F, float>, std::is_same<F, double>>>) {
             if (m_rocm && split.size() == 2u) {
                 // Actually run the ROCm implementation only if we have an accelerator and split contains 2 entries.
 
@@ -3222,8 +3224,8 @@ class tree
 
         if constexpr ((NDim == 3u || NDim == 2u)
                       && std::conjunction_v<
-                             std::disjunction<std::is_same<UInt, std::uint64_t>, std::is_same<UInt, std::uint32_t>>,
-                             std::disjunction<std::is_same<F, float>, std::is_same<F, double>>>) {
+                          std::disjunction<std::is_same<UInt, std::uint64_t>, std::is_same<UInt, std::uint32_t>>,
+                          std::disjunction<std::is_same<F, float>, std::is_same<F, double>>>) {
             if (split.size() > 1u) {
                 const auto np = nparts();
 
@@ -3735,12 +3737,12 @@ class tree
         });
 
         // Reset m_last_perm to a iota.
-        tbb::parallel_for(tbb::blocked_range(size_type(0), nparts, boost::numeric_cast<size_type>(data_chunking)),
-                          [this](const auto &range) {
-                              std::iota(m_last_perm.data() + range.begin(), m_last_perm.data() + range.end(),
-                                        range.begin());
-                          },
-                          tbb::simple_partitioner());
+        tbb::parallel_for(
+            tbb::blocked_range(size_type(0), nparts, boost::numeric_cast<size_type>(data_chunking)),
+            [this](const auto &range) {
+                std::iota(m_last_perm.data() + range.begin(), m_last_perm.data() + range.end(), range.begin());
+            },
+            tbb::simple_partitioner());
         // Do the indirect sorting onto m_last_perm.
         indirect_code_sort(m_last_perm.begin(), m_last_perm.end());
         {

From 75c4490bfb8b81212cbdfd10ea4fd11fcfc5668c Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 14:00:36 +0200
Subject: [PATCH 08/38] Minor.

---
 test/coll.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/coll.cpp b/test/coll.cpp
index 87f1fda..6413264 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -145,4 +145,4 @@ TEST_CASE("coll_get_aabb_vertices_2d")
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -10.}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -10.}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 10.}) != ret.end());
-}
\ No newline at end of file
+}

From 6a307f14e5396360446e6463374524a655ee3102 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 15:53:24 +0200
Subject: [PATCH 09/38] Another small bit.

---
 include/rakau/detail/tree_fwd.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/rakau/detail/tree_fwd.hpp b/include/rakau/detail/tree_fwd.hpp
index 8278548..c4dead5 100644
--- a/include/rakau/detail/tree_fwd.hpp
+++ b/include/rakau/detail/tree_fwd.hpp
@@ -141,7 +141,7 @@ inline constexpr std::size_t tree_nvecs_res = compute_tree_nvecs_res<Q, NDim>();
 template <typename UInt, std::size_t NDim>
 constexpr auto compute_cbits_v()
 {
-    constexpr unsigned nbits = std::numeric_limits<UInt>::digits;
+    constexpr auto nbits = static_cast<unsigned>(std::numeric_limits<UInt>::digits);
     static_assert(nbits > NDim, "The number of bits must be greater than the number of dimensions.");
     return static_cast<UInt>(nbits / NDim - !(nbits % NDim));
 }

From 3781e0178f275c33ba2efbb2b9adff23f6edafc4 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 15:53:33 +0200
Subject: [PATCH 10/38] More WIP code for collisions, yet to be tested.

---
 include/rakau/tree.hpp | 71 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 1838ade..53d9fd6 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -699,6 +699,77 @@ inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::
     // }
 }
 
+// Given:
+//
+// - a particle p_pos,
+// - the level of the leaf node in which the
+//   particle resides (llevel),
+// - a bounding box with sizes aabb_sizes,
+// - a domain size of 1/inv_box_size,
+//
+// compute the code of the smallest node not smaller than the leaf node
+// that contains the particle and its aabb (that is, the return
+// value will be the code of the leaf node or of one of its ancestors).
+// min_coord and max_coord can be inferred by inv_box_size, hence they are redundant,
+// but we pass them in to avoid re-computing them at every invocation.
+template <typename F, std::size_t NDim, typename UInt>
+inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt &llevel,
+                                    const std::array<F, NDim> &aabb_sizes, const F &min_coord, const F &max_coord,
+                                    const F &inv_box_size)
+{
+    // The number of vertices of the AABB is 2**NDim.
+    static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
+    constexpr auto n_points = std::size_t(1) << NDim;
+
+    // Get the list of vertices of the AABB.
+    const auto aabb_vertices = coll_get_aabb_vertices(p_pos, aabb_sizes, min_coord, max_coord);
+
+    // Compute their codes, and shift them down by (cbits - llevel) * NDim.
+    // We do this because we want to produce a nodal code
+    // whose level is llevel or lower, thus we already know we need
+    // to throw away some information from the lower bits of the AABB codes.
+    const auto shift_amount = (cbits_v<UInt, NDim> - llevel) * NDim;
+    std::array<UInt, n_points> aabb_codes;
+    std::array<UInt, NDim> tmp;
+    morton_encoder<NDim, UInt> me;
+    for (std::size_t i = 0; i < n_points; ++i) {
+        for (std::size_t j = 0; i < NDim; ++j) {
+            tmp[j] = disc_single_coord<NDim, UInt>(aabb_vertices[i][j], inv_box_size);
+        }
+        const auto code = me(tmp.data());
+        aabb_codes[i] = code >> shift_amount;
+    }
+
+    // Small helper to check if all codes in aabb_codes are equal.
+    auto check_equal_aabb_codes = [&aabb_codes]() {
+        const auto cmp = aabb_codes[0];
+        for (std::size_t i = 1; i < n_points; ++i) {
+            if (aabb_codes[i] != cmp) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    // The level of the output node. It will be
+    // llevel or lower.
+    auto out_level = llevel;
+
+    // Keep on shifting down the codes until they are all the same.
+    // In other words, establish the common prefix of all codes.
+    while (!check_equal_aabb_codes()) {
+        for (auto &c : aabb_codes) {
+            c >>= NDim;
+        }
+        assert(out_level > 0u);
+        --out_level;
+    }
+
+    // We have now the common prefix. Add a 1 bit on top
+    // to produce the nodal code and return it.
+    return aabb_codes[0] + (UInt(1) << (out_level * NDim));
+}
+
 } // namespace detail
 
 namespace kwargs

From 8633a30961d739cb0c504306494ed3074fc9c5ca Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 16:59:39 +0200
Subject: [PATCH 11/38] Fix, cleanup, some testing.

---
 include/rakau/tree.hpp |  6 +++--
 test/coll.cpp          | 53 ++++++++++++++++++++++++++++++++++++++----
 2 files changed, 52 insertions(+), 7 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index ef2ec8b..89ac230 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -733,7 +733,7 @@ inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt
     std::array<UInt, NDim> tmp;
     morton_encoder<NDim, UInt> me;
     for (std::size_t i = 0; i < n_points; ++i) {
-        for (std::size_t j = 0; i < NDim; ++j) {
+        for (std::size_t j = 0; j < NDim; ++j) {
             tmp[j] = disc_single_coord<NDim, UInt>(aabb_vertices[i][j], inv_box_size);
         }
         const auto code = me(tmp.data());
@@ -767,7 +767,9 @@ inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt
 
     // We have now the common prefix. Add a 1 bit on top
     // to produce the nodal code and return it.
-    return aabb_codes[0] + (UInt(1) << (out_level * NDim));
+    auto retval = aabb_codes[0] + (UInt(1) << (out_level * NDim));
+
+    return retval;
 }
 
 } // namespace detail
diff --git a/test/coll.cpp b/test/coll.cpp
index 6413264..645e658 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -13,17 +13,13 @@
 
 #include <algorithm>
 #include <array>
+#include <cstddef>
 #include <initializer_list>
 #include <numeric>
 #include <random>
 #include <tuple>
-// #include <type_traits>
-// #include <vector>
 
 #include <boost/iterator/permutation_iterator.hpp>
-// #include <boost/tuple/tuple.hpp>
-
-// #include <rakau/config.hpp>
 
 #include "test_utils.hpp"
 
@@ -146,3 +142,50 @@ TEST_CASE("coll_get_aabb_vertices_2d")
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -10.}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 10.}) != ret.end());
 }
+
+TEST_CASE("coll_get_enclosing_node_2d")
+{
+    using v2d = std::array<double, 2>;
+
+    // Particle at the origin, straddling all 4 children.
+    v2d pos{0., 0.};
+    v2d aabb_sizes{1., 1.};
+
+    auto ncode = detail::coll_get_enclosing_node(pos, std::size_t(0), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 1u);
+
+    // Move it only slightly, still straddling.
+    pos = {.1, .1};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 1u);
+
+    // Place it fully in all quadrants..
+    pos = {1., 1.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 7u);
+
+    pos = {-1., 1.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 6u);
+
+    pos = {-1., -1.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 4u);
+
+    // Straddle 2 quadrants.
+    pos = {1., 0.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 1u);
+
+    pos = {0., 1.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 1u);
+
+    pos = {-1., 0.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 1u);
+
+    pos = {0., -1.};
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    REQUIRE(ncode == 1u);
+}

From 3c622d0000f884a771faba71473fd6a5002b42a0 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 7 Jul 2019 17:22:13 +0200
Subject: [PATCH 12/38] Add some assertions in debug mode.

---
 include/rakau/tree.hpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 89ac230..1b45b68 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -769,6 +769,18 @@ inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt
     // to produce the nodal code and return it.
     auto retval = aabb_codes[0] + (UInt(1) << (out_level * NDim));
 
+#if !defined(NDEBUG)
+    // Check that the original particle code starts with
+    // aabb_codes[0] (the common prefix).
+    for (std::size_t i = 0; i < NDim; ++i) {
+        tmp[i] = disc_single_coord<NDim, UInt>(p_pos[i], inv_box_size);
+    }
+    auto orig_code = morton_encoder<NDim, UInt>{}(tmp.data());
+    // Shift it down the required number of levels.
+    orig_code >>= (cbits_v<UInt, NDim> - out_level) * NDim;
+    assert(orig_code == aabb_codes[0]);
+#endif
+
     return retval;
 }
 

From b9b5f264fd5c07abc6d3e1123d5a0d1a950580ee Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 9 Jul 2019 08:24:14 +0200
Subject: [PATCH 13/38] WIP progress.

---
 include/rakau/tree.hpp | 244 +++++++++++++++++++++++++++++++++++------
 test/coll.cpp          |  24 ++++
 2 files changed, 233 insertions(+), 35 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 1b45b68..38daf07 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -14,9 +14,6 @@
 #include <atomic>
 #include <bitset>
 #include <cassert>
-#if defined(RAKAU_WITH_TIMER)
-#include <chrono>
-#endif
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
@@ -33,14 +30,20 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
+#if defined(RAKAU_WITH_TIMER)
+#include <chrono>
+#endif
+
 #include <boost/iterator/permutation_iterator.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <tbb/blocked_range.h>
+#include <tbb/concurrent_unordered_set.h>
 #include <tbb/concurrent_vector.h>
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
@@ -371,7 +374,9 @@ struct morton_decoder<2, std::uint32_t> {
 };
 
 // Discretize a coordinate in a square domain of size 1/inv_box_size.
-template <std::size_t NDim, typename UInt, typename F>
+// If Clamp is true, then the coordinate will be clamped within
+// the domain.
+template <std::size_t NDim, typename UInt, bool Clamp = false, typename F>
 inline UInt disc_single_coord(const F &x, const F &inv_box_size)
 {
     constexpr UInt factor = UInt(1) << cbits_v<UInt, NDim>;
@@ -388,12 +393,18 @@ inline UInt disc_single_coord(const F &x, const F &inv_box_size)
                                     + " in a box of size " + std::to_string(F(1) / inv_box_size)
                                     + ", the non-finite value " + std::to_string(tmp) + " was generated");
     }
-    // Check: don't end up outside the [0, factor) range.
-    if (rakau_unlikely(tmp < F(0) || tmp >= F(factor))) {
-        throw std::invalid_argument("The discretisation of the input coordinate " + std::to_string(x)
-                                    + " in a box of size " + std::to_string(F(1) / inv_box_size)
-                                    + " produced the floating-point value " + std::to_string(tmp)
-                                    + ", which is outside the allowed bounds");
+
+    if constexpr (Clamp) {
+        // If requested, clamp the coordinate to [0, factor).
+        tmp = std::clamp(tmp, F(0), std::nextafter(F(factor), F(-1)));
+    } else {
+        // Check: don't end up outside the [0, factor) range.
+        if (rakau_unlikely(tmp < F(0) || tmp >= F(factor))) {
+            throw std::invalid_argument("The discretisation of the input coordinate " + std::to_string(x)
+                                        + " in a box of size " + std::to_string(F(1) / inv_box_size)
+                                        + " produced the floating-point value " + std::to_string(tmp)
+                                        + ", which is outside the allowed bounds");
+        }
     }
 
     // Cast to UInt.
@@ -578,6 +589,7 @@ inline constexpr unsigned default_ncrit =
 
 // Return a vector of indices into the input vector of nodes, t,
 // representing the ordered set of leaf nodes.
+// NOTE: need to understand if/when/how this should be parallelised.
 template <typename Nodes>
 inline auto coll_leaves_permutation(const Nodes &t)
 {
@@ -599,9 +611,6 @@ inline auto coll_leaves_permutation(const Nodes &t)
 // Given a particle with position p_pos and a rectangular bounding box
 // whose edges have sizes aabb_sizes, return the list of
 // the vertices of the bounding box.
-// The coordinates of the returned
-// points will be clamped in the [min_coord, max_coord] range for
-// every dimension.
 template <typename F, std::size_t NDim>
 inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::array<F, NDim> &aabb_sizes,
                                    const F &min_coord, const F &max_coord)
@@ -672,31 +681,11 @@ inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::
             // is a finite value. Gonna assume that std::clamp() does not do anything weird
             // FP-wise, so we don't check its output.
             aabb_points[i][j] = std::clamp(aabb_minmax_coords[idx][j], min_coord, max_coord);
+            assert(aabb_points[i][j] >= min_coord && aabb_points[i][j] <= max_coord);
         }
     }
 
     return aabb_points;
-
-    // // The [min, max] coordinates allowed for the aabb points.
-    // const auto min_coord = -b_size / 2;
-    // // NOTE: the domain size in a tree is understood to be a half-open range,
-    // // thus the maximum coordinate is not b_size / 2 but the number
-    // // immediately before it.
-    // const auto max_coord = std::nextafter(b_size / 2, F(-1));
-
-    // // Get the coordinates of the NDim * 2 points of the bounding box.
-    // std::array<std::array<std::array<F, NDim>, 2>, NDim> bb_points;
-    // for (std::size_t i = 0; i < NDim; ++i) {
-    //     // Size of the aabb in the i-th dimension.
-    //     const auto size = aabb[i];
-
-    //     // The
-    //     auto &bb_min = bb_points[i][0];
-    //     auto &bb_max = bb_points[i][1];
-
-    //     for (std::size_t j = 0; j < NDim; ++j) {
-    //     }
-    // }
 }
 
 // Given:
@@ -734,7 +723,13 @@ inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt
     morton_encoder<NDim, UInt> me;
     for (std::size_t i = 0; i < n_points; ++i) {
         for (std::size_t j = 0; j < NDim; ++j) {
-            tmp[j] = disc_single_coord<NDim, UInt>(aabb_vertices[i][j], inv_box_size);
+            // NOTE: set clamping to true. This is helpful because
+            // if the AABB is cropped by the boundary of the box,
+            // inside disc_single_coord we might end up generating
+            // a coordinate slightly outside box boundary, due to FP shenanigans.
+            // We know anyway that here the aabb_vertices have already been
+            // clamped to the box boundaries.
+            tmp[j] = disc_single_coord<NDim, UInt, true>(aabb_vertices[i][j], inv_box_size);
         }
         const auto code = me(tmp.data());
         aabb_codes[i] = code >> shift_amount;
@@ -3678,6 +3673,185 @@ class tree
     {
         accs_pots_o(acc_pot_ilist_to_array<2>(out), mac_value, std::forward<KwArgs>(args)...);
     }
+    template <typename It>
+    auto compute_clist(It it) const
+    {
+        simple_timer st("clist computation");
+
+        // TODO check the range of it.
+
+        tbb::task_group tg;
+
+        std::vector<tbb::concurrent_vector<size_type>> v_extra;
+        std::vector<tbb::concurrent_unordered_set<size_type>> c_list;
+        decltype(detail::coll_leaves_permutation(m_tree)) clp;
+
+        tg.run([this, &v_extra, &clp, it]() {
+            simple_timer st_vextra("vextra computation");
+
+            // Compute the permutation to iterate over the leaf nodes, and prepare
+            // the container of the extra particles for each leaf node.
+            clp = detail::coll_leaves_permutation(m_tree);
+            v_extra.resize(boost::numeric_cast<decltype(v_extra.size())>(clp.size()));
+
+            // TODO: check these against the assertions.
+            const auto inv_box_size = F(1) / m_box_size;
+            const auto min_coord = -m_box_size * (F(1) / F(2));
+            const auto max_coord = std::nextafter(m_box_size * (F(1) / F(2)), F(-1));
+
+            // Augment the leaf nodes with the extra particles.
+            tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()),
+                              [this, &clp, &v_extra, it, inv_box_size, min_coord, max_coord](const auto &r) {
+                                  // Temporary vector for the particle position
+                                  // and the sizes of the AABB.
+                                  std::array<F, NDim> tmp, aabb_sizes;
+                                  // A local map in which we will map indices
+                                  // to leaf nodes to extra particles for those nodes.
+                                  // We will add the contents of this map to v_extra
+                                  // at the end.
+                                  std::unordered_map<decltype(clp.size()), std::vector<size_type>> local_map;
+
+                                  for (auto i = r.begin(); i != r.end(); ++i) {
+                                      // Fetch/cache some properties of the leaf node.
+                                      const auto &lnode = m_tree[clp[i]];
+                                      const auto lcode = lnode.code;
+                                      const auto llevel = detail::tree_level<NDim>(lcode);
+
+                                      // Iterate over the particles of the leaf node.
+                                      const auto e = lnode.end;
+                                      for (auto b = lnode.begin; b != e; ++b) {
+                                          // TODO: this will be different in ordered mode.
+                                          const auto pidx = b;
+
+                                          // Fill in the tmp vectors for the particle pos
+                                          // and AABB.
+                                          const auto aabb_size = *(it + pidx);
+                                          for (std::size_t j = 0; j < NDim; ++j) {
+                                              tmp[j] = m_parts[j][pidx];
+                                              aabb_sizes[j] = aabb_size;
+                                          }
+
+                                          // Compute the enclosing node of the current particle.
+                                          const auto ecode = detail::coll_get_enclosing_node(
+                                              tmp, llevel, aabb_sizes, min_coord, max_coord, inv_box_size);
+
+                                          if (ecode == lcode) {
+                                              // The enclosing node is the leaf node
+                                              // itself, don't do anything.
+                                              continue;
+                                          }
+
+                                          // The enclosing node is an ancestor of the
+                                          // leaf node. We need to add the particle
+                                          // to all the leaf nodes which are children of
+                                          // the enclosing node.
+                                          // We will be iterating over the set of all leaf nodes
+                                          // starting from the current one. We will move backwards
+                                          // and forward until we have identified all the children nodes
+                                          // of the enclosing node.
+
+                                          // Small helper to establish if the node with the input code
+                                          // is a child of the enclosing node.
+                                          auto is_child
+                                              = [ecode_level = detail::tree_level<NDim>(ecode), ecode](UInt code) {
+                                                    const auto level = detail::tree_level<NDim>(code);
+                                                    if (level < ecode_level) {
+                                                        // The input node has a higher level than
+                                                        // the enclosing node, it cannot be one of its
+                                                        // children.
+                                                        return false;
+                                                    }
+                                                    if ((code >> ((level - ecode_level) * NDim)) != ecode) {
+                                                        // The input code does not start with ecode: it is
+                                                        // the child of another anode.
+                                                        return false;
+                                                    }
+                                                    return true;
+                                                };
+
+                                          // The backwards iteration.
+                                          auto j = i;
+                                          while (j) {
+                                              if (!is_child(m_tree[clp[--j]].code)) {
+                                                  break;
+                                              }
+                                              local_map[j].push_back(pidx);
+                                          }
+
+                                          // The forward iteration.
+                                          for (j = i + 1u; j < clp.size(); ++j) {
+                                              if (!is_child(m_tree[clp[j]].code)) {
+                                                  break;
+                                              }
+                                              local_map[j].push_back(pidx);
+                                          }
+                                      }
+                                  }
+
+                                  // Merge the local map into v_extra.
+                                  for (const auto &[i, v] : local_map) {
+                                      v_extra[static_cast<decltype(v_extra.size())>(i)].grow_by(v.begin(), v.end());
+                                  }
+                              });
+        });
+
+        // Concurrently, prepare the collision list via resize.
+        tg.run([this, &c_list]() { c_list.resize(boost::numeric_cast<decltype(c_list.size())>(m_parts[0].size())); });
+
+        tg.wait();
+
+        simple_timer st_aabb("aabb testing");
+        // Iterate over the leaf nodes and run the collision detection.
+        tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()), [this, &clp, &v_extra, it,
+                                                                                    &c_list](const auto &r) {
+            std::unordered_map<size_type, std::vector<size_type>> local_map;
+            std::vector<size_type> local_indices;
+
+            auto aabb_overlap = [this, it](size_type idx1, size_type idx2) {
+                const auto aabb_size1 = *(it + idx1);
+                const auto aabb_size2 = *(it + idx2);
+
+                for (std::size_t j = 0; j < NDim; ++j) {
+                    const auto min1 = fma_wrap(aabb_size1, -F(1) / F(2), m_parts[j][idx1]);
+                    const auto max1 = fma_wrap(aabb_size1, F(1) / F(2), m_parts[j][idx1]);
+
+                    const auto min2 = fma_wrap(aabb_size2, -F(1) / F(2), m_parts[j][idx2]);
+                    const auto max2 = fma_wrap(aabb_size2, F(1) / F(2), m_parts[j][idx2]);
+
+                    if (!(max1 > min2 && min1 < max2)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            };
+
+            for (auto i = r.begin(); i != r.end(); ++i) {
+                const auto &lnode = m_tree[clp[i]];
+                const auto extras = v_extra[static_cast<decltype(v_extra.size())>(i)];
+                local_indices.resize(lnode.end - lnode.begin + extras.size());
+                std::iota(local_indices.data(), local_indices.data() + (lnode.end - lnode.begin), lnode.begin);
+                std::copy(extras.begin(), extras.end(), local_indices.data() + (lnode.end - lnode.begin));
+                for (decltype(local_indices.size()) j0 = 0; j0 < local_indices.size(); ++j0) {
+                    for (auto j1 = j0 + 1u; j1 < local_indices.size(); ++j1) {
+                        const auto pidx0 = local_indices[j0];
+                        const auto pidx1 = local_indices[j1];
+
+                        if (aabb_overlap(pidx0, pidx1)) {
+                            local_map[pidx0].push_back(pidx1);
+                            local_map[pidx1].push_back(pidx0);
+                        }
+                    }
+                }
+            }
+
+            for (const auto &[idx, v] : local_map) {
+                c_list[static_cast<decltype(c_list.size())>(idx)].insert(v.begin(), v.end());
+            }
+        });
+
+        return c_list;
+    }
 
 private:
     template <bool Ordered, unsigned Q>
diff --git a/test/coll.cpp b/test/coll.cpp
index 645e658..6acee13 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -189,3 +189,27 @@ TEST_CASE("coll_get_enclosing_node_2d")
     ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
     REQUIRE(ncode == 1u);
 }
+
+TEST_CASE("compute_clist")
+{
+    constexpr auto bsize = 1.;
+    constexpr auto s = 100000u;
+    auto parts = get_uniform_particles<3>(s, bsize, rng);
+    octree<double> t{x_coords = parts.begin() + s,
+                     y_coords = parts.begin() + 2u * s,
+                     z_coords = parts.begin() + 3u * s,
+                     masses = parts.begin(),
+                     nparts = s,
+                     box_size = bsize};
+    const std::vector<double> aabb_sizes(s, 1E-3);
+
+    auto clist = t.compute_clist(aabb_sizes.data());
+
+    // for (decltype(clist.size()) i = 0; i < clist.size(); ++i) {
+    //     std::cout << i << " | ";
+    //     for (auto idx : clist[i]) {
+    //         std::cout << idx << ", ";
+    //     }
+    //     std::cout << '\n';
+    // }
+}

From 00848e2022874fdf75e8d36f818c60121dbdd51c Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 9 Jul 2019 12:50:58 +0200
Subject: [PATCH 14/38] More WIP, with testing.

---
 include/rakau/tree.hpp | 345 ++++++++++++++++++++++++-----------------
 test/coll.cpp          | 314 ++++++++++++++++++++++++++++++-------
 2 files changed, 460 insertions(+), 199 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 38daf07..496f640 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -612,16 +612,10 @@ inline auto coll_leaves_permutation(const Nodes &t)
 // whose edges have sizes aabb_sizes, return the list of
 // the vertices of the bounding box.
 template <typename F, std::size_t NDim>
-inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::array<F, NDim> &aabb_sizes,
-                                   const F &min_coord, const F &max_coord)
+inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::array<F, NDim> &aabb_sizes)
 {
-    // min/max coord must be finite.
-    assert(std::isfinite(min_coord) && std::isfinite(max_coord));
-    // min_coord < max_coord.
-    assert(min_coord < max_coord);
-    // p_pos must contain finite values in the [min_coord, max_coord] range.
-    assert(std::all_of(p_pos.begin(), p_pos.end(),
-                       [min_coord, max_coord](F x) { return std::isfinite(x) && x >= min_coord && x <= max_coord; }));
+    // p_pos must contain finite values.
+    assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
     // aabb_sizes all finite and non-negative.
     // NOTE: empty AABBs are allowed.
     assert(std::all_of(aabb_sizes.begin(), aabb_sizes.end(), [](F x) { return std::isfinite(x) && x >= F(0); }));
@@ -632,7 +626,6 @@ inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::
 
     // Compute the min/max coordinates of the AABB (in 2D, the lower-left
     // and upper-right corners of the AABB).
-    // NOTE: these will *not* be clamped.
     const auto aabb_minmax_coords = [&aabb_sizes, &p_pos]() {
         std::array<std::array<F, NDim>, 2> retval;
 
@@ -676,12 +669,7 @@ inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::
     for (std::size_t i = 0; i < n_points; ++i) {
         for (std::size_t j = 0; j < NDim; ++j) {
             const auto idx = (i >> j) & 1u;
-            // NOTE: we asserted that min_coord < max_coord, and that they
-            // are finite. Moreover, we also checked that aabb_minmax_coords[idx][j]
-            // is a finite value. Gonna assume that std::clamp() does not do anything weird
-            // FP-wise, so we don't check its output.
-            aabb_points[i][j] = std::clamp(aabb_minmax_coords[idx][j], min_coord, max_coord);
-            assert(aabb_points[i][j] >= min_coord && aabb_points[i][j] <= max_coord);
+            aabb_points[i][j] = aabb_minmax_coords[idx][j];
         }
     }
 
@@ -699,21 +687,18 @@ inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::
 // compute the code of the smallest node not smaller than the leaf node
 // that contains the particle and its aabb (that is, the return
 // value will be the code of the leaf node or of one of its ancestors).
-// min_coord and max_coord can be inferred by inv_box_size, hence they are redundant,
-// but we pass them in to avoid re-computing them at every invocation.
 template <typename F, std::size_t NDim, typename UInt>
 inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt &llevel,
-                                    const std::array<F, NDim> &aabb_sizes, const F &min_coord, const F &max_coord,
-                                    const F &inv_box_size)
+                                    const std::array<F, NDim> &aabb_sizes, const F &inv_box_size)
 {
     // The number of vertices of the AABB is 2**NDim.
     static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
     constexpr auto n_points = std::size_t(1) << NDim;
 
     // Get the list of vertices of the AABB.
-    const auto aabb_vertices = coll_get_aabb_vertices(p_pos, aabb_sizes, min_coord, max_coord);
+    const auto aabb_vertices = coll_get_aabb_vertices(p_pos, aabb_sizes);
 
-    // Compute their codes, and shift them down by (cbits - llevel) * NDim.
+    // Compute their clamped codes, and shift them down by (cbits - llevel) * NDim.
     // We do this because we want to produce a nodal code
     // whose level is llevel or lower, thus we already know we need
     // to throw away some information from the lower bits of the AABB codes.
@@ -723,12 +708,7 @@ inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt
     morton_encoder<NDim, UInt> me;
     for (std::size_t i = 0; i < n_points; ++i) {
         for (std::size_t j = 0; j < NDim; ++j) {
-            // NOTE: set clamping to true. This is helpful because
-            // if the AABB is cropped by the boundary of the box,
-            // inside disc_single_coord we might end up generating
-            // a coordinate slightly outside box boundary, due to FP shenanigans.
-            // We know anyway that here the aabb_vertices have already been
-            // clamped to the box boundaries.
+            // NOTE: discretize with clamping.
             tmp[j] = disc_single_coord<NDim, UInt, true>(aabb_vertices[i][j], inv_box_size);
         }
         const auto code = me(tmp.data());
@@ -3673,19 +3653,34 @@ class tree
     {
         accs_pots_o(acc_pot_ilist_to_array<2>(out), mac_value, std::forward<KwArgs>(args)...);
     }
-    template <typename It>
-    auto compute_clist(It it) const
+
+private:
+    template <bool Ordered, typename It>
+    auto compute_cgraph_impl(It it) const
     {
-        simple_timer st("clist computation");
+        simple_timer st("cgraph computation");
+
+        // Check that we can index into It at least
+        // up to the number of particles.
+        it_diff_check<It>(m_parts[0].size());
+
+        // The return value.
+        std::vector<tbb::concurrent_unordered_set<size_type>> cgraph;
+
+        // The vector holding the extra particles (the straddlers)
+        // for every leaf node of the tree.
+        // NOTE: for consistency with the particle indices
+        // in the original leaf node structure, we will store
+        // in v_extra indices referring to the internal tree
+        // order. We will translate them to indices in the original
+        // order, if needed, later.
+        std::vector<tbb::concurrent_vector<size_type>> v_extra;
 
-        // TODO check the range of it.
+        // The vector for iterating over the leaf nodes.
+        decltype(detail::coll_leaves_permutation(m_tree)) clp;
 
         tbb::task_group tg;
 
-        std::vector<tbb::concurrent_vector<size_type>> v_extra;
-        std::vector<tbb::concurrent_unordered_set<size_type>> c_list;
-        decltype(detail::coll_leaves_permutation(m_tree)) clp;
-
         tg.run([this, &v_extra, &clp, it]() {
             simple_timer st_vextra("vextra computation");
 
@@ -3694,122 +3689,137 @@ class tree
             clp = detail::coll_leaves_permutation(m_tree);
             v_extra.resize(boost::numeric_cast<decltype(v_extra.size())>(clp.size()));
 
-            // TODO: check these against the assertions.
+            // Pre-compute the inverse of the domain size.
             const auto inv_box_size = F(1) / m_box_size;
-            const auto min_coord = -m_box_size * (F(1) / F(2));
-            const auto max_coord = std::nextafter(m_box_size * (F(1) / F(2)), F(-1));
 
             // Augment the leaf nodes with the extra particles.
-            tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()),
-                              [this, &clp, &v_extra, it, inv_box_size, min_coord, max_coord](const auto &r) {
-                                  // Temporary vector for the particle position
-                                  // and the sizes of the AABB.
-                                  std::array<F, NDim> tmp, aabb_sizes;
-                                  // A local map in which we will map indices
-                                  // to leaf nodes to extra particles for those nodes.
-                                  // We will add the contents of this map to v_extra
-                                  // at the end.
-                                  std::unordered_map<decltype(clp.size()), std::vector<size_type>> local_map;
-
-                                  for (auto i = r.begin(); i != r.end(); ++i) {
-                                      // Fetch/cache some properties of the leaf node.
-                                      const auto &lnode = m_tree[clp[i]];
-                                      const auto lcode = lnode.code;
-                                      const auto llevel = detail::tree_level<NDim>(lcode);
-
-                                      // Iterate over the particles of the leaf node.
-                                      const auto e = lnode.end;
-                                      for (auto b = lnode.begin; b != e; ++b) {
-                                          // TODO: this will be different in ordered mode.
-                                          const auto pidx = b;
-
-                                          // Fill in the tmp vectors for the particle pos
-                                          // and AABB.
-                                          const auto aabb_size = *(it + pidx);
-                                          for (std::size_t j = 0; j < NDim; ++j) {
-                                              tmp[j] = m_parts[j][pidx];
-                                              aabb_sizes[j] = aabb_size;
-                                          }
-
-                                          // Compute the enclosing node of the current particle.
-                                          const auto ecode = detail::coll_get_enclosing_node(
-                                              tmp, llevel, aabb_sizes, min_coord, max_coord, inv_box_size);
-
-                                          if (ecode == lcode) {
-                                              // The enclosing node is the leaf node
-                                              // itself, don't do anything.
-                                              continue;
-                                          }
-
-                                          // The enclosing node is an ancestor of the
-                                          // leaf node. We need to add the particle
-                                          // to all the leaf nodes which are children of
-                                          // the enclosing node.
-                                          // We will be iterating over the set of all leaf nodes
-                                          // starting from the current one. We will move backwards
-                                          // and forward until we have identified all the children nodes
-                                          // of the enclosing node.
-
-                                          // Small helper to establish if the node with the input code
-                                          // is a child of the enclosing node.
-                                          auto is_child
-                                              = [ecode_level = detail::tree_level<NDim>(ecode), ecode](UInt code) {
-                                                    const auto level = detail::tree_level<NDim>(code);
-                                                    if (level < ecode_level) {
-                                                        // The input node has a higher level than
-                                                        // the enclosing node, it cannot be one of its
-                                                        // children.
-                                                        return false;
-                                                    }
-                                                    if ((code >> ((level - ecode_level) * NDim)) != ecode) {
-                                                        // The input code does not start with ecode: it is
-                                                        // the child of another anode.
-                                                        return false;
-                                                    }
-                                                    return true;
-                                                };
-
-                                          // The backwards iteration.
-                                          auto j = i;
-                                          while (j) {
-                                              if (!is_child(m_tree[clp[--j]].code)) {
-                                                  break;
-                                              }
-                                              local_map[j].push_back(pidx);
-                                          }
-
-                                          // The forward iteration.
-                                          for (j = i + 1u; j < clp.size(); ++j) {
-                                              if (!is_child(m_tree[clp[j]].code)) {
-                                                  break;
-                                              }
-                                              local_map[j].push_back(pidx);
-                                          }
-                                      }
-                                  }
+            tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()), [this, &clp, &v_extra, it,
+                                                                                        inv_box_size](const auto &r) {
+                // Temporary vector for the particle position
+                // and the sizes of the AABB.
+                std::array<F, NDim> tmp, aabb_sizes;
+                // A local map in which we will map leaf node indices
+                // to extra particles for those nodes.
+                // We will add the contents of this map to v_extra
+                // at the end.
+                std::unordered_map<decltype(clp.size()), std::vector<size_type>> local_map;
+
+                for (auto i = r.begin(); i != r.end(); ++i) {
+                    // Fetch/cache some properties of the leaf node.
+                    const auto &lnode = m_tree[clp[i]];
+                    const auto lcode = lnode.code;
+                    const auto llevel = detail::tree_level<NDim>(lcode);
+
+                    // Iterate over the particles of the leaf node.
+                    const auto e = lnode.end;
+                    for (auto pidx = lnode.begin; pidx != e; ++pidx) {
+                        // Fill in the tmp vectors for the particle pos
+                        // and AABB.
+                        // NOTE: if Ordered, we must transform the original
+                        // pidx, as 'it' points to a vector of aabb sizes sorted
+                        // in the original order.
+                        const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
+                        for (std::size_t j = 0; j < NDim; ++j) {
+                            tmp[j] = m_parts[j][pidx];
+                            aabb_sizes[j] = aabb_size;
+                        }
 
-                                  // Merge the local map into v_extra.
-                                  for (const auto &[i, v] : local_map) {
-                                      v_extra[static_cast<decltype(v_extra.size())>(i)].grow_by(v.begin(), v.end());
-                                  }
-                              });
+                        // Compute the enclosing node of the current particle.
+                        const auto ecode = detail::coll_get_enclosing_node(tmp, llevel, aabb_sizes, inv_box_size);
+
+                        if (ecode == lcode) {
+                            // The enclosing node is the leaf node
+                            // itself, don't do anything.
+                            continue;
+                        }
+
+                        // The enclosing node is an ancestor of the
+                        // leaf node. We need to add the current particle
+                        // to all the leaf nodes which are children of
+                        // the enclosing node.
+                        // We will be iterating over the set of all leaf nodes
+                        // starting from the current one. We will move backwards
+                        // and forward until we have identified all the children nodes
+                        // of the enclosing node.
+
+                        // Small helper to establish if the node with the input code
+                        // is a child of the enclosing node.
+                        auto is_child = [ecode_level = detail::tree_level<NDim>(ecode), ecode](UInt code) {
+                            const auto level = detail::tree_level<NDim>(code);
+                            if (level < ecode_level) {
+                                // The input node has a lower level than
+                                // the enclosing node, it cannot be one of its
+                                // children.
+                                return false;
+                            }
+                            if ((code >> ((level - ecode_level) * NDim)) != ecode) {
+                                // The input code does not start with ecode: it belongs
+                                // to another branch of the tree.
+                                return false;
+                            }
+                            return true;
+                        };
+
+                        // The backwards iteration.
+                        auto j = i;
+                        while (j) {
+                            if (!is_child(m_tree[clp[--j]].code)) {
+                                break;
+                            }
+                            local_map[j].push_back(pidx);
+                        }
+
+                        // The forward iteration.
+                        for (j = i + 1u; j < clp.size(); ++j) {
+                            if (!is_child(m_tree[clp[j]].code)) {
+                                break;
+                            }
+                            local_map[j].push_back(pidx);
+                        }
+                    }
+                }
+
+                // Merge the local map into v_extra.
+                for (const auto &[i, v] : local_map) {
+                    v_extra[static_cast<decltype(v_extra.size())>(i)].grow_by(v.begin(), v.end());
+                }
+            });
         });
 
         // Concurrently, prepare the collision list via resize.
-        tg.run([this, &c_list]() { c_list.resize(boost::numeric_cast<decltype(c_list.size())>(m_parts[0].size())); });
+        tg.run([this, &cgraph]() { cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size())); });
 
         tg.wait();
 
         simple_timer st_aabb("aabb testing");
-        // Iterate over the leaf nodes and run the collision detection.
+        // Iterate over the augmented leaf nodes and run the collision detection.
         tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()), [this, &clp, &v_extra, it,
-                                                                                    &c_list](const auto &r) {
+                                                                                    &cgraph](const auto &r) {
+            // Local collision graph, mapping a particle to a set
+            // of particles with which it collides.
+            // NOTE: this will always use unordered indices, we will translate
+            // to ordered indices, if necessary, at the end.
             std::unordered_map<size_type, std::vector<size_type>> local_map;
+
+            // Temporary vector in which we store the set of particles
+            // belonging to an augmented leaf node: the set of the original
+            // particles, plus the straddlers (contained in v_extra).
             std::vector<size_type> local_indices;
 
+            // Small helper to check for overlap between the AABBs
+            // of the two particles at indices idx1 and idx2.
             auto aabb_overlap = [this, it](size_type idx1, size_type idx2) {
-                const auto aabb_size1 = *(it + idx1);
-                const auto aabb_size2 = *(it + idx2);
+                // Like above, we might need to access the aabb sizes in a permuted
+                // fashion, as idx1 and idx2 will refer to particle indices
+                // in the internal tree order.
+                const auto aabb_size1 = Ordered ? *(it + m_perm[idx1]) : *(it + idx1);
+                const auto aabb_size2 = Ordered ? *(it + m_perm[idx2]) : *(it + idx2);
+
+                // If either AABB has a size of zero (i.e., point particles), we don't
+                // report a collision.
+                if (aabb_size1 == F(0) || aabb_size2 == F(0)) {
+                    return false;
+                }
 
                 for (std::size_t j = 0; j < NDim; ++j) {
                     const auto min1 = fma_wrap(aabb_size1, -F(1) / F(2), m_parts[j][idx1]);
@@ -3827,17 +3837,31 @@ class tree
             };
 
             for (auto i = r.begin(); i != r.end(); ++i) {
+                // Fetch references to the leaf node and its
+                // extra particles.
                 const auto &lnode = m_tree[clp[i]];
                 const auto extras = v_extra[static_cast<decltype(v_extra.size())>(i)];
-                local_indices.resize(lnode.end - lnode.begin + extras.size());
-                std::iota(local_indices.data(), local_indices.data() + (lnode.end - lnode.begin), lnode.begin);
-                std::copy(extras.begin(), extras.end(), local_indices.data() + (lnode.end - lnode.begin));
-                for (decltype(local_indices.size()) j0 = 0; j0 < local_indices.size(); ++j0) {
-                    for (auto j1 = j0 + 1u; j1 < local_indices.size(); ++j1) {
-                        const auto pidx0 = local_indices[j0];
+
+                // Fill in the full set of particles belonging to this node: the
+                // original ones, plus those from v_extra.
+                const auto orig_size = lnode.end - lnode.begin;
+                local_indices.resize(boost::numeric_cast<decltype(local_indices.size())>(orig_size + extras.size()));
+                std::iota(local_indices.data(), local_indices.data() + orig_size, lnode.begin);
+                std::copy(extras.begin(), extras.end(), local_indices.data() + orig_size);
+
+                // Check AABB overlaps over all the particles.
+                const auto ls = local_indices.size();
+                for (decltype(local_indices.size()) j0 = 0; j0 < ls; ++j0) {
+                    const auto pidx0 = local_indices[j0];
+                    for (auto j1 = j0 + 1u; j1 < ls; ++j1) {
                         const auto pidx1 = local_indices[j1];
 
                         if (aabb_overlap(pidx0, pidx1)) {
+                            // NOTE: we use the unordered indices
+                            // for the local map. We will be transforming
+                            // to ordered indices, if necessary,
+                            // only when merging the local map
+                            // into the global one.
                             local_map[pidx0].push_back(pidx1);
                             local_map[pidx1].push_back(pidx0);
                         }
@@ -3845,12 +3869,45 @@ class tree
                 }
             }
 
+            // Merge the local collision graph into the global one, translating
+            // the indices on the fly if necessary.
             for (const auto &[idx, v] : local_map) {
-                c_list[static_cast<decltype(c_list.size())>(idx)].insert(v.begin(), v.end());
+                if constexpr (Ordered) {
+                    auto idx_transform = [this](auto n) { return m_perm[n]; };
+                    cgraph[static_cast<decltype(cgraph.size())>(m_perm[idx])].insert(
+                        boost::make_transform_iterator(v.begin(), idx_transform),
+                        boost::make_transform_iterator(v.end(), idx_transform));
+                } else {
+                    cgraph[static_cast<decltype(cgraph.size())>(idx)].insert(v.begin(), v.end());
+                }
             }
         });
 
-        return c_list;
+#if !defined(NDEBUG)
+        // Verify the collision graph.
+        for (decltype(cgraph.size()) i = 0; i < cgraph.size(); ++i) {
+            for (auto idx : cgraph[i]) {
+                assert(idx < cgraph.size());
+                assert(std::find(cgraph[static_cast<decltype(cgraph.size())>(idx)].begin(),
+                                 cgraph[static_cast<decltype(cgraph.size())>(idx)].end(), i)
+                       != cgraph[static_cast<decltype(cgraph.size())>(idx)].end());
+            }
+        }
+#endif
+
+        return cgraph;
+    }
+
+public:
+    template <typename It>
+    auto compute_cgraph_u(It it) const
+    {
+        return compute_cgraph_impl<false>(it);
+    }
+    template <typename It>
+    auto compute_cgraph_o(It it) const
+    {
+        return compute_cgraph_impl<true>(it);
     }
 
 private:
diff --git a/test/coll.cpp b/test/coll.cpp
index 6acee13..1e38516 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -18,6 +18,8 @@
 #include <numeric>
 #include <random>
 #include <tuple>
+#include <unordered_set>
+#include <vector>
 
 #include <boost/iterator/permutation_iterator.hpp>
 
@@ -66,12 +68,12 @@ TEST_CASE("coll_get_aabb_vertices_2d")
     v2d p_pos = {.5, .5};
     v2d aabb_sizes = {0., 0.};
 
-    auto ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    auto ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::all_of(ret.begin(), ret.end(), [p_pos](const auto &v) { return v == p_pos; }));
 
     aabb_sizes = {.25, .25};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .375}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .625}) != ret.end());
@@ -79,7 +81,7 @@ TEST_CASE("coll_get_aabb_vertices_2d")
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .375}) != ret.end());
 
     aabb_sizes = {.25, .25 / 2};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .4375}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .5625}) != ret.end());
@@ -88,59 +90,57 @@ TEST_CASE("coll_get_aabb_vertices_2d")
 
     // Try a negative coord.
     p_pos = {-.5, .5};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.625, .4375}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.375, .5625}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.625, .5625}) != ret.end());
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.375, .4375}) != ret.end());
 
-    // Clamping.
     p_pos = {9., 9.};
     aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 11.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., 7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., 11.}) != ret.end());
 
     p_pos = {9., -9.};
     aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -11.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., -7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., -11.}) != ret.end());
 
     p_pos = {-9., 9.};
     aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., 10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 11.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., 7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., 11.}) != ret.end());
 
     p_pos = {-9., -9.};
     aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
     REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -11.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., -7.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., -11.}) != ret.end());
 
-    // Clamp in all directions.
     p_pos = {0., 0.};
     aabb_sizes = {40., 40.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes, -10., 10.);
+    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
 
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., 10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., -10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-10., -10.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{10., 10.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-20., 20.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{20., -20.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-20., -20.}) != ret.end());
+    REQUIRE(std::find(ret.begin(), ret.end(), v2d{20., 20.}) != ret.end());
 }
 
 TEST_CASE("coll_get_enclosing_node_2d")
@@ -151,65 +151,269 @@ TEST_CASE("coll_get_enclosing_node_2d")
     v2d pos{0., 0.};
     v2d aabb_sizes{1., 1.};
 
-    auto ncode = detail::coll_get_enclosing_node(pos, std::size_t(0), aabb_sizes, -5., 5., .0625);
+    auto ncode = detail::coll_get_enclosing_node(pos, std::size_t(0), aabb_sizes, .0625);
     REQUIRE(ncode == 1u);
 
     // Move it only slightly, still straddling.
     pos = {.1, .1};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 1u);
 
     // Place it fully in all quadrants..
     pos = {1., 1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 7u);
 
     pos = {-1., 1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 6u);
 
     pos = {-1., -1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 4u);
 
     // Straddle 2 quadrants.
     pos = {1., 0.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 1u);
 
     pos = {0., 1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 1u);
 
     pos = {-1., 0.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 1u);
 
     pos = {0., -1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, -5., 5., .0625);
+    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
     REQUIRE(ncode == 1u);
 }
 
-TEST_CASE("compute_clist")
+TEST_CASE("compute_cgraph")
 {
     constexpr auto bsize = 1.;
-    constexpr auto s = 100000u;
+    constexpr auto s = 200u;
+
+    auto aabb_overlap = [](auto x1, auto y1, auto z1, auto s1, auto x2, auto y2, auto z2, auto s2) {
+        if (s1 == 0 || s2 == 0) {
+            return false;
+        }
+
+        auto xmin1 = x1 - s1 / 2;
+        auto xmax1 = x1 + s1 / 2;
+        auto ymin1 = y1 - s1 / 2;
+        auto ymax1 = y1 + s1 / 2;
+        auto zmin1 = z1 - s1 / 2;
+        auto zmax1 = z1 + s1 / 2;
+
+        auto xmin2 = x2 - s2 / 2;
+        auto xmax2 = x2 + s2 / 2;
+        auto ymin2 = y2 - s2 / 2;
+        auto ymax2 = y2 + s2 / 2;
+        auto zmin2 = z2 - s2 / 2;
+        auto zmax2 = z2 + s2 / 2;
+
+        return xmax1 > xmin2 && xmin1 < xmax2 && ymax1 > ymin2 && ymin1 < ymax2 && zmax1 > zmin2 && zmin1 < zmax2;
+    };
+
+    std::vector<double> aabb_sizes(s, 1.);
+
+    // Start with an empty tree.
+    octree<double> t;
+    REQUIRE(t.compute_cgraph_o(aabb_sizes.data()).empty());
+    REQUIRE(t.compute_cgraph_u(aabb_sizes.data()).empty());
+
+    // Fill with random data.
     auto parts = get_uniform_particles<3>(s, bsize, rng);
-    octree<double> t{x_coords = parts.begin() + s,
-                     y_coords = parts.begin() + 2u * s,
-                     z_coords = parts.begin() + 3u * s,
-                     masses = parts.begin(),
-                     nparts = s,
-                     box_size = bsize};
-    const std::vector<double> aabb_sizes(s, 1E-3);
-
-    auto clist = t.compute_clist(aabb_sizes.data());
-
-    // for (decltype(clist.size()) i = 0; i < clist.size(); ++i) {
-    //     std::cout << i << " | ";
-    //     for (auto idx : clist[i]) {
-    //         std::cout << idx << ", ";
-    //     }
-    //     std::cout << '\n';
-    // }
+
+    const auto xc_o = parts.begin() + s;
+    const auto yc_o = parts.begin() + 2u * s;
+    const auto zc_o = parts.begin() + 3u * s;
+
+    t = octree<double>{x_coords = xc_o,        y_coords = yc_o, z_coords = zc_o,
+                       masses = parts.begin(), nparts = s,      box_size = bsize};
+
+    const auto [xc_u, yc_u, zc_u, m_u] = t.p_its_u();
+
+    // Test with a variety of aabb sizes, starting from
+    // very small until encompassing the whole domain.
+    for (long k = 16; k >= 0; --k) {
+        // Collision graph that will be computed with the N**2 algorithm.
+        std::vector<std::vector<decltype(t)::size_type>> cmp;
+        cmp.resize(s);
+
+        // All aabbs same (nonzero) size.
+        const auto aabb_size = 1. / static_cast<double>(1l << k);
+        std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
+
+        // Unordered testing.
+        auto cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_size, xc_u[j], yc_u[j], zc_u[j], aabb_size)) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_u[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // Ordered testing.
+        auto cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_size, xc_o[j], yc_o[j], zc_o[j], aabb_size)) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_o[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // Set the aabb size to zero for half the points.
+        for (auto i = 0u; i < s; i += 2u) {
+            aabb_sizes[i] = 0;
+        }
+        // Build a version of aabb_sizes permuted according to the tree order.
+        auto aabb_sizes_u(aabb_sizes);
+        for (auto i = 0u; i < s; ++i) {
+            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+        }
+
+        // Redo the testing.
+        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
+                                 aabb_sizes_u[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_u[i].size() == cmp[i].size());
+            // If the current particle is a point, it cannot
+            // collide with anything.
+            if (aabb_sizes_u[i] == 0) {
+                REQUIRE(cgraph_u[i].empty());
+            }
+            // All the colliding particles must have nonzero size.
+            for (auto idx : cgraph_u[i]) {
+                REQUIRE(aabb_sizes_u[idx] != 0);
+            }
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j], aabb_sizes[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_o[i].size() == cmp[i].size());
+            // If the current particle is a point, it cannot
+            // collide with anything.
+            if (aabb_sizes[i] == 0) {
+                REQUIRE(cgraph_o[i].empty());
+            }
+            // All the colliding particles must have nonzero size.
+            for (auto idx : cgraph_o[i]) {
+                REQUIRE(aabb_sizes[idx] != 0);
+            }
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // Try different sizes.
+        for (auto i = 0u; i < s; ++i) {
+            aabb_sizes[i] += aabb_sizes[i] / (i + 1u);
+        }
+        aabb_sizes_u = aabb_sizes;
+        for (auto i = 0u; i < s; ++i) {
+            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+        }
+
+        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
+                                 aabb_sizes_u[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_u[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j], aabb_sizes[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_o[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // All zero aabb sizes.
+        std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
+
+        cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+        for (const auto &c : cgraph_u) {
+            REQUIRE(c.empty());
+        }
+
+        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (const auto &c : cgraph_o) {
+            REQUIRE(c.empty());
+        }
+    }
 }

From f2bddfb34007ae49335ee827160714098bc77e88 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 9 Jul 2019 15:39:59 +0200
Subject: [PATCH 15/38] Add a collision benchmark.

---
 benchmark/CMakeLists.txt     |  1 +
 benchmark/benchmark_coll.cpp | 71 ++++++++++++++++++++++++++++++++++++
 benchmark/common.hpp         | 55 ++++++++++++++++++++++++++++
 3 files changed, 127 insertions(+)
 create mode 100644 benchmark/benchmark_coll.cpp

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index ea67ee0..e3820ac 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -12,6 +12,7 @@ endfunction()
 
 ADD_RAKAU_BENCHMARK(benchmark_acc)
 ADD_RAKAU_BENCHMARK(benchmark_acc_pot)
+ADD_RAKAU_BENCHMARK(benchmark_coll)
 ADD_RAKAU_BENCHMARK(benchmark_pot)
 ADD_RAKAU_BENCHMARK(benchmark_move)
 ADD_RAKAU_BENCHMARK(benchmark_leapfrog)
diff --git a/benchmark/benchmark_coll.cpp b/benchmark/benchmark_coll.cpp
new file mode 100644
index 0000000..8e000f5
--- /dev/null
+++ b/benchmark/benchmark_coll.cpp
@@ -0,0 +1,71 @@
+// Copyright 2018 Francesco Biscani (bluescarni@gmail.com)
+//
+// This file is part of the rakau library.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <initializer_list>
+#include <iostream>
+#include <numeric>
+#include <optional>
+#include <tuple>
+#include <vector>
+
+#include <tbb/task_scheduler_init.h>
+
+#include <rakau/tree.hpp>
+
+#include "common.hpp"
+
+using namespace rakau;
+using namespace rakau_benchmark;
+
+int main(int argc, char **argv)
+{
+    std::cout.precision(20);
+
+    const auto popts = parse_coll_benchmark_options(argc, argv);
+
+    std::optional<tbb::task_scheduler_init> t_init;
+    if (std::get<2>(popts)) {
+        t_init.emplace(std::get<2>(popts));
+    }
+
+    auto runner = [&popts](auto x) {
+        using fp_type = decltype(x);
+
+        const auto [nparts, max_leaf_n, _1, bsize, a, parinit, _2, ordered, psize] = popts;
+
+        auto parts = get_plummer_sphere(nparts, static_cast<fp_type>(a), static_cast<fp_type>(bsize), parinit);
+        const std::vector<fp_type> aabb_sizes(nparts, psize);
+
+        octree<fp_type> t{kwargs::x_coords = parts.data() + nparts,
+                          kwargs::y_coords = parts.data() + 2 * nparts,
+                          kwargs::z_coords = parts.data() + 3 * nparts,
+                          kwargs::masses = parts.data(),
+                          kwargs::nparts = nparts,
+                          kwargs::max_leaf_n = max_leaf_n};
+
+        std::cout << t << '\n';
+
+        decltype(t.compute_cgraph_o(aabb_sizes.data())) cgraph;
+        if (ordered) {
+            cgraph = t.compute_cgraph_o(aabb_sizes.data());
+        } else {
+            cgraph = t.compute_cgraph_u(aabb_sizes.data());
+        }
+
+        const auto acc = std::accumulate(cgraph.begin(), cgraph.end(), 0ull,
+                                         [](auto cur, const auto &c) { return cur + c.size(); });
+
+        std::cout << "Total number of collisions detected: " << acc / 2u << '\n';
+    };
+
+    if (std::get<6>(popts) == "float") {
+        runner(0.f);
+    } else {
+        runner(0.);
+    }
+}
diff --git a/benchmark/common.hpp b/benchmark/common.hpp
index 688191c..71cc824 100644
--- a/benchmark/common.hpp
+++ b/benchmark/common.hpp
@@ -228,6 +228,61 @@ inline auto parse_accpot_benchmark_options(int argc, char **argv)
                       ordered};
 }
 
+inline auto parse_coll_benchmark_options(int argc, char **argv)
+{
+    namespace po = boost::program_options;
+
+    unsigned long nparts;
+    unsigned max_leaf_n, nthreads;
+    double bsize, a, psize;
+    bool parinit = false;
+    std::string fp_type;
+    bool ordered = false;
+
+    po::options_description desc("Allowed options");
+    desc.add_options()("help", "produce help message")(
+        "nparts", po::value<unsigned long>(&nparts)->default_value(1'000'000ul), "number of particles")(
+        "max_leaf_n", po::value<unsigned>(&max_leaf_n)->default_value(rakau::default_max_leaf_n),
+        "max number of particles in a leaf node")("a", po::value<double>(&a)->default_value(1.), "Plummer core radius")(
+        "bsize", po::value<double>(&bsize)->default_value(0.),
+        "size of the domain (if 0, it is automatically deduced)")(
+        "psize", po::value<double>(&psize)->default_value(1E-3),
+        "particle size")("nthreads", po::value<unsigned>(&nthreads)->default_value(0u),
+                         "number of threads to use (0 for auto-detection)")(
+        "parinit", "parallel nondeterministic initialisation of the particle distribution")(
+        "fp_type", po::value<std::string>(&fp_type)->default_value("float"),
+        "floating-point type to use in the computations")(
+        "ordered", "compute the collision graph using the original particle order");
+
+    po::variables_map vm;
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+
+    if (vm.count("help")) {
+        std::cout << desc << "\n";
+        std::exit(0);
+    }
+
+    if (nparts == 0u) {
+        throw std::invalid_argument("The number of particles cannot be zero");
+    }
+
+    if (vm.count("parinit")) {
+        parinit = true;
+    }
+
+    if (fp_type != "float" && fp_type != "double") {
+        throw std::invalid_argument("Only the 'float' and 'double' floating-point types are supported, but the type '"
+                                    + fp_type + "' was specified instead");
+    }
+
+    if (vm.count("ordered")) {
+        ordered = true;
+    }
+
+    return std::tuple{nparts, max_leaf_n, nthreads, bsize, a, parinit, std::move(fp_type), ordered, psize};
+}
+
 } // namespace rakau_benchmark
 
 #endif

From 67d588fc8f645fda0fc72192e78edf57c8c5df79 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Wed, 10 Jul 2019 09:57:48 +0200
Subject: [PATCH 16/38] More WIP profiling.

---
 benchmark/benchmark_coll.cpp |   7 ++
 include/rakau/tree.hpp       | 204 +++++++++++++++++++----------------
 2 files changed, 121 insertions(+), 90 deletions(-)

diff --git a/benchmark/benchmark_coll.cpp b/benchmark/benchmark_coll.cpp
index 8e000f5..aeac434 100644
--- a/benchmark/benchmark_coll.cpp
+++ b/benchmark/benchmark_coll.cpp
@@ -49,6 +49,13 @@ int main(int argc, char **argv)
                           kwargs::max_leaf_n = max_leaf_n};
 
         std::cout << t << '\n';
+        std::cout << detail::tree_level<3>(std::max_element(t.nodes().begin(), t.nodes().end(),
+                                                            [](const auto &n1, const auto &n2) {
+                                                                return detail::tree_level<3>(n1.code)
+                                                                       < detail::tree_level<3>(n2.code);
+                                                            })
+                                               ->code)
+                  << '\n';
 
         decltype(t.compute_cgraph_o(aabb_sizes.data())) cgraph;
         if (ordered) {
diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 496f640..3083394 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -38,6 +38,7 @@
 #include <chrono>
 #endif
 
+#include <boost/container/small_vector.hpp>
 #include <boost/iterator/permutation_iterator.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 #include <boost/numeric/conversion/cast.hpp>
@@ -45,6 +46,7 @@
 #include <tbb/blocked_range.h>
 #include <tbb/concurrent_unordered_set.h>
 #include <tbb/concurrent_vector.h>
+#include <tbb/enumerable_thread_specific.h>
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 #include <tbb/parallel_sort.h>
@@ -3673,7 +3675,7 @@ class tree
         // in the original leaf node structure, we will store
         // in v_extra indices referring to the internal tree
         // order. We will translate them to indices in the original
-        // order, if needed, later.
+        // order, if needed, only at the very end.
         std::vector<tbb::concurrent_vector<size_type>> v_extra;
 
         // The vector for iterating over the leaf nodes.
@@ -3689,100 +3691,122 @@ class tree
             clp = detail::coll_leaves_permutation(m_tree);
             v_extra.resize(boost::numeric_cast<decltype(v_extra.size())>(clp.size()));
 
+            using local_map_t = std::vector<boost::container::small_vector<size_type, 1u>>;
+            tbb::enumerable_thread_specific<local_map_t> local_maps(
+                local_map_t(boost::numeric_cast<typename local_map_t::size_type>(clp.size())));
+
             // Pre-compute the inverse of the domain size.
             const auto inv_box_size = F(1) / m_box_size;
 
-            // Augment the leaf nodes with the extra particles.
-            tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()), [this, &clp, &v_extra, it,
-                                                                                        inv_box_size](const auto &r) {
-                // Temporary vector for the particle position
-                // and the sizes of the AABB.
-                std::array<F, NDim> tmp, aabb_sizes;
-                // A local map in which we will map leaf node indices
-                // to extra particles for those nodes.
-                // We will add the contents of this map to v_extra
-                // at the end.
-                std::unordered_map<decltype(clp.size()), std::vector<size_type>> local_map;
-
-                for (auto i = r.begin(); i != r.end(); ++i) {
-                    // Fetch/cache some properties of the leaf node.
-                    const auto &lnode = m_tree[clp[i]];
-                    const auto lcode = lnode.code;
-                    const auto llevel = detail::tree_level<NDim>(lcode);
-
-                    // Iterate over the particles of the leaf node.
-                    const auto e = lnode.end;
-                    for (auto pidx = lnode.begin; pidx != e; ++pidx) {
-                        // Fill in the tmp vectors for the particle pos
-                        // and AABB.
-                        // NOTE: if Ordered, we must transform the original
-                        // pidx, as 'it' points to a vector of aabb sizes sorted
-                        // in the original order.
-                        const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
-                        for (std::size_t j = 0; j < NDim; ++j) {
-                            tmp[j] = m_parts[j][pidx];
-                            aabb_sizes[j] = aabb_size;
-                        }
-
-                        // Compute the enclosing node of the current particle.
-                        const auto ecode = detail::coll_get_enclosing_node(tmp, llevel, aabb_sizes, inv_box_size);
-
-                        if (ecode == lcode) {
-                            // The enclosing node is the leaf node
-                            // itself, don't do anything.
-                            continue;
-                        }
-
-                        // The enclosing node is an ancestor of the
-                        // leaf node. We need to add the current particle
-                        // to all the leaf nodes which are children of
-                        // the enclosing node.
-                        // We will be iterating over the set of all leaf nodes
-                        // starting from the current one. We will move backwards
-                        // and forward until we have identified all the children nodes
-                        // of the enclosing node.
-
-                        // Small helper to establish if the node with the input code
-                        // is a child of the enclosing node.
-                        auto is_child = [ecode_level = detail::tree_level<NDim>(ecode), ecode](UInt code) {
-                            const auto level = detail::tree_level<NDim>(code);
-                            if (level < ecode_level) {
-                                // The input node has a lower level than
-                                // the enclosing node, it cannot be one of its
-                                // children.
-                                return false;
-                            }
-                            if ((code >> ((level - ecode_level) * NDim)) != ecode) {
-                                // The input code does not start with ecode: it belongs
-                                // to another branch of the tree.
-                                return false;
-                            }
-                            return true;
-                        };
-
-                        // The backwards iteration.
-                        auto j = i;
-                        while (j) {
-                            if (!is_child(m_tree[clp[--j]].code)) {
-                                break;
-                            }
-                            local_map[j].push_back(pidx);
-                        }
+            // Determine the straddling particles that need to be added to each leaf node.
+            tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()),
+                              [this, &clp, &v_extra, it, inv_box_size, &local_maps](const auto &r) {
+                                  // Temporary vector for the particle position
+                                  // and the sizes of the AABB.
+                                  std::array<F, NDim> tmp, aabb_sizes;
+
+                                  // Extract the reference to the local map.
+                                  auto &local_map = local_maps.local();
+
+                                  for (auto i = r.begin(); i != r.end(); ++i) {
+                                      // Fetch/cache some properties of the leaf node.
+                                      const auto &lnode = m_tree[clp[i]];
+                                      const auto lcode = lnode.code;
+                                      const auto llevel = detail::tree_level<NDim>(lcode);
+
+                                      // Iterate over the particles of the leaf node.
+                                      const auto e = lnode.end;
+                                      for (auto pidx = lnode.begin; pidx != e; ++pidx) {
+                                          // Fill in the tmp vectors for the particle pos
+                                          // and AABB.
+                                          // NOTE: if Ordered, we must transform the original
+                                          // pidx, as 'it' points to a vector of aabb sizes sorted
+                                          // in the original order.
+                                          const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
+                                          for (std::size_t j = 0; j < NDim; ++j) {
+                                              tmp[j] = m_parts[j][pidx];
+                                              aabb_sizes[j] = aabb_size;
+                                          }
+
+                                          // Compute the code of the enclosing node for the
+                                          // current particle.
+                                          const auto ecode
+                                              = detail::coll_get_enclosing_node(tmp, llevel, aabb_sizes, inv_box_size);
+
+                                          if (ecode == lcode) {
+                                              // The enclosing node is the leaf node
+                                              // itself, don't do anything.
+                                              continue;
+                                          }
+
+                                          // The enclosing node is an ancestor of the
+                                          // leaf node. We need to add the current particle
+                                          // to all the leaf nodes which are children of
+                                          // the enclosing node.
+                                          // We will be iterating over the set of all leaf nodes
+                                          // starting from the current one. We will move backwards
+                                          // and forward until we have identified all the children nodes
+                                          // of the enclosing node.
+
+                                          // Small helper to establish if the node with the input code
+                                          // is a child of the enclosing node.
+                                          auto is_child
+                                              = [ecode_level = detail::tree_level<NDim>(ecode), ecode](UInt code) {
+                                                    const auto level = detail::tree_level<NDim>(code);
+
+                                                    if (level < ecode_level) {
+                                                        // The input node has a lower level than
+                                                        // the enclosing node, it cannot be one of its
+                                                        // children.
+                                                        return false;
+                                                    }
+
+                                                    if ((code >> ((level - ecode_level) * NDim)) != ecode) {
+                                                        // The input code does not start with ecode: it belongs
+                                                        // to another branch of the tree.
+                                                        return false;
+                                                    }
+
+                                                    return true;
+                                                };
+
+                                          // The backwards iteration.
+                                          auto j = i;
+                                          while (j) {
+                                              if (!is_child(m_tree[clp[--j]].code)) {
+                                                  break;
+                                              }
+                                              local_map[j].push_back(pidx);
+                                          }
+
+                                          // The forward iteration.
+                                          for (j = i + 1u; j < clp.size(); ++j) {
+                                              if (!is_child(m_tree[clp[j]].code)) {
+                                                  break;
+                                              }
+                                              local_map[j].push_back(pidx);
+                                          }
+                                      }
+                                  }
+                              });
 
-                        // The forward iteration.
-                        for (j = i + 1u; j < clp.size(); ++j) {
-                            if (!is_child(m_tree[clp[j]].code)) {
-                                break;
-                            }
-                            local_map[j].push_back(pidx);
-                        }
+            for (const auto &lm : local_maps) {
+                auto acc = 0ull;
+                std::cout << std::accumulate(lm.begin(), lm.end(), 0ull, [](auto cur, const auto &v) {
+                    return cur + v.size();
+                }) << ", ";
+            }
+            std::cout << '\n';
+            tbb::parallel_for(tbb::blocked_range(local_maps.begin(), local_maps.end()), [&v_extra](const auto &r) {
+                for (auto it = r.begin(); it != r.end(); ++it) {
+                    const auto &lm = *it;
+                    const auto lm_size = lm.size();
+
+                    for (decltype(lm.size()) i = 0; i < lm_size; ++i) {
+                        const auto &lv = lm[i];
+                        v_extra[i].grow_by(lv.begin(), lv.end());
                     }
                 }
-
-                // Merge the local map into v_extra.
-                for (const auto &[i, v] : local_map) {
-                    v_extra[static_cast<decltype(v_extra.size())>(i)].grow_by(v.begin(), v.end());
-                }
             });
         });
 
@@ -3840,7 +3864,7 @@ class tree
                 // Fetch references to the leaf node and its
                 // extra particles.
                 const auto &lnode = m_tree[clp[i]];
-                const auto extras = v_extra[static_cast<decltype(v_extra.size())>(i)];
+                const auto &extras = v_extra[i];
 
                 // Fill in the full set of particles belonging to this node: the
                 // original ones, plus those from v_extra.

From ae4076cac5703636d149c735d92be515cd596d7f Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 14 Jul 2019 13:32:34 +0200
Subject: [PATCH 17/38] Provisional, non-working WIP.

---
 benchmark/benchmark_coll.cpp       |   7 -
 include/rakau/detail/tree_coll.hpp | 500 +++++++++++++++++++++++++++++
 include/rakau/tree.hpp             | 285 +++++++++++++++-
 test/coll.cpp                      | 233 +++++++++++++-
 4 files changed, 1007 insertions(+), 18 deletions(-)
 create mode 100644 include/rakau/detail/tree_coll.hpp

diff --git a/benchmark/benchmark_coll.cpp b/benchmark/benchmark_coll.cpp
index aeac434..8e000f5 100644
--- a/benchmark/benchmark_coll.cpp
+++ b/benchmark/benchmark_coll.cpp
@@ -49,13 +49,6 @@ int main(int argc, char **argv)
                           kwargs::max_leaf_n = max_leaf_n};
 
         std::cout << t << '\n';
-        std::cout << detail::tree_level<3>(std::max_element(t.nodes().begin(), t.nodes().end(),
-                                                            [](const auto &n1, const auto &n2) {
-                                                                return detail::tree_level<3>(n1.code)
-                                                                       < detail::tree_level<3>(n2.code);
-                                                            })
-                                               ->code)
-                  << '\n';
 
         decltype(t.compute_cgraph_o(aabb_sizes.data())) cgraph;
         if (ordered) {
diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
new file mode 100644
index 0000000..84b53d3
--- /dev/null
+++ b/include/rakau/detail/tree_coll.hpp
@@ -0,0 +1,500 @@
+// Copyright 2018 Francesco Biscani (bluescarni@gmail.com)
+//
+// This file is part of the rakau library.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef RAKAU_DETAIL_TREE_COLL_HPP
+#define RAKAU_DETAIL_TREE_COLL_HPP
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include <boost/iterator/permutation_iterator.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <tbb/blocked_range.h>
+#include <tbb/concurrent_vector.h>
+#include <tbb/parallel_for.h>
+#include <tbb/task_group.h>
+
+#include <rakau/detail/simple_timer.hpp>
+#include <rakau/detail/tree_fwd.hpp>
+
+namespace rakau
+{
+
+// Return the largest node level such that the node
+// size is larger than the value s. If s >= m_box_size,
+// 0 will be returned.
+template <std::size_t NDim, typename F, typename UInt, mac MAC>
+inline UInt tree<NDim, F, UInt, MAC>::coll_size_to_level(F s) const
+{
+    assert(std::isfinite(s));
+    // NOTE: we assume we never enter here
+    // with a null node size.
+    assert(s > F(0));
+
+    UInt retval = 0;
+    F cur_node_size = m_box_size;
+
+    // Don't return a result larger than cbits
+    // (the max level).
+    for (; retval != cbits; ++retval) {
+        const auto next_node_size = cur_node_size * F(1) / F(2);
+        if (next_node_size <= s) {
+            // The next node size is not larger
+            // than the target. Break out and
+            // return the current retval;
+            break;
+        }
+        cur_node_size = next_node_size;
+    }
+
+    return retval;
+}
+
+// Return a vector of indices into tree structure
+// representing the ordered set of leaf nodes
+// NOTE: need to understand if/when/how this should be parallelised.
+template <std::size_t NDim, typename F, typename UInt, mac MAC>
+inline auto tree<NDim, F, UInt, MAC>::coll_leaves_permutation() const
+{
+    simple_timer st("coll_leaves_permutation");
+
+    // Prepare the output.
+    std::vector<size_type> retval;
+    const auto tsize = m_tree.size();
+    retval.reserve(static_cast<decltype(retval.size())>(tsize));
+
+    for (size_type i = 0; i < tsize; ++i) {
+        if (!m_tree[i].n_children) {
+            // Leaf node, add it.
+            retval.push_back(i);
+        }
+    }
+
+#if !defined(NDEBUG)
+    // Verify the output.
+    size_type tot_parts = 0;
+    for (auto idx : retval) {
+        assert(m_tree[idx].n_children == 0u);
+        tot_parts += m_tree[idx].end - m_tree[idx].begin;
+    }
+    assert(tot_parts == m_parts[0].size());
+#endif
+
+    return retval;
+}
+
+inline namespace detail
+{
+
+// Compute the coordinates and the codes of the vertices of an AABB of size aabb_size around
+// the point p_pos. When computing the codes, the coordinates of the AABB vertices will be clamped
+// to the domain boundaries (via inv_box_size).
+template <typename UInt, typename F, std::size_t NDim>
+inline auto tree_coll_get_aabb(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
+{
+    // p_pos must contain finite values.
+    assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
+    // aabb_size finite and non-negative.
+    // NOTE: empty AABBs are allowed.
+    assert(std::isfinite(aabb_size) && aabb_size >= F(0));
+
+    // The number of vertices of the AABB is 2**NDim.
+    static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
+    constexpr auto n_points = std::size_t(1) << NDim;
+
+    // Compute the min/max coordinates of the AABB (in 2D, the lower-left
+    // and upper-right corners of the AABB).
+    const auto aabb_minmax_coords = [half = aabb_size * (F(1) / F(2)), &p_pos]() {
+        std::array<std::array<F, NDim>, 2> retval;
+
+        for (std::size_t i = 0; i < NDim; ++i) {
+            const auto min_c = p_pos[i] - half;
+            const auto max_c = p_pos[i] + half;
+
+            // Check them.
+            if (rakau_unlikely(!std::isfinite(min_c) || !std::isfinite(max_c) || min_c > max_c)) {
+                throw std::invalid_argument(
+                    "The computation of the min/max coordinates of an AABB produced the invalid pair of values ("
+                    + std::to_string(min_c) + ", " + std::to_string(max_c) + ")");
+            }
+
+            retval[0][i] = min_c;
+            retval[1][i] = max_c;
+        }
+
+        return retval;
+    }();
+
+    // The return value.
+    std::pair<std::array<std::array<F, NDim>, n_points>, std::array<UInt, n_points>> retval;
+    auto &aabb_vertices = retval.first;
+    auto &aabb_codes = retval.second;
+
+    // Fill in aabb_vertices and aabb_codes. The idea here is that
+    // we need to generate all the 2**NDim possible combinations of min/max
+    // aabb coordinates. We do it via the bit-level representation
+    // of the numbers from 0 to 2**NDim - 1u. For instance, in 3 dimensions,
+    // we have the numbers from 0 to 7 included:
+    //
+    // 0 0 0 | i = 0
+    // 0 0 1 | i = 1
+    // 0 1 0 | i = 2
+    // 0 1 1 | i = 3
+    // ...
+    // 1 1 1 | i = 7
+    //
+    // We interpret a zero bit as setting the min aabb coordinate,
+    // a one bit as setting the max aabb coordinate. So, for instance,
+    // i = 3 corresponds to the aabb point (min, max, max).
+    std::array<UInt, NDim> tmp_disc;
+    morton_encoder<NDim, UInt> me;
+    for (std::size_t i = 0; i < n_points; ++i) {
+        auto &cur_vertex = aabb_vertices[i];
+
+        for (std::size_t j = 0; j < NDim; ++j) {
+            const auto idx = (i >> j) & 1u;
+            const auto cur_c = aabb_minmax_coords[idx][j];
+
+            cur_vertex[j] = cur_c;
+            // NOTE: discretize with clamping.
+            tmp_disc[j] = disc_single_coord<NDim, UInt, true>(cur_c, inv_box_size);
+        }
+        aabb_codes[i] = me(tmp_disc.data());
+    }
+
+    return retval;
+}
+
+// Given a nodal code and its level, determine the
+// closed range of [min, max] highest level nodal codes
+// (that is, positional codes with an extra 1 bit on top)
+// belonging to the node.
+template <std::size_t NDim, typename UInt>
+inline std::pair<UInt, UInt> tree_coll_node_range(UInt code, UInt level)
+{
+    constexpr auto cbits = cbits_v<UInt, NDim>;
+
+    assert(tree_level<NDim>(code) == level);
+    assert(cbits >= level);
+
+    const auto shift_amount = (cbits - level) * NDim;
+
+    // Move up, right filling zeroes.
+    const UInt min = code << shift_amount;
+    // Turn the filling zeroes into ones.
+    const UInt max = min + (UInt(-1) >> (unsigned(std::numeric_limits<UInt>::digits) - shift_amount));
+
+    return std::make_pair(min, max);
+}
+
+} // namespace detail
+
+template <std::size_t NDim, typename F, typename UInt, mac MAC>
+template <bool Ordered, typename It>
+inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl2(It it) const
+{
+    simple_timer st("overall cgraph computation");
+
+    // Check that we can index into It at least
+    // up to the number of particles.
+    detail::it_diff_check<It>(m_parts[0].size());
+
+    // The vector of permutations over the leaf nodes.
+    decltype(coll_leaves_permutation()) clp;
+
+    // The return value.
+    std::vector<tbb::concurrent_vector<size_type>> cgraph;
+
+    // Prepare storage in parallel.
+    tbb::task_group tg;
+
+    tg.run([this, &cgraph]() {
+        simple_timer st("cgraph prepare");
+        cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
+    });
+
+    tg.run([this, &clp]() {
+        simple_timer st("leaves permutation");
+        clp = coll_leaves_permutation();
+    });
+
+    tg.wait();
+
+    // Create the iterators for accessing the leaf nodes.
+    // NOTE: make sure we don't overflow when indexing.
+    detail::it_diff_check<decltype(m_tree.begin())>(m_tree.size());
+    auto c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
+    auto c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
+
+    // Pre-compute the inverse of the domain size.
+    const auto inv_box_size = F(1) / m_box_size;
+
+    // Build the collision graph
+    tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, it, inv_box_size, c_begin, c_end,
+                                                           &cgraph](const auto &r) {
+        // Temporary vector for the particle position, and its min/max aabb coordinates.
+        std::array<F, NDim> p_pos, min_aabb, max_aabb;
+
+        // Iteration over the leaf nodes.
+        for (const auto &lnode : r) {
+            // Fetch/cache some properties of the leaf node.
+            const auto lcode = lnode.code;
+            const auto llevel = lnode.level;
+
+            // Iterate over the particles of the leaf node.
+            const auto e = lnode.end;
+            for (auto pidx = lnode.begin; pidx != e; ++pidx) {
+                if (pidx == 102u || pidx == 107u) {
+                    static std::mutex mutex;
+                    std::lock_guard lock{mutex};
+                    std::cout << "idx: " << pidx << '\n';
+                    std::cout << "lnode dim: " << get_node_dim(llevel, m_box_size) << '\n';
+                    F nc[NDim];
+                    get_node_centre(nc, lcode, m_box_size);
+                    std::cout << "lnode centre: ";
+                    for (std::size_t j = 0; j < NDim; ++j) {
+                        std::cout << nc[j] << ", ";
+                    }
+                    std::cout << '\n';
+                }
+
+                // Load the particle's AABB size.
+                // NOTE: if Ordered, we must transform the original
+                // pidx, as 'it' points to a vector of aabb sizes sorted
+                // in the original order.
+                const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
+
+                // Check the aabb_size.
+                if (rakau_unlikely(!std::isfinite(aabb_size))) {
+                    throw std::invalid_argument(
+                        "A non-finite AABB size was detected while computing the collision graph");
+                }
+
+                // Particles with a null AABB don't participate in collision
+                // detection.
+                if (aabb_size == F(0)) {
+                    continue;
+                }
+
+                // Fill in the particle position and min/max aabb coordinates.
+                for (std::size_t j = 0; j < NDim; ++j) {
+                    p_pos[j] = m_parts[j][pidx];
+                    min_aabb[j] = p_pos[j] - aabb_size * (F(1) / F(2));
+                    max_aabb[j] = p_pos[j] + aabb_size * (F(1) / F(2));
+                }
+
+                // Helper to run AABB collision detection between the
+                // current particle and all the particles in the input
+                // node.
+                auto aabb_node_coll = [this, pidx, it, &max_aabb, &min_aabb, &cgraph](const auto &node) {
+                    for (auto idx_other = node.begin; idx_other != node.end; ++idx_other) {
+                        if (idx_other == pidx) {
+                            // Don't self collision check.
+                            continue;
+                        }
+
+                        // Load the other AABB size.
+                        const auto other_aabb_size = Ordered ? *(it + m_perm[idx_other]) : *(it + idx_other);
+
+                        if (other_aabb_size == F(0)) {
+                            // Null AABB, particle does not participate
+                            // in collision detection.
+                            continue;
+                        }
+
+                        // Check AABB overlap.
+                        bool overlap = true;
+                        for (std::size_t j = 0; j < NDim; ++j) {
+                            // NOTE: if other_aabb_size is NaN, the comparisons
+                            // below will both be false and no collision
+                            // will be registered. Later, when we do the collision
+                            // detection for idx_other, we will be checking for
+                            // NaN the aabb_size (see above) and an exception will fire.
+                            const auto min2 = m_parts[j][idx_other] - other_aabb_size * (F(1) / F(2));
+                            const auto max2 = m_parts[j][idx_other] + other_aabb_size * (F(1) / F(2));
+
+                            if (!(max_aabb[j] > min2 && min_aabb[j] < max2)) {
+                                overlap = false;
+                                break;
+                            }
+                        }
+
+                        if (overlap) {
+                            // if (pidx == 102u) {
+                            //     std::cout << "102 first collides with: " << idx_other << '\n';
+                            // }
+                            // if (pidx == 107u) {
+                            //     std::cout << "107 first collides with: " << idx_other << '\n';
+                            // }
+                            // if (idx_other == 102u) {
+                            //     std::cout << "102 second collides with: " << pidx << '\n';
+                            // }
+                            // if (idx_other == 107u) {
+                            //     std::cout << "107 second collides with: " << pidx << '\n';
+                            // }
+
+                            // Register the collision for the particle pidx.
+                            if constexpr (Ordered) {
+                                cgraph[m_perm[pidx]].push_back(m_perm[idx_other]);
+                                cgraph[m_perm[idx_other]].push_back(m_perm[pidx]);
+                            } else {
+                                cgraph[pidx].push_back(idx_other);
+                                cgraph[idx_other].push_back(pidx);
+                            }
+                        }
+                    }
+                };
+
+                // Do the collision detection with the other
+                // particles in the leaf node.
+                aabb_node_coll(lnode);
+
+                // Now we need to establish
+                // if the particle pidx straddles outside the leaf node,
+                // in which case we will have to run collision detection
+                // with other leaf nodes.
+
+                // Compute the AABB vertices and the corresponding clamped codes.
+                const auto tcga = detail::tree_coll_get_aabb<UInt>(p_pos, aabb_size, inv_box_size);
+                const auto &aabb_vertices = tcga.first;
+                const auto &aabb_codes = tcga.second;
+
+                // Fetch the number of vertices.
+                constexpr auto n_vertices = std::tuple_size_v<uncvref_t<decltype(aabb_vertices)>>;
+
+                // Check if the particle straddles.
+                // NOTE: the idea here is that the codes for all positions in the current node share
+                // the same initial llevel*NDim digits, which we can determine from the particle code.
+                const auto straddles = [llevel, &aabb_codes, pcode = m_codes[pidx]]() {
+                    const auto shift_amount = (cbits - llevel) * NDim;
+                    const auto common_prefix = pcode >> shift_amount;
+
+                    for (std::size_t i = 0; i < n_vertices; ++i) {
+                        if (aabb_codes[i] >> shift_amount != common_prefix) {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }();
+
+                // if (pidx == 102u) {
+                //     std::cout << "102 straddles: " << straddles << '\n';
+                // }
+
+                // if (pidx == 107u) {
+                //     std::cout << "107 straddles: " << straddles << '\n';
+                // }
+
+                if (!straddles) {
+                    // The particle does not straddle, move on.
+                    continue;
+                }
+
+                // The particle straddles. To know into which leaf nodes it straddles,
+                // the first step is to construct a set of adjacent nodes which are guaranteed
+                // to contain the AABB of pidx. We can do that by establishing for each AABB
+                // vertex the smallest node of size greater than aabb_size that contains
+                // the vertex. The set of equal-sized nodes thus determined will completely
+                // enclose the AABB of pidx. We will then figure out which leaf nodes
+                // overlap the enclosing node set and test for collision with all the
+                // particles in such leaf nodes.
+
+                // Convert the AABB size to a node level.
+                const auto aabb_level = coll_size_to_level(aabb_size);
+
+                // Iterate over the AABB vertices.
+                for (std::size_t i = 0; i < n_vertices; ++i) {
+                    // Compute the code of the node at level aabb_level
+                    // that encloses the vertex.
+                    const auto s_code
+                        = (aabb_codes[i] >> ((cbits - aabb_level) * NDim)) + (UInt(1) << (aabb_level * NDim));
+
+                    if (aabb_level >= llevel && s_code >> ((aabb_level - llevel) * NDim) == lcode) {
+                        // The s_code node fits within the current leaf node.
+                        // We don't need to re-run collision detection on the same
+                        // particles as already done above.
+                        continue;
+                    }
+
+                    // Determine the code range encompassed by s_code.
+                    const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, aabb_level);
+
+                    // In the set of leaf nodes, determine either the last node whose
+                    // code range precedes s_code_range, or the first one whose code
+                    // range has some overlap with s_code range.
+                    auto l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
+                        const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                        return n_max < p.first;
+                    });
+
+                    // Now determine the first node whose code range follows s_code_range.
+                    // NOTE: in upper_bound(), the comparator parameter types are flipped around
+                    // wrt lower_bound().
+                    const auto l_end = std::upper_bound(c_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
+                        const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                        return p.second < n_min;
+                    });
+
+                    // if (pidx == 102u) {
+                    //     std::cout << "102, vertex " << i << ", n nodes " << l_end - l_begin << '\n';
+                    // }
+                    // if (pidx == 107u) {
+                    //     std::cout << "107, vertex " << i << ", n nodes " << l_end - l_begin << '\n';
+                    // }
+
+                    // Iterate over the leaf node range, do the collision detection.
+                    for (; l_begin != l_end; ++l_begin) {
+                        aabb_node_coll(*l_begin);
+                    }
+                }
+            }
+        }
+    });
+
+    tbb::parallel_for(tbb::blocked_range(cgraph.begin(), cgraph.end()), [](const auto &r) {
+        for (auto &v : r) {
+            detail::it_diff_check<decltype(v.begin())>(v.size());
+
+            std::sort(v.begin(), v.end());
+            const auto new_end = std::unique(v.begin(), v.end());
+            v.resize(static_cast<decltype(v.size())>(new_end - v.begin()));
+        }
+    });
+
+#if !defined(NDEBUG)
+    // Verify the collision graph.
+    for (decltype(cgraph.size()) i = 0; i < cgraph.size(); ++i) {
+        for (auto idx : cgraph[i]) {
+            assert(idx < cgraph.size());
+            assert(std::find(cgraph[idx].begin(), cgraph[idx].end(), i) != cgraph[idx].end());
+        }
+    }
+
+    const auto acc
+        = std::accumulate(cgraph.begin(), cgraph.end(), 0ull, [](auto cur, const auto &c) { return cur + c.size(); });
+
+    std::cout << "Total number of collisions detected: " << acc / 2u << '\n';
+#endif
+
+    return cgraph;
+}
+
+} // namespace rakau
+
+#endif
diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 3083394..32e1858 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -38,7 +38,6 @@
 #include <chrono>
 #endif
 
-#include <boost/container/small_vector.hpp>
 #include <boost/iterator/permutation_iterator.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 #include <boost/numeric/conversion/cast.hpp>
@@ -3657,15 +3656,274 @@ class tree
     }
 
 private:
+    auto coll_leaves_permutation() const;
+    UInt coll_size_to_level(F) const;
+
+    // Compute the codes of the vertices of an AABB of size aabb_size around
+    // the point p_pos. The coordinates of the AABB vertices will be clamped
+    // to the domain boundaries (via inv_box_size).
+    static auto coll_get_aabb_codes(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
+    {
+        // p_pos must contain finite values.
+        assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
+        // aabb_size finite and non-negative.
+        // NOTE: empty AABBs are allowed.
+        assert(std::isfinite(aabb_size) && aabb_size >= F(0));
+
+        // The number of vertices of the AABB is 2**NDim.
+        static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
+        constexpr auto n_points = std::size_t(1) << NDim;
+
+        // Compute the min/max coordinates of the AABB (in 2D, the lower-left
+        // and upper-right corners of the AABB).
+        const auto aabb_minmax_coords = [half = aabb_size * (F(1) / F(2)), &p_pos]() {
+            std::array<std::array<F, NDim>, 2> retval;
+
+            for (std::size_t i = 0; i < NDim; ++i) {
+                const auto min_c = p_pos[i] - half;
+                const auto max_c = p_pos[i] + half;
+
+                // Check them.
+                if (rakau_unlikely(!std::isfinite(min_c) || !std::isfinite(max_c) || min_c > max_c)) {
+                    throw std::invalid_argument(
+                        "The computation of the min/max coordinates of an AABB produced the invalid pair of values ("
+                        + std::to_string(min_c) + ", " + std::to_string(max_c) + ")");
+                }
+
+                retval[0][i] = min_c;
+                retval[1][i] = max_c;
+            }
+
+            return retval;
+        }();
+
+        // The return value.
+        std::array<UInt, n_points> aabb_codes;
+
+        // Fill in aabb_codes. The idea here is that
+        // we need to generate all the 2**NDim possible combinations of min/max
+        // aabb coordinates. We do it via the bit-level representation
+        // of the numbers from 0 to 2**NDim - 1u. For instance, in 3 dimensions,
+        // we have the numbers from 0 to 7 included:
+        //
+        // 0 0 0 | i = 0
+        // 0 0 1 | i = 1
+        // 0 1 0 | i = 2
+        // 0 1 1 | i = 3
+        // ...
+        // 1 1 1 | i = 7
+        //
+        // We interpret a zero bit as setting the min aabb coordinate,
+        // a one bit as setting the max aabb coordinate. So, for instance,
+        // i = 3 corresponds to the aabb point (min, max, max).
+        std::array<UInt, NDim> tmp_disc;
+        morton_encoder<NDim, UInt> me;
+        for (std::size_t i = 0; i < n_points; ++i) {
+            for (std::size_t j = 0; j < NDim; ++j) {
+                const auto idx = (i >> j) & 1u;
+                // NOTE: discretize with clamping.
+                tmp_disc[j] = disc_single_coord<NDim, UInt, true>(aabb_minmax_coords[idx][j], inv_box_size);
+            }
+            aabb_codes[i] = me(tmp_disc.data());
+        }
+
+        return aabb_codes;
+    }
+
+    // Given a nodal code and its level, determine the
+    // closed range of [min, max] highest level codes
+    // (that is, positional codes with an extra 1 bit on top)
+    // belonging to the node.
+    std::pair<UInt, UInt> coll_code_to_range(UInt code, UInt level) const
+    {
+        assert(detail::tree_level<NDim>(code) == level);
+
+        const auto shift_amount = (cbits - level) * NDim;
+
+        assert(unsigned(std::numeric_limits<UInt>::digits) >= shift_amount);
+
+        // Move up, right filling zeroes.
+        const UInt min = code << shift_amount;
+        // Turn the filling zeroes into ones.
+        const UInt max = min + (UInt(-1) >> (unsigned(std::numeric_limits<UInt>::digits) - shift_amount));
+
+        return std::pair{min, max};
+    }
+
+    // Implementation of the computation of the collision graph.
     template <bool Ordered, typename It>
     auto compute_cgraph_impl(It it) const
     {
-        simple_timer st("cgraph computation");
+        simple_timer st("overall cgraph computation");
 
         // Check that we can index into It at least
         // up to the number of particles.
         it_diff_check<It>(m_parts[0].size());
 
+        // Run in parallel independent computations.
+        tbb::task_group tg;
+
+        decltype(coll_leaves_permutation()) clp;
+        std::vector<std::vector<size_type>> cgraph;
+        std::vector<tbb::concurrent_vector<size_type>> v_add;
+
+        tg.run([this, &cgraph]() {
+            simple_timer st("cgraph prepare");
+            cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
+        });
+
+        tg.run([this, &clp, &v_add, it]() {
+            // Determine the permutation indices over the
+            // leaf nodes.
+            clp = coll_leaves_permutation();
+
+            // Create the iterators for accessing the leaf nodes.
+            // NOTE: make sure we don't overflow when indexing.
+            it_diff_check<decltype(m_tree.begin())>(m_tree.size());
+            auto c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
+            auto c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
+
+            // Pre-compute the inverse of the domain size.
+            const auto inv_box_size = F(1) / m_box_size;
+
+            simple_timer st("v_add computation");
+            // Prepare the data structure for recording the additional
+            // particles for each leaf node.
+            // TODO in parallel?
+            v_add.resize(boost::numeric_cast<decltype(v_add.size())>(clp.size()));
+
+            // Fill in v_add. We will be first accumulating into thread local
+            // temporaries, and we will then merge the partial results in v_add.
+            using local_map_t = std::vector<std::vector<size_type>>;
+            tbb::enumerable_thread_specific<local_map_t> local_maps(
+                local_map_t(boost::numeric_cast<typename local_map_t::size_type>(clp.size())));
+
+            tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &local_maps, it, inv_box_size, c_begin,
+                                                                   c_end](const auto &r) {
+                // Temporary vector for the particle position.
+                std::array<F, NDim> tmp;
+
+                // Get out a reference to the local map.
+                auto &lmap = local_maps.local();
+
+                // Iteration over the leaf nodes.
+                for (const auto &lnode : r) {
+                    // Fetch/cache some properties of the leaf node.
+                    const auto lcode = lnode.code;
+                    const auto llevel = detail::tree_level<NDim>(lcode);
+
+                    // Iterate over the particles of the leaf node.
+                    const auto e = lnode.end;
+                    for (auto pidx = lnode.begin; pidx != e; ++pidx) {
+                        // Fill in the particle position and load the particle's AABB size.
+                        // NOTE: if Ordered, we must transform the original
+                        // pidx, as 'it' points to a vector of aabb sizes sorted
+                        // in the original order.
+                        const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
+                        for (std::size_t j = 0; j < NDim; ++j) {
+                            tmp[j] = m_parts[j][pidx];
+                        }
+
+                        // Fetch the particle code.
+                        const auto pcode = m_codes[pidx];
+
+                        // Compute the clamped codes of the AABB vertices.
+                        const auto aabb_codes = coll_get_aabb_codes(tmp, aabb_size, inv_box_size);
+                        constexpr auto n_aabb_codes = std::tuple_size_v<std::remove_const_t<decltype(aabb_codes)>>;
+
+                        // Array of flags identifying AABB vertices which straddle. Inited
+                        // to all false.
+                        std::array<bool, n_aabb_codes> straddle_flags{};
+
+                        // Flag the straddling AABB vertices.
+                        // NOTE: the idea here is that the codes for all positions in the current node share
+                        // the same initial llevel*NDim digits, which we can determine from pcode.
+                        const auto n_straddle = [llevel, &aabb_codes, &straddle_flags, pcode]() {
+                            std::size_t retval = 0;
+                            const auto shift_amount = (cbits - llevel) * NDim;
+                            const auto common_prefix = pcode >> shift_amount;
+
+                            for (std::size_t i = 0; i < n_aabb_codes; ++i) {
+                                if (aabb_codes[i] >> shift_amount != common_prefix) {
+                                    straddle_flags[i] = true;
+                                    ++retval;
+                                }
+                            }
+
+                            return retval;
+                        }();
+
+                        if (!n_straddle) {
+                            // No AABB vertices straddle, move to the next particle.
+                            continue;
+                        }
+
+                        // The particle straddles. We need to identify the other
+                        // leaf nodes into which it straddles.
+                        // For each straddling vertex V of the AABB, we will be looking
+                        // in the tree for the node N which contains V and
+                        // whose size is greater than the AABB size, and we will
+                        // add the particle to all the leaf nodes inside N.
+
+                        // Convert the AABB size to a node level.
+                        // NOTE: we implicitly checked above, when computing the aabb_codes,
+                        // that the AABB sizes stored in 'it' are finite and non-negative.
+                        const auto aabb_level = coll_size_to_level(aabb_size);
+
+                        for (std::size_t i = 0; i < n_aabb_codes; ++i) {
+                            if (!straddle_flags[i]) {
+                                // The current vertex does not straddle, skip it.
+                                continue;
+                            }
+
+                            // Compute the code of the node at level aabb_level
+                            // that encloses the straddling vertex.
+                            const auto s_code
+                                = (aabb_codes[i] >> ((cbits - aabb_level) * NDim)) + (UInt(1) << (aabb_level * NDim));
+
+                            // Determine the range of nodal codes for the s_code node.
+                            const auto blappo = coll_code_to_range(s_code, aabb_level);
+
+                            // The last that fully precedes, or the first which overlaps.
+                            auto l_begin
+                                = std::lower_bound(c_begin, c_end, blappo, [this](const auto &n, const auto &p) {
+                                      const auto [n_min, n_max] = coll_code_to_range(n.code, n.level);
+                                      return n_max < p.first;
+                                  });
+
+                            // The first that is completely after.
+                            auto l_end = std::upper_bound(c_begin, c_end, blappo, [this](const auto &p, const auto &n) {
+                                const auto [n_min, n_max] = coll_code_to_range(n.code, n.level);
+                                return p.second < n_min;
+                            });
+
+                            for (; l_begin != l_end; ++l_begin) {
+                                lmap[l_begin - c_begin].push_back(pidx);
+                            }
+                        }
+                    }
+                }
+            });
+
+            // Merge the local maps into v_add.
+            tbb::parallel_for(tbb::blocked_range(local_maps.begin(), local_maps.end()), [&v_add](const auto &r) {
+                for (auto &lmap : r) {
+                    for (decltype(lmap.size()) i = 0; i < lmap.size(); ++i) {
+                        auto &v = lmap[i];
+                        std::sort(v.begin(), v.end());
+                        v.erase(std::unique(v.begin(), v.end()), v.end());
+
+                        v_add[i].grow_by(v.begin(), v.end());
+                    }
+                }
+            });
+        });
+
+        tg.wait();
+
+        return cgraph;
+
+#if 0
         // The return value.
         std::vector<tbb::concurrent_unordered_set<size_type>> cgraph;
 
@@ -3679,16 +3937,16 @@ class tree
         std::vector<tbb::concurrent_vector<size_type>> v_extra;
 
         // The vector for iterating over the leaf nodes.
-        decltype(detail::coll_leaves_permutation(m_tree)) clp;
+        decltype(detail::coll_leaves_permutation(m_tree, leaf_level)) clp;
 
         tbb::task_group tg;
 
-        tg.run([this, &v_extra, &clp, it]() {
+        tg.run([this, &v_extra, &clp, it, leaf_level]() {
             simple_timer st_vextra("vextra computation");
 
             // Compute the permutation to iterate over the leaf nodes, and prepare
             // the container of the extra particles for each leaf node.
-            clp = detail::coll_leaves_permutation(m_tree);
+            clp = detail::coll_leaves_permutation(m_tree, leaf_level);
             v_extra.resize(boost::numeric_cast<decltype(v_extra.size())>(clp.size()));
 
             using local_map_t = std::vector<boost::container::small_vector<size_type, 1u>>;
@@ -3698,7 +3956,7 @@ class tree
             // Pre-compute the inverse of the domain size.
             const auto inv_box_size = F(1) / m_box_size;
 
-            // Determine the straddling particles that need to be added to each leaf node.
+            // Determine the straddling particles that need to be added to the leaf nodes.
             tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()),
                               [this, &clp, &v_extra, it, inv_box_size, &local_maps](const auto &r) {
                                   // Temporary vector for the particle position
@@ -3811,7 +4069,10 @@ class tree
         });
 
         // Concurrently, prepare the collision list via resize.
-        tg.run([this, &cgraph]() { cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size())); });
+        tg.run([this, &cgraph]() {
+            simple_timer st_vextra("cgraph prepare");
+            cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
+        });
 
         tg.wait();
 
@@ -3917,21 +4178,25 @@ class tree
                        != cgraph[static_cast<decltype(cgraph.size())>(idx)].end());
             }
         }
+#endif
 #endif
 
         return cgraph;
     }
 
+    template <bool Ordered, typename It>
+    auto compute_cgraph_impl2(It) const;
+
 public:
     template <typename It>
     auto compute_cgraph_u(It it) const
     {
-        return compute_cgraph_impl<false>(it);
+        return compute_cgraph_impl2<false>(it);
     }
     template <typename It>
     auto compute_cgraph_o(It it) const
     {
-        return compute_cgraph_impl<true>(it);
+        return compute_cgraph_impl2<true>(it);
     }
 
 private:
@@ -4299,4 +4564,6 @@ using octree = tree<3, F, std::size_t, MAC>;
 
 } // namespace rakau
 
+#include <rakau/detail/tree_coll.hpp>
+
 #endif
diff --git a/test/coll.cpp b/test/coll.cpp
index 1e38516..08edfbd 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -190,10 +190,239 @@ TEST_CASE("coll_get_enclosing_node_2d")
     REQUIRE(ncode == 1u);
 }
 
-TEST_CASE("compute_cgraph")
+TEST_CASE("compute_cgraph_2d")
 {
     constexpr auto bsize = 1.;
-    constexpr auto s = 200u;
+    constexpr auto s = 1000u;
+
+    auto aabb_overlap = [](auto x1, auto y1, auto s1, auto x2, auto y2, auto s2) {
+        if (s1 == 0 || s2 == 0) {
+            return false;
+        }
+
+        auto xmin1 = x1 - s1 / 2;
+        auto xmax1 = x1 + s1 / 2;
+        auto ymin1 = y1 - s1 / 2;
+        auto ymax1 = y1 + s1 / 2;
+
+        auto xmin2 = x2 - s2 / 2;
+        auto xmax2 = x2 + s2 / 2;
+        auto ymin2 = y2 - s2 / 2;
+        auto ymax2 = y2 + s2 / 2;
+
+        return xmax1 > xmin2 && xmin1 < xmax2 && ymax1 > ymin2 && ymin1 < ymax2;
+    };
+
+    std::vector<double> aabb_sizes(s, 1.);
+
+    // Start with an empty tree.
+    quadtree<double> t;
+    REQUIRE(t.compute_cgraph_o(aabb_sizes.data()).empty());
+    REQUIRE(t.compute_cgraph_u(aabb_sizes.data()).empty());
+
+    // Fill with random data.
+    auto parts = get_uniform_particles<2>(s, bsize, rng);
+
+    const auto xc_o = parts.begin() + s;
+    const auto yc_o = parts.begin() + 2u * s;
+
+    t = quadtree<double>{x_coords = xc_o, y_coords = yc_o, masses = parts.begin(), nparts = s, box_size = bsize};
+
+    const auto [xc_u, yc_u, m_u] = t.p_its_u();
+
+    // Test with a variety of aabb sizes, starting from
+    // very small until encompassing the whole domain.
+    for (long k = 16; k >= 0; --k) {
+        std::cout << "k=" << k << '\n';
+
+        // Collision graph that will be computed with the N**2 algorithm.
+        std::vector<std::vector<decltype(t)::size_type>> cmp;
+        cmp.resize(s);
+
+        // All aabbs same (nonzero) size.
+        const auto aabb_size = 1. / static_cast<double>(1l << k);
+        std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
+
+        // Unordered testing.
+        auto cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_u[i], yc_u[i], aabb_size, xc_u[j], yc_u[j], aabb_size)) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            if (cgraph_u[i].size() != cmp[i].size()) {
+                auto idx1 = 102u;
+                auto idx2 = 107u;
+                auto [x_it, y_it, m_it] = t.p_its_u();
+                std::cout << x_it[idx1] << ", " << y_it[idx1] << ", " << '\n';
+                std::cout << x_it[idx2] << ", " << y_it[idx2] << ", " << '\n';
+            }
+            REQUIRE(cgraph_u[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // Ordered testing.
+        auto cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_o[i], yc_o[i], aabb_size, xc_o[j], yc_o[j], aabb_size)) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_o[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // Set the aabb size to zero for half the points.
+        for (auto i = 0u; i < s; i += 2u) {
+            aabb_sizes[i] = 0;
+        }
+        // Build a version of aabb_sizes permuted according to the tree order.
+        auto aabb_sizes_u(aabb_sizes);
+        for (auto i = 0u; i < s; ++i) {
+            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+        }
+
+        // Redo the testing.
+        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_u[i].size() == cmp[i].size());
+            // If the current particle is a point, it cannot
+            // collide with anything.
+            if (aabb_sizes_u[i] == 0) {
+                REQUIRE(cgraph_u[i].empty());
+            }
+            // All the colliding particles must have nonzero size.
+            for (auto idx : cgraph_u[i]) {
+                REQUIRE(aabb_sizes_u[idx] != 0);
+            }
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_o[i].size() == cmp[i].size());
+            // If the current particle is a point, it cannot
+            // collide with anything.
+            if (aabb_sizes[i] == 0) {
+                REQUIRE(cgraph_o[i].empty());
+            }
+            // All the colliding particles must have nonzero size.
+            for (auto idx : cgraph_o[i]) {
+                REQUIRE(aabb_sizes[idx] != 0);
+            }
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // Try different sizes.
+        for (auto i = 0u; i < s; ++i) {
+            aabb_sizes[i] += aabb_sizes[i] / (i + 1u);
+        }
+        aabb_sizes_u = aabb_sizes;
+        for (auto i = 0u; i < s; ++i) {
+            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+        }
+
+        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_u[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (auto i = 0u; i < s; ++i) {
+            for (auto j = i + 1u; j < s; ++j) {
+                if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
+                    cmp[i].push_back(j);
+                    cmp[j].push_back(i);
+                }
+            }
+        }
+        for (auto i = 0u; i < s; ++i) {
+            REQUIRE(cgraph_o[i].size() == cmp[i].size());
+            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+        }
+        // Clear cmp.
+        for (auto &v : cmp) {
+            v.clear();
+        }
+
+        // All zero aabb sizes.
+        std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
+
+        cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+        for (const auto &c : cgraph_u) {
+            REQUIRE(c.empty());
+        }
+
+        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+        for (const auto &c : cgraph_o) {
+            REQUIRE(c.empty());
+        }
+    }
+}
+
+TEST_CASE("compute_cgraph_3d")
+{
+    constexpr auto bsize = 1.;
+    constexpr auto s = 1000u;
 
     auto aabb_overlap = [](auto x1, auto y1, auto z1, auto s1, auto x2, auto y2, auto z2, auto s2) {
         if (s1 == 0 || s2 == 0) {

From d948fd804bb751b86d1aa76c37ff4d9e44a5164a Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 14 Jul 2019 18:32:10 +0200
Subject: [PATCH 18/38] More WIP, cleanup, first test passing. Not finished
 yet.

---
 include/rakau/detail/tree_coll.hpp | 434 +++++++++---------
 include/rakau/tree.hpp             | 704 +----------------------------
 test/coll.cpp                      | 172 +------
 3 files changed, 231 insertions(+), 1079 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 84b53d3..1916372 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -15,6 +15,7 @@
 #include <cmath>
 #include <cstddef>
 #include <limits>
+#include <numeric>
 #include <stdexcept>
 #include <string>
 #include <tuple>
@@ -206,7 +207,7 @@ inline std::pair<UInt, UInt> tree_coll_node_range(UInt code, UInt level)
 
 template <std::size_t NDim, typename F, typename UInt, mac MAC>
 template <bool Ordered, typename It>
-inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl2(It it) const
+inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
 {
     simple_timer st("overall cgraph computation");
 
@@ -217,10 +218,14 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl2(It it) const
     // The vector of permutations over the leaf nodes.
     decltype(coll_leaves_permutation()) clp;
 
+    // The vector of additional particles for each leaf node.
+    std::vector<tbb::concurrent_vector<size_type>> v_add;
+
     // The return value.
     std::vector<tbb::concurrent_vector<size_type>> cgraph;
 
-    // Prepare storage in parallel.
+    // Prepare storage for cgraph in parallel
+    // with the v_add computation.
     tbb::task_group tg;
 
     tg.run([this, &cgraph]() {
@@ -228,239 +233,257 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl2(It it) const
         cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
     });
 
-    tg.run([this, &clp]() {
-        simple_timer st("leaves permutation");
-        clp = coll_leaves_permutation();
-    });
+    decltype(boost::make_permutation_iterator(m_tree.begin(), clp.begin())) c_begin, c_end;
 
-    tg.wait();
+    tg.run([this, &clp, &v_add, it, &c_begin, &c_end]() {
+        {
+            simple_timer st("leaves permutation");
+            clp = coll_leaves_permutation();
+        }
 
-    // Create the iterators for accessing the leaf nodes.
-    // NOTE: make sure we don't overflow when indexing.
-    detail::it_diff_check<decltype(m_tree.begin())>(m_tree.size());
-    auto c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
-    auto c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
+        {
+            simple_timer st("v_add prepare");
+            v_add.resize(boost::numeric_cast<decltype(v_add.size())>(clp.size()));
+        }
 
-    // Pre-compute the inverse of the domain size.
-    const auto inv_box_size = F(1) / m_box_size;
+        simple_timer st("v_add computation");
+
+        // Create the iterators for accessing the leaf nodes.
+        // NOTE: make sure we don't overflow when indexing.
+        detail::it_diff_check<decltype(m_tree.begin())>(m_tree.size());
+        c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
+        c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
+
+        // Pre-compute the inverse of the domain size.
+        const auto inv_box_size = F(1) / m_box_size;
+
+        // Determine the additional particles for each node.
+        tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &v_add, inv_box_size, it, c_begin,
+                                                               c_end](const auto &r) {
+            // Temporary vector for the particle position.
+            std::array<F, NDim> p_pos;
+
+            // Iteration over the leaf nodes.
+            for (const auto &lnode : r) {
+                // Fetch/cache some properties of the leaf node.
+                const auto lcode = lnode.code;
+                const auto llevel = lnode.level;
+
+                // Iterate over the particles of the leaf node.
+                const auto e = lnode.end;
+                for (auto pidx = lnode.begin; pidx != e; ++pidx) {
+                    // Load the particle's AABB size.
+                    // NOTE: if Ordered, we must transform the original
+                    // pidx, as 'it' points to a vector of aabb sizes sorted
+                    // in the original order.
+                    const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
+
+                    // Check it.
+                    if (rakau_unlikely(!std::isfinite(aabb_size))) {
+                        throw std::invalid_argument(
+                            "A non-finite AABB size was detected while computing the collision graph");
+                    }
 
-    // Build the collision graph
-    tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, it, inv_box_size, c_begin, c_end,
-                                                           &cgraph](const auto &r) {
-        // Temporary vector for the particle position, and its min/max aabb coordinates.
-        std::array<F, NDim> p_pos, min_aabb, max_aabb;
+                    // Particles with a null AABB don't participate in collision
+                    // detection and cannot straddle into other nodes.
+                    if (aabb_size == F(0)) {
+                        continue;
+                    }
 
-        // Iteration over the leaf nodes.
-        for (const auto &lnode : r) {
-            // Fetch/cache some properties of the leaf node.
-            const auto lcode = lnode.code;
-            const auto llevel = lnode.level;
-
-            // Iterate over the particles of the leaf node.
-            const auto e = lnode.end;
-            for (auto pidx = lnode.begin; pidx != e; ++pidx) {
-                if (pidx == 102u || pidx == 107u) {
-                    static std::mutex mutex;
-                    std::lock_guard lock{mutex};
-                    std::cout << "idx: " << pidx << '\n';
-                    std::cout << "lnode dim: " << get_node_dim(llevel, m_box_size) << '\n';
-                    F nc[NDim];
-                    get_node_centre(nc, lcode, m_box_size);
-                    std::cout << "lnode centre: ";
+                    // Fill in the particle position.
                     for (std::size_t j = 0; j < NDim; ++j) {
-                        std::cout << nc[j] << ", ";
+                        p_pos[j] = m_parts[j][pidx];
                     }
-                    std::cout << '\n';
-                }
 
-                // Load the particle's AABB size.
-                // NOTE: if Ordered, we must transform the original
-                // pidx, as 'it' points to a vector of aabb sizes sorted
-                // in the original order.
-                const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
-
-                // Check the aabb_size.
-                if (rakau_unlikely(!std::isfinite(aabb_size))) {
-                    throw std::invalid_argument(
-                        "A non-finite AABB size was detected while computing the collision graph");
-                }
+                    // Compute the clamped codes of the AABB vertices.
+                    // TODO: remove vertices.
+                    const auto tcga = detail::tree_coll_get_aabb<UInt>(p_pos, aabb_size, inv_box_size);
+                    const auto &aabb_codes = tcga.second;
+
+                    // Fetch the number of vertices.
+                    // TODO remove uncvref_t.
+                    constexpr auto n_vertices = std::tuple_size_v<uncvref_t<decltype(aabb_codes)>>;
+
+                    // Check if the particle straddles.
+                    // NOTE: the idea here is that the codes for all positions in the current node share
+                    // the same initial llevel*NDim digits, which we can determine from the particle code.
+                    const auto straddles = [llevel, &aabb_codes, pcode = m_codes[pidx]]() {
+                        const auto shift_amount = (cbits - llevel) * NDim;
+                        const auto common_prefix = pcode >> shift_amount;
+
+                        for (std::size_t i = 0; i < n_vertices; ++i) {
+                            if (aabb_codes[i] >> shift_amount != common_prefix) {
+                                return true;
+                            }
+                        }
 
-                // Particles with a null AABB don't participate in collision
-                // detection.
-                if (aabb_size == F(0)) {
-                    continue;
-                }
+                        return false;
+                    }();
 
-                // Fill in the particle position and min/max aabb coordinates.
-                for (std::size_t j = 0; j < NDim; ++j) {
-                    p_pos[j] = m_parts[j][pidx];
-                    min_aabb[j] = p_pos[j] - aabb_size * (F(1) / F(2));
-                    max_aabb[j] = p_pos[j] + aabb_size * (F(1) / F(2));
-                }
+                    if (!straddles) {
+                        // The particle does not straddle, move on.
+                        continue;
+                    }
 
-                // Helper to run AABB collision detection between the
-                // current particle and all the particles in the input
-                // node.
-                auto aabb_node_coll = [this, pidx, it, &max_aabb, &min_aabb, &cgraph](const auto &node) {
-                    for (auto idx_other = node.begin; idx_other != node.end; ++idx_other) {
-                        if (idx_other == pidx) {
-                            // Don't self collision check.
-                            continue;
-                        }
+                    // The particle straddles. To know into which leaf nodes it straddles,
+                    // the first step is to construct a set of adjacent nodes which are guaranteed
+                    // to contain the AABB of pidx. We can do that by establishing for each AABB
+                    // vertex the smallest node of size greater than aabb_size that contains
+                    // the vertex. The set of equal-sized nodes thus determined will completely
+                    // enclose the AABB of pidx. We will then figure out which leaf nodes
+                    // overlap the enclosing node set.
 
-                        // Load the other AABB size.
-                        const auto other_aabb_size = Ordered ? *(it + m_perm[idx_other]) : *(it + idx_other);
+                    // Convert the AABB size to a node level.
+                    const auto aabb_level = coll_size_to_level(aabb_size);
 
-                        if (other_aabb_size == F(0)) {
-                            // Null AABB, particle does not participate
-                            // in collision detection.
+                    // Iterate over the AABB vertices.
+                    for (std::size_t i = 0; i < n_vertices; ++i) {
+                        // Compute the code of the node at level aabb_level
+                        // that encloses the vertex.
+                        const auto s_code
+                            = (aabb_codes[i] >> ((cbits - aabb_level) * NDim)) + (UInt(1) << (aabb_level * NDim));
+
+                        if (aabb_level >= llevel && s_code >> ((aabb_level - llevel) * NDim) == lcode) {
+                            // The s_code node fits within the current leaf node,
+                            // no need for further checks (i.e., s_code does not overlap
+                            // with any leaf node other than the original one).
                             continue;
                         }
 
-                        // Check AABB overlap.
-                        bool overlap = true;
-                        for (std::size_t j = 0; j < NDim; ++j) {
-                            // NOTE: if other_aabb_size is NaN, the comparisons
-                            // below will both be false and no collision
-                            // will be registered. Later, when we do the collision
-                            // detection for idx_other, we will be checking for
-                            // NaN the aabb_size (see above) and an exception will fire.
-                            const auto min2 = m_parts[j][idx_other] - other_aabb_size * (F(1) / F(2));
-                            const auto max2 = m_parts[j][idx_other] + other_aabb_size * (F(1) / F(2));
-
-                            if (!(max_aabb[j] > min2 && min_aabb[j] < max2)) {
-                                overlap = false;
-                                break;
-                            }
-                        }
-
-                        if (overlap) {
-                            // if (pidx == 102u) {
-                            //     std::cout << "102 first collides with: " << idx_other << '\n';
-                            // }
-                            // if (pidx == 107u) {
-                            //     std::cout << "107 first collides with: " << idx_other << '\n';
-                            // }
-                            // if (idx_other == 102u) {
-                            //     std::cout << "102 second collides with: " << pidx << '\n';
-                            // }
-                            // if (idx_other == 107u) {
-                            //     std::cout << "107 second collides with: " << pidx << '\n';
-                            // }
-
-                            // Register the collision for the particle pidx.
-                            if constexpr (Ordered) {
-                                cgraph[m_perm[pidx]].push_back(m_perm[idx_other]);
-                                cgraph[m_perm[idx_other]].push_back(m_perm[pidx]);
-                            } else {
-                                cgraph[pidx].push_back(idx_other);
-                                cgraph[idx_other].push_back(pidx);
+                        // Determine the code range encompassed by s_code.
+                        const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, aabb_level);
+
+                        // In the set of leaf nodes, determine either the last node whose
+                        // code range precedes s_code_range, or the first one whose code
+                        // range has some overlap with s_code range.
+                        auto l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
+                            const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                            return n_max < p.first;
+                        });
+
+                        // Now determine the first node whose code range follows s_code_range.
+                        // NOTE: in upper_bound(), the comparator parameter types are flipped around
+                        // wrt lower_bound().
+                        // NOTE: start the search from l_begin, determined above, as we know
+                        // that l_end must be l_begin or an iterator following it.
+                        const auto l_end
+                            = std::upper_bound(l_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
+                                  const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                                  return p.second < n_min;
+                              });
+
+                        // Iterate over the leaf node range, and add pidx as extra particle
+                        // to each leaf node.
+                        for (; l_begin != l_end; ++l_begin) {
+                            // NOTE: don't add pidx as an extra particle
+                            // to its original node.
+                            if (l_begin->code != lcode) {
+                                // NOTE: we checked earlier that c_begin's
+                                // diff type can represent v_add.size().
+                                v_add[static_cast<decltype(v_add.size())>(l_begin - c_begin)].push_back(pidx);
                             }
                         }
                     }
-                };
-
-                // Do the collision detection with the other
-                // particles in the leaf node.
-                aabb_node_coll(lnode);
+                }
+            }
+        });
+    });
 
-                // Now we need to establish
-                // if the particle pidx straddles outside the leaf node,
-                // in which case we will have to run collision detection
-                // with other leaf nodes.
+    tg.wait();
 
-                // Compute the AABB vertices and the corresponding clamped codes.
-                const auto tcga = detail::tree_coll_get_aabb<UInt>(p_pos, aabb_size, inv_box_size);
-                const auto &aabb_vertices = tcga.first;
-                const auto &aabb_codes = tcga.second;
+#if !defined(NDEBUG)
+    // Verify v_add.
+    for (decltype(v_add.size()) i = 0; i < v_add.size(); ++i) {
+        const auto &v = v_add[i];
+        for (auto idx : v) {
+            // The indices of the extra particles cannot
+            // be referring to particles already in the node.
+            assert(idx < m_tree[clp[i]].begin || idx >= m_tree[clp[i]].end);
+        }
+    }
+#endif
 
-                // Fetch the number of vertices.
-                constexpr auto n_vertices = std::tuple_size_v<uncvref_t<decltype(aabb_vertices)>>;
+    // Build the collision graph.
+    tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &v_add, &cgraph, c_begin, it](const auto &r) {
+        // A thread local vector to store all the particle indices
+        // of a node, including the extra particles.
+        std::vector<size_type> node_indices;
 
-                // Check if the particle straddles.
-                // NOTE: the idea here is that the codes for all positions in the current node share
-                // the same initial llevel*NDim digits, which we can determine from the particle code.
-                const auto straddles = [llevel, &aabb_codes, pcode = m_codes[pidx]]() {
-                    const auto shift_amount = (cbits - llevel) * NDim;
-                    const auto common_prefix = pcode >> shift_amount;
+        // Vectors to hold the min/max aabb coordinates
+        // for a particle.
+        std::array<F, NDim> min_aabb, max_aabb;
 
-                    for (std::size_t i = 0; i < n_vertices; ++i) {
-                        if (aabb_codes[i] >> shift_amount != common_prefix) {
-                            return true;
-                        }
-                    }
+        // Iteration over the leaf nodes.
+        for (auto l_it = r.begin(); l_it != r.end(); ++l_it) {
+            // Fetch the leaf node and its vector of extra particles.
+            const auto &lnode = *l_it;
+            auto &va = v_add[static_cast<decltype(v_add.size())>(l_it - c_begin)];
+
+            // Fill in all the particle indices belonging to the node: its original
+            // particles, plus the additional ones.
+            node_indices.resize(boost::numeric_cast<decltype(node_indices.size())>(lnode.end - lnode.begin));
+            std::iota(node_indices.begin(), node_indices.end(), lnode.begin);
+            std::sort(va.begin(), va.end());
+            const auto new_va_end = std::unique(va.begin(), va.end());
+            node_indices.insert(node_indices.end(), va.begin(), new_va_end);
+
+            // Run the N**2 collision detection.
+            const auto tot_n = node_indices.size();
+            for (decltype(node_indices.size()) i = 0; i < tot_n; ++i) {
+                // Load the index of the first particle.
+                const auto idx1 = node_indices[i];
+
+                // Load the AABB size for particle idx1.
+                const auto aabb_size1 = Ordered ? *(it + m_perm[idx1]) : *(it + idx1);
+
+                if (aabb_size1 == F(0)) {
+                    // Skip collision detection for this particle
+                    // if the AABB is null.
+                    continue;
+                }
 
-                    return false;
-                }();
+                // Determine the min/max aabb coordinates for the particle idx1.
+                for (std::size_t k = 0; k < NDim; ++k) {
+                    min_aabb[k] = m_parts[k][idx1] - aabb_size1 * (F(1) / F(2));
+                    max_aabb[k] = m_parts[k][idx1] + aabb_size1 * (F(1) / F(2));
+                }
 
-                // if (pidx == 102u) {
-                //     std::cout << "102 straddles: " << straddles << '\n';
-                // }
+                for (auto j = i + 1u; j < tot_n; ++j) {
+                    // Load the index of the second particle.
+                    const auto idx2 = node_indices[j];
 
-                // if (pidx == 107u) {
-                //     std::cout << "107 straddles: " << straddles << '\n';
-                // }
+                    assert(idx1 != idx2);
 
-                if (!straddles) {
-                    // The particle does not straddle, move on.
-                    continue;
-                }
+                    // Load the AABB size for particle idx2.
+                    const auto aabb_size2 = Ordered ? *(it + m_perm[idx2]) : *(it + idx2);
 
-                // The particle straddles. To know into which leaf nodes it straddles,
-                // the first step is to construct a set of adjacent nodes which are guaranteed
-                // to contain the AABB of pidx. We can do that by establishing for each AABB
-                // vertex the smallest node of size greater than aabb_size that contains
-                // the vertex. The set of equal-sized nodes thus determined will completely
-                // enclose the AABB of pidx. We will then figure out which leaf nodes
-                // overlap the enclosing node set and test for collision with all the
-                // particles in such leaf nodes.
-
-                // Convert the AABB size to a node level.
-                const auto aabb_level = coll_size_to_level(aabb_size);
-
-                // Iterate over the AABB vertices.
-                for (std::size_t i = 0; i < n_vertices; ++i) {
-                    // Compute the code of the node at level aabb_level
-                    // that encloses the vertex.
-                    const auto s_code
-                        = (aabb_codes[i] >> ((cbits - aabb_level) * NDim)) + (UInt(1) << (aabb_level * NDim));
-
-                    if (aabb_level >= llevel && s_code >> ((aabb_level - llevel) * NDim) == lcode) {
-                        // The s_code node fits within the current leaf node.
-                        // We don't need to re-run collision detection on the same
-                        // particles as already done above.
+                    if (aabb_size2 == F(0)) {
+                        // Skip collision detection for this particle
+                        // if the AABB is null.
                         continue;
                     }
 
-                    // Determine the code range encompassed by s_code.
-                    const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, aabb_level);
-
-                    // In the set of leaf nodes, determine either the last node whose
-                    // code range precedes s_code_range, or the first one whose code
-                    // range has some overlap with s_code range.
-                    auto l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
-                        const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
-                        return n_max < p.first;
-                    });
-
-                    // Now determine the first node whose code range follows s_code_range.
-                    // NOTE: in upper_bound(), the comparator parameter types are flipped around
-                    // wrt lower_bound().
-                    const auto l_end = std::upper_bound(c_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
-                        const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
-                        return p.second < n_min;
-                    });
-
-                    // if (pidx == 102u) {
-                    //     std::cout << "102, vertex " << i << ", n nodes " << l_end - l_begin << '\n';
-                    // }
-                    // if (pidx == 107u) {
-                    //     std::cout << "107, vertex " << i << ", n nodes " << l_end - l_begin << '\n';
-                    // }
-
-                    // Iterate over the leaf node range, do the collision detection.
-                    for (; l_begin != l_end; ++l_begin) {
-                        aabb_node_coll(*l_begin);
+                    // Check for AABB overlap.
+                    bool overlap = true;
+                    for (std::size_t k = 0; k < NDim; ++k) {
+                        const auto min2 = m_parts[k][idx2] - aabb_size2 * (F(1) / F(2));
+                        const auto max2 = m_parts[k][idx2] + aabb_size2 * (F(1) / F(2));
+
+                        if (!(max_aabb[k] > min2 && min_aabb[k] < max2)) {
+                            overlap = false;
+                            break;
+                        }
+                    }
+
+                    if (overlap) {
+                        // Overlap detected, record it.
+                        if constexpr (Ordered) {
+                            cgraph[m_perm[idx1]].push_back(m_perm[idx2]);
+                            cgraph[m_perm[idx2]].push_back(m_perm[idx1]);
+                        } else {
+                            cgraph[idx1].push_back(idx2);
+                            cgraph[idx2].push_back(idx1);
+                        }
                     }
                 }
             }
@@ -485,11 +508,6 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl2(It it) const
             assert(std::find(cgraph[idx].begin(), cgraph[idx].end(), i) != cgraph[idx].end());
         }
     }
-
-    const auto acc
-        = std::accumulate(cgraph.begin(), cgraph.end(), 0ull, [](auto cur, const auto &c) { return cur + c.size(); });
-
-    std::cout << "Total number of collisions detected: " << acc / 2u << '\n';
 #endif
 
     return cgraph;
diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 32e1858..23748c6 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -588,178 +588,6 @@ inline constexpr unsigned default_ncrit =
 #endif
     ;
 
-// Return a vector of indices into the input vector of nodes, t,
-// representing the ordered set of leaf nodes.
-// NOTE: need to understand if/when/how this should be parallelised.
-template <typename Nodes>
-inline auto coll_leaves_permutation(const Nodes &t)
-{
-    using idx_t = typename Nodes::size_type;
-
-    // Prepare the output.
-    std::vector<idx_t> retval;
-    retval.reserve(static_cast<decltype(retval.size())>(t.size()));
-
-    for (idx_t i = 0; i < t.size(); ++i) {
-        if (!t[i].n_children) {
-            retval.push_back(i);
-        }
-    }
-
-    return retval;
-}
-
-// Given a particle with position p_pos and a rectangular bounding box
-// whose edges have sizes aabb_sizes, return the list of
-// the vertices of the bounding box.
-template <typename F, std::size_t NDim>
-inline auto coll_get_aabb_vertices(const std::array<F, NDim> &p_pos, const std::array<F, NDim> &aabb_sizes)
-{
-    // p_pos must contain finite values.
-    assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
-    // aabb_sizes all finite and non-negative.
-    // NOTE: empty AABBs are allowed.
-    assert(std::all_of(aabb_sizes.begin(), aabb_sizes.end(), [](F x) { return std::isfinite(x) && x >= F(0); }));
-
-    // The number of vertices of the AABB is 2**NDim.
-    static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
-    constexpr auto n_points = std::size_t(1) << NDim;
-
-    // Compute the min/max coordinates of the AABB (in 2D, the lower-left
-    // and upper-right corners of the AABB).
-    const auto aabb_minmax_coords = [&aabb_sizes, &p_pos]() {
-        std::array<std::array<F, NDim>, 2> retval;
-
-        for (std::size_t i = 0; i < NDim; ++i) {
-            const auto min_c = fma_wrap(aabb_sizes[i], -F(1) / F(2), p_pos[i]);
-            const auto max_c = fma_wrap(aabb_sizes[i], F(1) / F(2), p_pos[i]);
-
-            // Check them.
-            if (rakau_unlikely(!std::isfinite(min_c) || !std::isfinite(max_c) || min_c > max_c)) {
-                throw std::invalid_argument(
-                    "The computation of the min/max coordinates of an AABB produced the invalid pair of values ("
-                    + std::to_string(min_c) + ", " + std::to_string(max_c) + ")");
-            }
-
-            retval[0][i] = min_c;
-            retval[1][i] = max_c;
-        }
-
-        return retval;
-    }();
-
-    // The coordinates of all the points of the AABB.
-    std::array<std::array<F, NDim>, n_points> aabb_points;
-
-    // Fill in aabb_points. The idea here is that
-    // we need to generate all the 2**NDim possible combinations of min/max
-    // aabb coordinates. We do it via the bit-level representation
-    // of the numbers from 0 to 2**NDim - 1u. For instance, in 3 dimensions,
-    // we have the numbers from 0 to 7 included:
-    //
-    // 0 0 0 | i = 0
-    // 0 0 1 | i = 1
-    // 0 1 0 | i = 2
-    // 0 1 1 | i = 3
-    // ...
-    // 1 1 1 | i = 7
-    //
-    // We interpret a zero bit as setting the min aabb coordinate,
-    // a one bit as setting the max aabb coordinate. So, for instance,
-    // i = 3 corresponds to the aabb point (min, max, max).
-    for (std::size_t i = 0; i < n_points; ++i) {
-        for (std::size_t j = 0; j < NDim; ++j) {
-            const auto idx = (i >> j) & 1u;
-            aabb_points[i][j] = aabb_minmax_coords[idx][j];
-        }
-    }
-
-    return aabb_points;
-}
-
-// Given:
-//
-// - a particle p_pos,
-// - the level of the leaf node in which the
-//   particle resides (llevel),
-// - a bounding box with sizes aabb_sizes,
-// - a domain size of 1/inv_box_size,
-//
-// compute the code of the smallest node not smaller than the leaf node
-// that contains the particle and its aabb (that is, the return
-// value will be the code of the leaf node or of one of its ancestors).
-template <typename F, std::size_t NDim, typename UInt>
-inline UInt coll_get_enclosing_node(const std::array<F, NDim> &p_pos, const UInt &llevel,
-                                    const std::array<F, NDim> &aabb_sizes, const F &inv_box_size)
-{
-    // The number of vertices of the AABB is 2**NDim.
-    static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
-    constexpr auto n_points = std::size_t(1) << NDim;
-
-    // Get the list of vertices of the AABB.
-    const auto aabb_vertices = coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    // Compute their clamped codes, and shift them down by (cbits - llevel) * NDim.
-    // We do this because we want to produce a nodal code
-    // whose level is llevel or lower, thus we already know we need
-    // to throw away some information from the lower bits of the AABB codes.
-    const auto shift_amount = (cbits_v<UInt, NDim> - llevel) * NDim;
-    std::array<UInt, n_points> aabb_codes;
-    std::array<UInt, NDim> tmp;
-    morton_encoder<NDim, UInt> me;
-    for (std::size_t i = 0; i < n_points; ++i) {
-        for (std::size_t j = 0; j < NDim; ++j) {
-            // NOTE: discretize with clamping.
-            tmp[j] = disc_single_coord<NDim, UInt, true>(aabb_vertices[i][j], inv_box_size);
-        }
-        const auto code = me(tmp.data());
-        aabb_codes[i] = code >> shift_amount;
-    }
-
-    // Small helper to check if all codes in aabb_codes are equal.
-    auto check_equal_aabb_codes = [&aabb_codes]() {
-        const auto cmp = aabb_codes[0];
-        for (std::size_t i = 1; i < n_points; ++i) {
-            if (aabb_codes[i] != cmp) {
-                return false;
-            }
-        }
-        return true;
-    };
-
-    // The level of the output node. It will be
-    // llevel or lower.
-    auto out_level = llevel;
-
-    // Keep on shifting down the codes until they are all the same.
-    // In other words, establish the common prefix of all codes.
-    while (!check_equal_aabb_codes()) {
-        for (auto &c : aabb_codes) {
-            c >>= NDim;
-        }
-        assert(out_level > 0u);
-        --out_level;
-    }
-
-    // We have now the common prefix. Add a 1 bit on top
-    // to produce the nodal code and return it.
-    auto retval = aabb_codes[0] + (UInt(1) << (out_level * NDim));
-
-#if !defined(NDEBUG)
-    // Check that the original particle code starts with
-    // aabb_codes[0] (the common prefix).
-    for (std::size_t i = 0; i < NDim; ++i) {
-        tmp[i] = disc_single_coord<NDim, UInt>(p_pos[i], inv_box_size);
-    }
-    auto orig_code = morton_encoder<NDim, UInt>{}(tmp.data());
-    // Shift it down the required number of levels.
-    orig_code >>= (cbits_v<UInt, NDim> - out_level) * NDim;
-    assert(orig_code == aabb_codes[0]);
-#endif
-
-    return retval;
-}
-
 } // namespace detail
 
 namespace kwargs
@@ -3658,545 +3486,19 @@ class tree
 private:
     auto coll_leaves_permutation() const;
     UInt coll_size_to_level(F) const;
-
-    // Compute the codes of the vertices of an AABB of size aabb_size around
-    // the point p_pos. The coordinates of the AABB vertices will be clamped
-    // to the domain boundaries (via inv_box_size).
-    static auto coll_get_aabb_codes(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
-    {
-        // p_pos must contain finite values.
-        assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
-        // aabb_size finite and non-negative.
-        // NOTE: empty AABBs are allowed.
-        assert(std::isfinite(aabb_size) && aabb_size >= F(0));
-
-        // The number of vertices of the AABB is 2**NDim.
-        static_assert(NDim < unsigned(std::numeric_limits<std::size_t>::digits), "Overflow error.");
-        constexpr auto n_points = std::size_t(1) << NDim;
-
-        // Compute the min/max coordinates of the AABB (in 2D, the lower-left
-        // and upper-right corners of the AABB).
-        const auto aabb_minmax_coords = [half = aabb_size * (F(1) / F(2)), &p_pos]() {
-            std::array<std::array<F, NDim>, 2> retval;
-
-            for (std::size_t i = 0; i < NDim; ++i) {
-                const auto min_c = p_pos[i] - half;
-                const auto max_c = p_pos[i] + half;
-
-                // Check them.
-                if (rakau_unlikely(!std::isfinite(min_c) || !std::isfinite(max_c) || min_c > max_c)) {
-                    throw std::invalid_argument(
-                        "The computation of the min/max coordinates of an AABB produced the invalid pair of values ("
-                        + std::to_string(min_c) + ", " + std::to_string(max_c) + ")");
-                }
-
-                retval[0][i] = min_c;
-                retval[1][i] = max_c;
-            }
-
-            return retval;
-        }();
-
-        // The return value.
-        std::array<UInt, n_points> aabb_codes;
-
-        // Fill in aabb_codes. The idea here is that
-        // we need to generate all the 2**NDim possible combinations of min/max
-        // aabb coordinates. We do it via the bit-level representation
-        // of the numbers from 0 to 2**NDim - 1u. For instance, in 3 dimensions,
-        // we have the numbers from 0 to 7 included:
-        //
-        // 0 0 0 | i = 0
-        // 0 0 1 | i = 1
-        // 0 1 0 | i = 2
-        // 0 1 1 | i = 3
-        // ...
-        // 1 1 1 | i = 7
-        //
-        // We interpret a zero bit as setting the min aabb coordinate,
-        // a one bit as setting the max aabb coordinate. So, for instance,
-        // i = 3 corresponds to the aabb point (min, max, max).
-        std::array<UInt, NDim> tmp_disc;
-        morton_encoder<NDim, UInt> me;
-        for (std::size_t i = 0; i < n_points; ++i) {
-            for (std::size_t j = 0; j < NDim; ++j) {
-                const auto idx = (i >> j) & 1u;
-                // NOTE: discretize with clamping.
-                tmp_disc[j] = disc_single_coord<NDim, UInt, true>(aabb_minmax_coords[idx][j], inv_box_size);
-            }
-            aabb_codes[i] = me(tmp_disc.data());
-        }
-
-        return aabb_codes;
-    }
-
-    // Given a nodal code and its level, determine the
-    // closed range of [min, max] highest level codes
-    // (that is, positional codes with an extra 1 bit on top)
-    // belonging to the node.
-    std::pair<UInt, UInt> coll_code_to_range(UInt code, UInt level) const
-    {
-        assert(detail::tree_level<NDim>(code) == level);
-
-        const auto shift_amount = (cbits - level) * NDim;
-
-        assert(unsigned(std::numeric_limits<UInt>::digits) >= shift_amount);
-
-        // Move up, right filling zeroes.
-        const UInt min = code << shift_amount;
-        // Turn the filling zeroes into ones.
-        const UInt max = min + (UInt(-1) >> (unsigned(std::numeric_limits<UInt>::digits) - shift_amount));
-
-        return std::pair{min, max};
-    }
-
-    // Implementation of the computation of the collision graph.
-    template <bool Ordered, typename It>
-    auto compute_cgraph_impl(It it) const
-    {
-        simple_timer st("overall cgraph computation");
-
-        // Check that we can index into It at least
-        // up to the number of particles.
-        it_diff_check<It>(m_parts[0].size());
-
-        // Run in parallel independent computations.
-        tbb::task_group tg;
-
-        decltype(coll_leaves_permutation()) clp;
-        std::vector<std::vector<size_type>> cgraph;
-        std::vector<tbb::concurrent_vector<size_type>> v_add;
-
-        tg.run([this, &cgraph]() {
-            simple_timer st("cgraph prepare");
-            cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
-        });
-
-        tg.run([this, &clp, &v_add, it]() {
-            // Determine the permutation indices over the
-            // leaf nodes.
-            clp = coll_leaves_permutation();
-
-            // Create the iterators for accessing the leaf nodes.
-            // NOTE: make sure we don't overflow when indexing.
-            it_diff_check<decltype(m_tree.begin())>(m_tree.size());
-            auto c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
-            auto c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
-
-            // Pre-compute the inverse of the domain size.
-            const auto inv_box_size = F(1) / m_box_size;
-
-            simple_timer st("v_add computation");
-            // Prepare the data structure for recording the additional
-            // particles for each leaf node.
-            // TODO in parallel?
-            v_add.resize(boost::numeric_cast<decltype(v_add.size())>(clp.size()));
-
-            // Fill in v_add. We will be first accumulating into thread local
-            // temporaries, and we will then merge the partial results in v_add.
-            using local_map_t = std::vector<std::vector<size_type>>;
-            tbb::enumerable_thread_specific<local_map_t> local_maps(
-                local_map_t(boost::numeric_cast<typename local_map_t::size_type>(clp.size())));
-
-            tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &local_maps, it, inv_box_size, c_begin,
-                                                                   c_end](const auto &r) {
-                // Temporary vector for the particle position.
-                std::array<F, NDim> tmp;
-
-                // Get out a reference to the local map.
-                auto &lmap = local_maps.local();
-
-                // Iteration over the leaf nodes.
-                for (const auto &lnode : r) {
-                    // Fetch/cache some properties of the leaf node.
-                    const auto lcode = lnode.code;
-                    const auto llevel = detail::tree_level<NDim>(lcode);
-
-                    // Iterate over the particles of the leaf node.
-                    const auto e = lnode.end;
-                    for (auto pidx = lnode.begin; pidx != e; ++pidx) {
-                        // Fill in the particle position and load the particle's AABB size.
-                        // NOTE: if Ordered, we must transform the original
-                        // pidx, as 'it' points to a vector of aabb sizes sorted
-                        // in the original order.
-                        const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
-                        for (std::size_t j = 0; j < NDim; ++j) {
-                            tmp[j] = m_parts[j][pidx];
-                        }
-
-                        // Fetch the particle code.
-                        const auto pcode = m_codes[pidx];
-
-                        // Compute the clamped codes of the AABB vertices.
-                        const auto aabb_codes = coll_get_aabb_codes(tmp, aabb_size, inv_box_size);
-                        constexpr auto n_aabb_codes = std::tuple_size_v<std::remove_const_t<decltype(aabb_codes)>>;
-
-                        // Array of flags identifying AABB vertices which straddle. Inited
-                        // to all false.
-                        std::array<bool, n_aabb_codes> straddle_flags{};
-
-                        // Flag the straddling AABB vertices.
-                        // NOTE: the idea here is that the codes for all positions in the current node share
-                        // the same initial llevel*NDim digits, which we can determine from pcode.
-                        const auto n_straddle = [llevel, &aabb_codes, &straddle_flags, pcode]() {
-                            std::size_t retval = 0;
-                            const auto shift_amount = (cbits - llevel) * NDim;
-                            const auto common_prefix = pcode >> shift_amount;
-
-                            for (std::size_t i = 0; i < n_aabb_codes; ++i) {
-                                if (aabb_codes[i] >> shift_amount != common_prefix) {
-                                    straddle_flags[i] = true;
-                                    ++retval;
-                                }
-                            }
-
-                            return retval;
-                        }();
-
-                        if (!n_straddle) {
-                            // No AABB vertices straddle, move to the next particle.
-                            continue;
-                        }
-
-                        // The particle straddles. We need to identify the other
-                        // leaf nodes into which it straddles.
-                        // For each straddling vertex V of the AABB, we will be looking
-                        // in the tree for the node N which contains V and
-                        // whose size is greater than the AABB size, and we will
-                        // add the particle to all the leaf nodes inside N.
-
-                        // Convert the AABB size to a node level.
-                        // NOTE: we implicitly checked above, when computing the aabb_codes,
-                        // that the AABB sizes stored in 'it' are finite and non-negative.
-                        const auto aabb_level = coll_size_to_level(aabb_size);
-
-                        for (std::size_t i = 0; i < n_aabb_codes; ++i) {
-                            if (!straddle_flags[i]) {
-                                // The current vertex does not straddle, skip it.
-                                continue;
-                            }
-
-                            // Compute the code of the node at level aabb_level
-                            // that encloses the straddling vertex.
-                            const auto s_code
-                                = (aabb_codes[i] >> ((cbits - aabb_level) * NDim)) + (UInt(1) << (aabb_level * NDim));
-
-                            // Determine the range of nodal codes for the s_code node.
-                            const auto blappo = coll_code_to_range(s_code, aabb_level);
-
-                            // The last that fully precedes, or the first which overlaps.
-                            auto l_begin
-                                = std::lower_bound(c_begin, c_end, blappo, [this](const auto &n, const auto &p) {
-                                      const auto [n_min, n_max] = coll_code_to_range(n.code, n.level);
-                                      return n_max < p.first;
-                                  });
-
-                            // The first that is completely after.
-                            auto l_end = std::upper_bound(c_begin, c_end, blappo, [this](const auto &p, const auto &n) {
-                                const auto [n_min, n_max] = coll_code_to_range(n.code, n.level);
-                                return p.second < n_min;
-                            });
-
-                            for (; l_begin != l_end; ++l_begin) {
-                                lmap[l_begin - c_begin].push_back(pidx);
-                            }
-                        }
-                    }
-                }
-            });
-
-            // Merge the local maps into v_add.
-            tbb::parallel_for(tbb::blocked_range(local_maps.begin(), local_maps.end()), [&v_add](const auto &r) {
-                for (auto &lmap : r) {
-                    for (decltype(lmap.size()) i = 0; i < lmap.size(); ++i) {
-                        auto &v = lmap[i];
-                        std::sort(v.begin(), v.end());
-                        v.erase(std::unique(v.begin(), v.end()), v.end());
-
-                        v_add[i].grow_by(v.begin(), v.end());
-                    }
-                }
-            });
-        });
-
-        tg.wait();
-
-        return cgraph;
-
-#if 0
-        // The return value.
-        std::vector<tbb::concurrent_unordered_set<size_type>> cgraph;
-
-        // The vector holding the extra particles (the straddlers)
-        // for every leaf node of the tree.
-        // NOTE: for consistency with the particle indices
-        // in the original leaf node structure, we will store
-        // in v_extra indices referring to the internal tree
-        // order. We will translate them to indices in the original
-        // order, if needed, only at the very end.
-        std::vector<tbb::concurrent_vector<size_type>> v_extra;
-
-        // The vector for iterating over the leaf nodes.
-        decltype(detail::coll_leaves_permutation(m_tree, leaf_level)) clp;
-
-        tbb::task_group tg;
-
-        tg.run([this, &v_extra, &clp, it, leaf_level]() {
-            simple_timer st_vextra("vextra computation");
-
-            // Compute the permutation to iterate over the leaf nodes, and prepare
-            // the container of the extra particles for each leaf node.
-            clp = detail::coll_leaves_permutation(m_tree, leaf_level);
-            v_extra.resize(boost::numeric_cast<decltype(v_extra.size())>(clp.size()));
-
-            using local_map_t = std::vector<boost::container::small_vector<size_type, 1u>>;
-            tbb::enumerable_thread_specific<local_map_t> local_maps(
-                local_map_t(boost::numeric_cast<typename local_map_t::size_type>(clp.size())));
-
-            // Pre-compute the inverse of the domain size.
-            const auto inv_box_size = F(1) / m_box_size;
-
-            // Determine the straddling particles that need to be added to the leaf nodes.
-            tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()),
-                              [this, &clp, &v_extra, it, inv_box_size, &local_maps](const auto &r) {
-                                  // Temporary vector for the particle position
-                                  // and the sizes of the AABB.
-                                  std::array<F, NDim> tmp, aabb_sizes;
-
-                                  // Extract the reference to the local map.
-                                  auto &local_map = local_maps.local();
-
-                                  for (auto i = r.begin(); i != r.end(); ++i) {
-                                      // Fetch/cache some properties of the leaf node.
-                                      const auto &lnode = m_tree[clp[i]];
-                                      const auto lcode = lnode.code;
-                                      const auto llevel = detail::tree_level<NDim>(lcode);
-
-                                      // Iterate over the particles of the leaf node.
-                                      const auto e = lnode.end;
-                                      for (auto pidx = lnode.begin; pidx != e; ++pidx) {
-                                          // Fill in the tmp vectors for the particle pos
-                                          // and AABB.
-                                          // NOTE: if Ordered, we must transform the original
-                                          // pidx, as 'it' points to a vector of aabb sizes sorted
-                                          // in the original order.
-                                          const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
-                                          for (std::size_t j = 0; j < NDim; ++j) {
-                                              tmp[j] = m_parts[j][pidx];
-                                              aabb_sizes[j] = aabb_size;
-                                          }
-
-                                          // Compute the code of the enclosing node for the
-                                          // current particle.
-                                          const auto ecode
-                                              = detail::coll_get_enclosing_node(tmp, llevel, aabb_sizes, inv_box_size);
-
-                                          if (ecode == lcode) {
-                                              // The enclosing node is the leaf node
-                                              // itself, don't do anything.
-                                              continue;
-                                          }
-
-                                          // The enclosing node is an ancestor of the
-                                          // leaf node. We need to add the current particle
-                                          // to all the leaf nodes which are children of
-                                          // the enclosing node.
-                                          // We will be iterating over the set of all leaf nodes
-                                          // starting from the current one. We will move backwards
-                                          // and forward until we have identified all the children nodes
-                                          // of the enclosing node.
-
-                                          // Small helper to establish if the node with the input code
-                                          // is a child of the enclosing node.
-                                          auto is_child
-                                              = [ecode_level = detail::tree_level<NDim>(ecode), ecode](UInt code) {
-                                                    const auto level = detail::tree_level<NDim>(code);
-
-                                                    if (level < ecode_level) {
-                                                        // The input node has a lower level than
-                                                        // the enclosing node, it cannot be one of its
-                                                        // children.
-                                                        return false;
-                                                    }
-
-                                                    if ((code >> ((level - ecode_level) * NDim)) != ecode) {
-                                                        // The input code does not start with ecode: it belongs
-                                                        // to another branch of the tree.
-                                                        return false;
-                                                    }
-
-                                                    return true;
-                                                };
-
-                                          // The backwards iteration.
-                                          auto j = i;
-                                          while (j) {
-                                              if (!is_child(m_tree[clp[--j]].code)) {
-                                                  break;
-                                              }
-                                              local_map[j].push_back(pidx);
-                                          }
-
-                                          // The forward iteration.
-                                          for (j = i + 1u; j < clp.size(); ++j) {
-                                              if (!is_child(m_tree[clp[j]].code)) {
-                                                  break;
-                                              }
-                                              local_map[j].push_back(pidx);
-                                          }
-                                      }
-                                  }
-                              });
-
-            for (const auto &lm : local_maps) {
-                auto acc = 0ull;
-                std::cout << std::accumulate(lm.begin(), lm.end(), 0ull, [](auto cur, const auto &v) {
-                    return cur + v.size();
-                }) << ", ";
-            }
-            std::cout << '\n';
-            tbb::parallel_for(tbb::blocked_range(local_maps.begin(), local_maps.end()), [&v_extra](const auto &r) {
-                for (auto it = r.begin(); it != r.end(); ++it) {
-                    const auto &lm = *it;
-                    const auto lm_size = lm.size();
-
-                    for (decltype(lm.size()) i = 0; i < lm_size; ++i) {
-                        const auto &lv = lm[i];
-                        v_extra[i].grow_by(lv.begin(), lv.end());
-                    }
-                }
-            });
-        });
-
-        // Concurrently, prepare the collision list via resize.
-        tg.run([this, &cgraph]() {
-            simple_timer st_vextra("cgraph prepare");
-            cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
-        });
-
-        tg.wait();
-
-        simple_timer st_aabb("aabb testing");
-        // Iterate over the augmented leaf nodes and run the collision detection.
-        tbb::parallel_for(tbb::blocked_range(decltype(clp.size())(0), clp.size()), [this, &clp, &v_extra, it,
-                                                                                    &cgraph](const auto &r) {
-            // Local collision graph, mapping a particle to a set
-            // of particles with which it collides.
-            // NOTE: this will always use unordered indices, we will translate
-            // to ordered indices, if necessary, at the end.
-            std::unordered_map<size_type, std::vector<size_type>> local_map;
-
-            // Temporary vector in which we store the set of particles
-            // belonging to an augmented leaf node: the set of the original
-            // particles, plus the straddlers (contained in v_extra).
-            std::vector<size_type> local_indices;
-
-            // Small helper to check for overlap between the AABBs
-            // of the two particles at indices idx1 and idx2.
-            auto aabb_overlap = [this, it](size_type idx1, size_type idx2) {
-                // Like above, we might need to access the aabb sizes in a permuted
-                // fashion, as idx1 and idx2 will refer to particle indices
-                // in the internal tree order.
-                const auto aabb_size1 = Ordered ? *(it + m_perm[idx1]) : *(it + idx1);
-                const auto aabb_size2 = Ordered ? *(it + m_perm[idx2]) : *(it + idx2);
-
-                // If either AABB has a size of zero (i.e., point particles), we don't
-                // report a collision.
-                if (aabb_size1 == F(0) || aabb_size2 == F(0)) {
-                    return false;
-                }
-
-                for (std::size_t j = 0; j < NDim; ++j) {
-                    const auto min1 = fma_wrap(aabb_size1, -F(1) / F(2), m_parts[j][idx1]);
-                    const auto max1 = fma_wrap(aabb_size1, F(1) / F(2), m_parts[j][idx1]);
-
-                    const auto min2 = fma_wrap(aabb_size2, -F(1) / F(2), m_parts[j][idx2]);
-                    const auto max2 = fma_wrap(aabb_size2, F(1) / F(2), m_parts[j][idx2]);
-
-                    if (!(max1 > min2 && min1 < max2)) {
-                        return false;
-                    }
-                }
-
-                return true;
-            };
-
-            for (auto i = r.begin(); i != r.end(); ++i) {
-                // Fetch references to the leaf node and its
-                // extra particles.
-                const auto &lnode = m_tree[clp[i]];
-                const auto &extras = v_extra[i];
-
-                // Fill in the full set of particles belonging to this node: the
-                // original ones, plus those from v_extra.
-                const auto orig_size = lnode.end - lnode.begin;
-                local_indices.resize(boost::numeric_cast<decltype(local_indices.size())>(orig_size + extras.size()));
-                std::iota(local_indices.data(), local_indices.data() + orig_size, lnode.begin);
-                std::copy(extras.begin(), extras.end(), local_indices.data() + orig_size);
-
-                // Check AABB overlaps over all the particles.
-                const auto ls = local_indices.size();
-                for (decltype(local_indices.size()) j0 = 0; j0 < ls; ++j0) {
-                    const auto pidx0 = local_indices[j0];
-                    for (auto j1 = j0 + 1u; j1 < ls; ++j1) {
-                        const auto pidx1 = local_indices[j1];
-
-                        if (aabb_overlap(pidx0, pidx1)) {
-                            // NOTE: we use the unordered indices
-                            // for the local map. We will be transforming
-                            // to ordered indices, if necessary,
-                            // only when merging the local map
-                            // into the global one.
-                            local_map[pidx0].push_back(pidx1);
-                            local_map[pidx1].push_back(pidx0);
-                        }
-                    }
-                }
-            }
-
-            // Merge the local collision graph into the global one, translating
-            // the indices on the fly if necessary.
-            for (const auto &[idx, v] : local_map) {
-                if constexpr (Ordered) {
-                    auto idx_transform = [this](auto n) { return m_perm[n]; };
-                    cgraph[static_cast<decltype(cgraph.size())>(m_perm[idx])].insert(
-                        boost::make_transform_iterator(v.begin(), idx_transform),
-                        boost::make_transform_iterator(v.end(), idx_transform));
-                } else {
-                    cgraph[static_cast<decltype(cgraph.size())>(idx)].insert(v.begin(), v.end());
-                }
-            }
-        });
-
-#if !defined(NDEBUG)
-        // Verify the collision graph.
-        for (decltype(cgraph.size()) i = 0; i < cgraph.size(); ++i) {
-            for (auto idx : cgraph[i]) {
-                assert(idx < cgraph.size());
-                assert(std::find(cgraph[static_cast<decltype(cgraph.size())>(idx)].begin(),
-                                 cgraph[static_cast<decltype(cgraph.size())>(idx)].end(), i)
-                       != cgraph[static_cast<decltype(cgraph.size())>(idx)].end());
-            }
-        }
-#endif
-#endif
-
-        return cgraph;
-    }
-
     template <bool Ordered, typename It>
-    auto compute_cgraph_impl2(It) const;
+    auto compute_cgraph_impl(It) const;
 
 public:
     template <typename It>
     auto compute_cgraph_u(It it) const
     {
-        return compute_cgraph_impl2<false>(it);
+        return compute_cgraph_impl<false>(it);
     }
     template <typename It>
     auto compute_cgraph_o(It it) const
     {
-        return compute_cgraph_impl2<true>(it);
+        return compute_cgraph_impl<true>(it);
     }
 
 private:
diff --git a/test/coll.cpp b/test/coll.cpp
index 08edfbd..6890105 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -31,169 +31,10 @@ using namespace rakau_test;
 
 std::mt19937 rng;
 
-TEST_CASE("coll_leaves_permutation")
-{
-    // Empty tree.
-    octree<double> t;
-    auto perm = detail::coll_leaves_permutation(t.nodes());
-    REQUIRE(perm.empty());
-
-    // Fill it in with some particles.
-    const auto bsize = 1.;
-    const auto s = 10000u;
-    auto parts = get_uniform_particles<3>(s, bsize, rng);
-    t = octree<double>{x_coords = parts.begin() + s,
-                       y_coords = parts.begin() + 2u * s,
-                       z_coords = parts.begin() + 3u * s,
-                       masses = parts.begin(),
-                       nparts = s,
-                       box_size = bsize};
-    perm = detail::coll_leaves_permutation(t.nodes());
-    auto p_begin = boost::make_permutation_iterator(t.nodes().begin(), perm.begin());
-    auto p_end = boost::make_permutation_iterator(t.nodes().end(), perm.end());
-    // Check the output is sorted.
-    auto node_sorter = [](const auto &n1, const auto &n2) { return detail::node_compare<3>(n1.code, n2.code); };
-    REQUIRE(std::is_sorted(p_begin, p_end, node_sorter));
-    // Check the output contains all particles.
-    REQUIRE(std::accumulate(p_begin, p_end, 0u,
-                            [](auto cur, const auto &n) { return cur + static_cast<unsigned>(n.end - n.begin); })
-            == s);
-}
-
-TEST_CASE("coll_get_aabb_vertices_2d")
-{
-    using v2d = std::array<double, 2>;
-
-    // Empty aabb.
-    v2d p_pos = {.5, .5};
-    v2d aabb_sizes = {0., 0.};
-
-    auto ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::all_of(ret.begin(), ret.end(), [p_pos](const auto &v) { return v == p_pos; }));
-
-    aabb_sizes = {.25, .25};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .375}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .625}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .625}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .375}) != ret.end());
-
-    aabb_sizes = {.25, .25 / 2};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .4375}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .5625}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.375, .5625}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{.625, .4375}) != ret.end());
-
-    // Try a negative coord.
-    p_pos = {-.5, .5};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.625, .4375}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.375, .5625}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.625, .5625}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-.375, .4375}) != ret.end());
-
-    p_pos = {9., 9.};
-    aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., 11.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., 11.}) != ret.end());
-
-    p_pos = {9., -9.};
-    aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{7., -11.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{11., -11.}) != ret.end());
-
-    p_pos = {-9., 9.};
-    aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., 11.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., 7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., 11.}) != ret.end());
-
-    p_pos = {-9., -9.};
-    aabb_sizes = {4., 4.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-7., -11.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., -7.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-11., -11.}) != ret.end());
-
-    p_pos = {0., 0.};
-    aabb_sizes = {40., 40.};
-    ret = detail::coll_get_aabb_vertices(p_pos, aabb_sizes);
-
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-20., 20.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{20., -20.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{-20., -20.}) != ret.end());
-    REQUIRE(std::find(ret.begin(), ret.end(), v2d{20., 20.}) != ret.end());
-}
-
-TEST_CASE("coll_get_enclosing_node_2d")
-{
-    using v2d = std::array<double, 2>;
-
-    // Particle at the origin, straddling all 4 children.
-    v2d pos{0., 0.};
-    v2d aabb_sizes{1., 1.};
-
-    auto ncode = detail::coll_get_enclosing_node(pos, std::size_t(0), aabb_sizes, .0625);
-    REQUIRE(ncode == 1u);
-
-    // Move it only slightly, still straddling.
-    pos = {.1, .1};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 1u);
-
-    // Place it fully in all quadrants..
-    pos = {1., 1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 7u);
-
-    pos = {-1., 1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 6u);
-
-    pos = {-1., -1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 4u);
-
-    // Straddle 2 quadrants.
-    pos = {1., 0.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 1u);
-
-    pos = {0., 1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 1u);
-
-    pos = {-1., 0.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 1u);
-
-    pos = {0., -1.};
-    ncode = detail::coll_get_enclosing_node(pos, std::size_t(1), aabb_sizes, .0625);
-    REQUIRE(ncode == 1u);
-}
-
 TEST_CASE("compute_cgraph_2d")
 {
     constexpr auto bsize = 1.;
-    constexpr auto s = 1000u;
+    constexpr auto s = 200u;
 
     auto aabb_overlap = [](auto x1, auto y1, auto s1, auto x2, auto y2, auto s2) {
         if (s1 == 0 || s2 == 0) {
@@ -233,8 +74,6 @@ TEST_CASE("compute_cgraph_2d")
     // Test with a variety of aabb sizes, starting from
     // very small until encompassing the whole domain.
     for (long k = 16; k >= 0; --k) {
-        std::cout << "k=" << k << '\n';
-
         // Collision graph that will be computed with the N**2 algorithm.
         std::vector<std::vector<decltype(t)::size_type>> cmp;
         cmp.resize(s);
@@ -254,13 +93,6 @@ TEST_CASE("compute_cgraph_2d")
             }
         }
         for (auto i = 0u; i < s; ++i) {
-            if (cgraph_u[i].size() != cmp[i].size()) {
-                auto idx1 = 102u;
-                auto idx2 = 107u;
-                auto [x_it, y_it, m_it] = t.p_its_u();
-                std::cout << x_it[idx1] << ", " << y_it[idx1] << ", " << '\n';
-                std::cout << x_it[idx2] << ", " << y_it[idx2] << ", " << '\n';
-            }
             REQUIRE(cgraph_u[i].size() == cmp[i].size());
             REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
                     == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
@@ -422,7 +254,7 @@ TEST_CASE("compute_cgraph_2d")
 TEST_CASE("compute_cgraph_3d")
 {
     constexpr auto bsize = 1.;
-    constexpr auto s = 1000u;
+    constexpr auto s = 200u;
 
     auto aabb_overlap = [](auto x1, auto y1, auto z1, auto s1, auto x2, auto y2, auto z2, auto s2) {
         if (s1 == 0 || s2 == 0) {

From dbd0399802ece37ddf36d78f763fd1bbdbdfb8eb Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 14 Jul 2019 21:51:57 +0200
Subject: [PATCH 19/38] Small cleanup.

---
 include/rakau/tree.hpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 23748c6..2b96ae8 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -30,7 +30,6 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -43,9 +42,7 @@
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <tbb/blocked_range.h>
-#include <tbb/concurrent_unordered_set.h>
 #include <tbb/concurrent_vector.h>
-#include <tbb/enumerable_thread_specific.h>
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 #include <tbb/parallel_sort.h>

From 6b63c92ea07e80444d526c90b6f06d40ee9562b1 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 14 Jul 2019 21:54:20 +0200
Subject: [PATCH 20/38] WIP.

---
 include/rakau/detail/tree_coll.hpp | 34 ++++++++++++------------------
 1 file changed, 13 insertions(+), 21 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 1916372..f7620ab 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -19,6 +19,7 @@
 #include <stdexcept>
 #include <string>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -102,11 +103,11 @@ inline auto tree<NDim, F, UInt, MAC>::coll_leaves_permutation() const
 inline namespace detail
 {
 
-// Compute the coordinates and the codes of the vertices of an AABB of size aabb_size around
-// the point p_pos. When computing the codes, the coordinates of the AABB vertices will be clamped
+// Compute the codes of the vertices of an AABB of size aabb_size around
+// the point p_pos. The coordinates of the AABB vertices will be clamped
 // to the domain boundaries (via inv_box_size).
 template <typename UInt, typename F, std::size_t NDim>
-inline auto tree_coll_get_aabb(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
+inline auto tree_coll_get_aabb_codes(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
 {
     // p_pos must contain finite values.
     assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
@@ -142,11 +143,9 @@ inline auto tree_coll_get_aabb(const std::array<F, NDim> &p_pos, F aabb_size, F
     }();
 
     // The return value.
-    std::pair<std::array<std::array<F, NDim>, n_points>, std::array<UInt, n_points>> retval;
-    auto &aabb_vertices = retval.first;
-    auto &aabb_codes = retval.second;
+    std::array<UInt, n_points> aabb_codes;
 
-    // Fill in aabb_vertices and aabb_codes. The idea here is that
+    // Fill in aabb_codes. The idea here is that
     // we need to generate all the 2**NDim possible combinations of min/max
     // aabb coordinates. We do it via the bit-level representation
     // of the numbers from 0 to 2**NDim - 1u. For instance, in 3 dimensions,
@@ -165,20 +164,15 @@ inline auto tree_coll_get_aabb(const std::array<F, NDim> &p_pos, F aabb_size, F
     std::array<UInt, NDim> tmp_disc;
     morton_encoder<NDim, UInt> me;
     for (std::size_t i = 0; i < n_points; ++i) {
-        auto &cur_vertex = aabb_vertices[i];
-
         for (std::size_t j = 0; j < NDim; ++j) {
             const auto idx = (i >> j) & 1u;
-            const auto cur_c = aabb_minmax_coords[idx][j];
-
-            cur_vertex[j] = cur_c;
             // NOTE: discretize with clamping.
-            tmp_disc[j] = disc_single_coord<NDim, UInt, true>(cur_c, inv_box_size);
+            tmp_disc[j] = disc_single_coord<NDim, UInt, true>(aabb_minmax_coords[idx][j], inv_box_size);
         }
         aabb_codes[i] = me(tmp_disc.data());
     }
 
-    return retval;
+    return aabb_codes;
 }
 
 // Given a nodal code and its level, determine the
@@ -215,7 +209,7 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
     // up to the number of particles.
     detail::it_diff_check<It>(m_parts[0].size());
 
-    // The vector of permutations over the leaf nodes.
+    // The vector for iterating over the leaf nodes.
     decltype(coll_leaves_permutation()) clp;
 
     // The vector of additional particles for each leaf node.
@@ -296,13 +290,10 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                     }
 
                     // Compute the clamped codes of the AABB vertices.
-                    // TODO: remove vertices.
-                    const auto tcga = detail::tree_coll_get_aabb<UInt>(p_pos, aabb_size, inv_box_size);
-                    const auto &aabb_codes = tcga.second;
+                    const auto aabb_codes = detail::tree_coll_get_aabb_codes<UInt>(p_pos, aabb_size, inv_box_size);
 
                     // Fetch the number of vertices.
-                    // TODO remove uncvref_t.
-                    constexpr auto n_vertices = std::tuple_size_v<uncvref_t<decltype(aabb_codes)>>;
+                    constexpr auto n_vertices = std::tuple_size_v<std::remove_const_t<decltype(aabb_codes)>>;
 
                     // Check if the particle straddles.
                     // NOTE: the idea here is that the codes for all positions in the current node share
@@ -379,7 +370,8 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                             // to its original node.
                             if (l_begin->code != lcode) {
                                 // NOTE: we checked earlier that c_begin's
-                                // diff type can represent v_add.size().
+                                // diff type can represent m_tree.size() and,
+                                // by extension, v_add.size().
                                 v_add[static_cast<decltype(v_add.size())>(l_begin - c_begin)].push_back(pidx);
                             }
                         }

From 1d629938a83c0a2b5bd464dad77d9fdafe67b5ce Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 14 Jul 2019 22:41:08 +0200
Subject: [PATCH 21/38] More WIP.

---
 include/rakau/detail/tree_coll.hpp |  89 ++--
 test/coll.cpp                      | 653 +++++++++++++++--------------
 2 files changed, 386 insertions(+), 356 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index f7620ab..5228565 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -73,8 +73,6 @@ inline UInt tree<NDim, F, UInt, MAC>::coll_size_to_level(F s) const
 template <std::size_t NDim, typename F, typename UInt, mac MAC>
 inline auto tree<NDim, F, UInt, MAC>::coll_leaves_permutation() const
 {
-    simple_timer st("coll_leaves_permutation");
-
     // Prepare the output.
     std::vector<size_type> retval;
     const auto tsize = m_tree.size();
@@ -107,7 +105,14 @@ inline namespace detail
 // the point p_pos. The coordinates of the AABB vertices will be clamped
 // to the domain boundaries (via inv_box_size).
 template <typename UInt, typename F, std::size_t NDim>
-inline auto tree_coll_get_aabb_codes(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
+inline auto
+#if defined(__GNUC__)
+    // NOTE: unsure why, but disabling inlining
+    // on this function is a big performance win on some
+    // test cases. Need to investigate.
+    __attribute__((noinline))
+#endif
+    tree_coll_get_aabb_codes(const std::array<F, NDim> &p_pos, F aabb_size, F inv_box_size)
 {
     // p_pos must contain finite values.
     assert(std::all_of(p_pos.begin(), p_pos.end(), [](F x) { return std::isfinite(x); }));
@@ -209,8 +214,10 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
     // up to the number of particles.
     detail::it_diff_check<It>(m_parts[0].size());
 
-    // The vector for iterating over the leaf nodes.
+    // The vector for iterating over the leaf nodes, and the corresponding
+    // permutation iterators.
     decltype(coll_leaves_permutation()) clp;
+    decltype(boost::make_permutation_iterator(m_tree.begin(), clp.begin())) c_begin, c_end;
 
     // The vector of additional particles for each leaf node.
     std::vector<tbb::concurrent_vector<size_type>> v_add;
@@ -227,8 +234,6 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
         cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
     });
 
-    decltype(boost::make_permutation_iterator(m_tree.begin(), clp.begin())) c_begin, c_end;
-
     tg.run([this, &clp, &v_add, it, &c_begin, &c_end]() {
         {
             simple_timer st("leaves permutation");
@@ -385,21 +390,23 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
 
 #if !defined(NDEBUG)
     // Verify v_add.
-    for (decltype(v_add.size()) i = 0; i < v_add.size(); ++i) {
-        const auto &v = v_add[i];
-        for (auto idx : v) {
-            // The indices of the extra particles cannot
-            // be referring to particles already in the node.
-            assert(idx < m_tree[clp[i]].begin || idx >= m_tree[clp[i]].end);
+    tbb::parallel_for(tbb::blocked_range(decltype(v_add.size())(0), v_add.size()), [this, &clp, &v_add](const auto &r) {
+        for (auto i = r.begin(); i != r.end(); ++i) {
+            const auto &v = v_add[i];
+            for (auto idx : v) {
+                // The indices of the extra particles cannot
+                // be referring to particles already in the node.
+                assert(idx < m_tree[clp[i]].begin || idx >= m_tree[clp[i]].end);
+            }
         }
-    }
+    });
 #endif
 
     // Build the collision graph.
     tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &v_add, &cgraph, c_begin, it](const auto &r) {
         // A thread local vector to store all the particle indices
         // of a node, including the extra particles.
-        std::vector<size_type> node_indices;
+        static thread_local std::vector<size_type> node_indices;
 
         // Vectors to hold the min/max aabb coordinates
         // for a particle.
@@ -411,15 +418,19 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
             const auto &lnode = *l_it;
             auto &va = v_add[static_cast<decltype(v_add.size())>(l_it - c_begin)];
 
-            // Fill in all the particle indices belonging to the node: its original
+            // Write into node_indices all the particle indices belonging to the node: its original
             // particles, plus the additional ones.
             node_indices.resize(boost::numeric_cast<decltype(node_indices.size())>(lnode.end - lnode.begin));
             std::iota(node_indices.begin(), node_indices.end(), lnode.begin);
+            // NOTE: the vector of extra particles might contain
+            // duplicates: sort it, apply std::unique() and insert
+            // only the non-duplicate values.
             std::sort(va.begin(), va.end());
             const auto new_va_end = std::unique(va.begin(), va.end());
             node_indices.insert(node_indices.end(), va.begin(), new_va_end);
 
-            // Run the N**2 collision detection.
+            // Run the N**2 AABB overlap detection on all particles
+            // in node_indices.
             const auto tot_n = node_indices.size();
             for (decltype(node_indices.size()) i = 0; i < tot_n; ++i) {
                 // Load the index of the first particle.
@@ -461,7 +472,11 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                         const auto min2 = m_parts[k][idx2] - aabb_size2 * (F(1) / F(2));
                         const auto max2 = m_parts[k][idx2] + aabb_size2 * (F(1) / F(2));
 
-                        if (!(max_aabb[k] > min2 && min_aabb[k] < max2)) {
+                        // NOTE: we regard the AABBs as closed ranges, that is,
+                        // a single point in common in two segments is enough
+                        // to trigger an overlap condition. Thus, test with
+                        // >= and <=.
+                        if (!(max_aabb[k] >= min2 && min_aabb[k] <= max2)) {
                             overlap = false;
                             break;
                         }
@@ -482,24 +497,36 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
         }
     });
 
-    tbb::parallel_for(tbb::blocked_range(cgraph.begin(), cgraph.end()), [](const auto &r) {
-        for (auto &v : r) {
-            detail::it_diff_check<decltype(v.begin())>(v.size());
-
-            std::sort(v.begin(), v.end());
-            const auto new_end = std::unique(v.begin(), v.end());
-            v.resize(static_cast<decltype(v.size())>(new_end - v.begin()));
-        }
-    });
+    // Last step: sort+duplicate removal for the
+    // vectors in cgraph.
+    {
+        simple_timer st_cd("cgraph deduplication");
+        tbb::parallel_for(tbb::blocked_range(cgraph.begin(), cgraph.end()), [](const auto &r) {
+            for (auto &v : r) {
+                detail::it_diff_check<decltype(v.begin())>(v.size());
+
+                std::sort(v.begin(), v.end());
+                const auto new_end = std::unique(v.begin(), v.end());
+                v.resize(static_cast<decltype(v.size())>(new_end - v.begin()));
+            }
+        });
+    }
 
 #if !defined(NDEBUG)
     // Verify the collision graph.
-    for (decltype(cgraph.size()) i = 0; i < cgraph.size(); ++i) {
-        for (auto idx : cgraph[i]) {
-            assert(idx < cgraph.size());
-            assert(std::find(cgraph[idx].begin(), cgraph[idx].end(), i) != cgraph[idx].end());
+    tbb::parallel_for(tbb::blocked_range(decltype(cgraph.size())(0), cgraph.size()), [&cgraph](const auto &r) {
+        for (auto i = r.begin(); i != r.end(); ++i) {
+            for (auto idx : cgraph[i]) {
+                assert(idx < cgraph.size());
+                assert(std::is_sorted(cgraph[idx].begin(), cgraph[idx].end()));
+                const auto new_end = std::unique(cgraph[idx].begin(), cgraph[idx].end());
+                assert(new_end == cgraph[idx].end());
+                const auto lb_it = std::lower_bound(cgraph[idx].begin(), cgraph[idx].end(), i);
+                assert(lb_it != cgraph[idx].end());
+                assert(*lb_it == i);
+            }
         }
-    }
+    });
 #endif
 
     return cgraph;
diff --git a/test/coll.cpp b/test/coll.cpp
index 6890105..2345315 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -12,12 +12,8 @@
 #include "catch.hpp"
 
 #include <algorithm>
-#include <array>
-#include <cstddef>
 #include <initializer_list>
-#include <numeric>
 #include <random>
-#include <tuple>
 #include <unordered_set>
 #include <vector>
 
@@ -51,7 +47,7 @@ TEST_CASE("compute_cgraph_2d")
         auto ymin2 = y2 - s2 / 2;
         auto ymax2 = y2 + s2 / 2;
 
-        return xmax1 > xmin2 && xmin1 < xmax2 && ymax1 > ymin2 && ymin1 < ymax2;
+        return xmax1 >= xmin2 && xmin1 <= xmax2 && ymax1 >= ymin2 && ymin1 <= ymax2;
     };
 
     std::vector<double> aabb_sizes(s, 1.);
@@ -67,186 +63,189 @@ TEST_CASE("compute_cgraph_2d")
     const auto xc_o = parts.begin() + s;
     const auto yc_o = parts.begin() + 2u * s;
 
-    t = quadtree<double>{x_coords = xc_o, y_coords = yc_o, masses = parts.begin(), nparts = s, box_size = bsize};
-
-    const auto [xc_u, yc_u, m_u] = t.p_its_u();
-
-    // Test with a variety of aabb sizes, starting from
-    // very small until encompassing the whole domain.
-    for (long k = 16; k >= 0; --k) {
-        // Collision graph that will be computed with the N**2 algorithm.
-        std::vector<std::vector<decltype(t)::size_type>> cmp;
-        cmp.resize(s);
-
-        // All aabbs same (nonzero) size.
-        const auto aabb_size = 1. / static_cast<double>(1l << k);
-        std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
-
-        // Unordered testing.
-        auto cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_u[i], yc_u[i], aabb_size, xc_u[j], yc_u[j], aabb_size)) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+    for (auto mln : {1, 4, 8, 16, 400}) {
+        t = quadtree<double>{x_coords = xc_o, y_coords = yc_o,  masses = parts.begin(),
+                             nparts = s,      box_size = bsize, max_leaf_n = mln};
+
+        const auto [xc_u, yc_u, m_u] = t.p_its_u();
+
+        // Test with a variety of aabb sizes, starting from
+        // very small until encompassing the whole domain.
+        for (long k = 16; k >= 0; --k) {
+            // Collision graph that will be computed with the N**2 algorithm.
+            std::vector<std::vector<decltype(t)::size_type>> cmp;
+            cmp.resize(s);
+
+            // All aabbs same (nonzero) size.
+            const auto aabb_size = 1. / static_cast<double>(1l << k);
+            std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
+
+            // Unordered testing.
+            auto cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_u[i], yc_u[i], aabb_size, xc_u[j], yc_u[j], aabb_size)) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_u[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_u[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // Ordered testing.
-        auto cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_o[i], yc_o[i], aabb_size, xc_o[j], yc_o[j], aabb_size)) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            // Ordered testing.
+            auto cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_o[i], yc_o[i], aabb_size, xc_o[j], yc_o[j], aabb_size)) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_o[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_o[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // Set the aabb size to zero for half the points.
-        for (auto i = 0u; i < s; i += 2u) {
-            aabb_sizes[i] = 0;
-        }
-        // Build a version of aabb_sizes permuted according to the tree order.
-        auto aabb_sizes_u(aabb_sizes);
-        for (auto i = 0u; i < s; ++i) {
-            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
-        }
+            // Set the aabb size to zero for half the points.
+            for (auto i = 0u; i < s; i += 2u) {
+                aabb_sizes[i] = 0;
+            }
+            // Build a version of aabb_sizes permuted according to the tree order.
+            auto aabb_sizes_u(aabb_sizes);
+            for (auto i = 0u; i < s; ++i) {
+                aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+            }
 
-        // Redo the testing.
-        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            // Redo the testing.
+            cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_u[i].size() == cmp[i].size());
-            // If the current particle is a point, it cannot
-            // collide with anything.
-            if (aabb_sizes_u[i] == 0) {
-                REQUIRE(cgraph_u[i].empty());
-            }
-            // All the colliding particles must have nonzero size.
-            for (auto idx : cgraph_u[i]) {
-                REQUIRE(aabb_sizes_u[idx] != 0);
-            }
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_u[i].size() == cmp[i].size());
+                // If the current particle is a point, it cannot
+                // collide with anything.
+                if (aabb_sizes_u[i] == 0) {
+                    REQUIRE(cgraph_u[i].empty());
+                }
+                // All the colliding particles must have nonzero size.
+                for (auto idx : cgraph_u[i]) {
+                    REQUIRE(aabb_sizes_u[idx] != 0);
+                }
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_o[i].size() == cmp[i].size());
-            // If the current particle is a point, it cannot
-            // collide with anything.
-            if (aabb_sizes[i] == 0) {
-                REQUIRE(cgraph_o[i].empty());
-            }
-            // All the colliding particles must have nonzero size.
-            for (auto idx : cgraph_o[i]) {
-                REQUIRE(aabb_sizes[idx] != 0);
-            }
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_o[i].size() == cmp[i].size());
+                // If the current particle is a point, it cannot
+                // collide with anything.
+                if (aabb_sizes[i] == 0) {
+                    REQUIRE(cgraph_o[i].empty());
+                }
+                // All the colliding particles must have nonzero size.
+                for (auto idx : cgraph_o[i]) {
+                    REQUIRE(aabb_sizes[idx] != 0);
+                }
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // Try different sizes.
-        for (auto i = 0u; i < s; ++i) {
-            aabb_sizes[i] += aabb_sizes[i] / (i + 1u);
-        }
-        aabb_sizes_u = aabb_sizes;
-        for (auto i = 0u; i < s; ++i) {
-            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
-        }
+            // Try different sizes.
+            for (auto i = 0u; i < s; ++i) {
+                aabb_sizes[i] += aabb_sizes[i] / (i + 1u);
+            }
+            aabb_sizes_u = aabb_sizes;
+            for (auto i = 0u; i < s; ++i) {
+                aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+            }
 
-        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_u[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_u[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_o[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_o[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // All zero aabb sizes.
-        std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
+            // All zero aabb sizes.
+            std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
 
-        cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
-        for (const auto &c : cgraph_u) {
-            REQUIRE(c.empty());
-        }
+            cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+            for (const auto &c : cgraph_u) {
+                REQUIRE(c.empty());
+            }
 
-        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (const auto &c : cgraph_o) {
-            REQUIRE(c.empty());
+            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (const auto &c : cgraph_o) {
+                REQUIRE(c.empty());
+            }
         }
     }
 }
@@ -275,7 +274,7 @@ TEST_CASE("compute_cgraph_3d")
         auto zmin2 = z2 - s2 / 2;
         auto zmax2 = z2 + s2 / 2;
 
-        return xmax1 > xmin2 && xmin1 < xmax2 && ymax1 > ymin2 && ymin1 < ymax2 && zmax1 > zmin2 && zmin1 < zmax2;
+        return xmax1 >= xmin2 && xmin1 <= xmax2 && ymax1 >= ymin2 && ymin1 <= ymax2 && zmax1 >= zmin2 && zmin1 <= zmax2;
     };
 
     std::vector<double> aabb_sizes(s, 1.);
@@ -292,189 +291,193 @@ TEST_CASE("compute_cgraph_3d")
     const auto yc_o = parts.begin() + 2u * s;
     const auto zc_o = parts.begin() + 3u * s;
 
-    t = octree<double>{x_coords = xc_o,        y_coords = yc_o, z_coords = zc_o,
-                       masses = parts.begin(), nparts = s,      box_size = bsize};
-
-    const auto [xc_u, yc_u, zc_u, m_u] = t.p_its_u();
-
-    // Test with a variety of aabb sizes, starting from
-    // very small until encompassing the whole domain.
-    for (long k = 16; k >= 0; --k) {
-        // Collision graph that will be computed with the N**2 algorithm.
-        std::vector<std::vector<decltype(t)::size_type>> cmp;
-        cmp.resize(s);
-
-        // All aabbs same (nonzero) size.
-        const auto aabb_size = 1. / static_cast<double>(1l << k);
-        std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
-
-        // Unordered testing.
-        auto cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_size, xc_u[j], yc_u[j], zc_u[j], aabb_size)) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+    for (auto mln : {1, 4, 8, 16, 400}) {
+        t = octree<double>{x_coords = xc_o, y_coords = yc_o,  z_coords = zc_o, masses = parts.begin(),
+                           nparts = s,      box_size = bsize, max_leaf_n = mln};
+
+        const auto [xc_u, yc_u, zc_u, m_u] = t.p_its_u();
+
+        // Test with a variety of aabb sizes, starting from
+        // very small until encompassing the whole domain.
+        for (long k = 16; k >= 0; --k) {
+            // Collision graph that will be computed with the N**2 algorithm.
+            std::vector<std::vector<decltype(t)::size_type>> cmp;
+            cmp.resize(s);
+
+            // All aabbs same (nonzero) size.
+            const auto aabb_size = 1. / static_cast<double>(1l << k);
+            std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
+
+            // Unordered testing.
+            auto cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_size, xc_u[j], yc_u[j], zc_u[j], aabb_size)) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_u[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_u[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // Ordered testing.
-        auto cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_size, xc_o[j], yc_o[j], zc_o[j], aabb_size)) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            // Ordered testing.
+            auto cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_size, xc_o[j], yc_o[j], zc_o[j], aabb_size)) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_o[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_o[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // Set the aabb size to zero for half the points.
-        for (auto i = 0u; i < s; i += 2u) {
-            aabb_sizes[i] = 0;
-        }
-        // Build a version of aabb_sizes permuted according to the tree order.
-        auto aabb_sizes_u(aabb_sizes);
-        for (auto i = 0u; i < s; ++i) {
-            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
-        }
+            // Set the aabb size to zero for half the points.
+            for (auto i = 0u; i < s; i += 2u) {
+                aabb_sizes[i] = 0;
+            }
+            // Build a version of aabb_sizes permuted according to the tree order.
+            auto aabb_sizes_u(aabb_sizes);
+            for (auto i = 0u; i < s; ++i) {
+                aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+            }
 
-        // Redo the testing.
-        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
-                                 aabb_sizes_u[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            // Redo the testing.
+            cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
+                                     aabb_sizes_u[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_u[i].size() == cmp[i].size());
-            // If the current particle is a point, it cannot
-            // collide with anything.
-            if (aabb_sizes_u[i] == 0) {
-                REQUIRE(cgraph_u[i].empty());
-            }
-            // All the colliding particles must have nonzero size.
-            for (auto idx : cgraph_u[i]) {
-                REQUIRE(aabb_sizes_u[idx] != 0);
-            }
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_u[i].size() == cmp[i].size());
+                // If the current particle is a point, it cannot
+                // collide with anything.
+                if (aabb_sizes_u[i] == 0) {
+                    REQUIRE(cgraph_u[i].empty());
+                }
+                // All the colliding particles must have nonzero size.
+                for (auto idx : cgraph_u[i]) {
+                    REQUIRE(aabb_sizes_u[idx] != 0);
+                }
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j], aabb_sizes[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j],
+                                     aabb_sizes[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_o[i].size() == cmp[i].size());
-            // If the current particle is a point, it cannot
-            // collide with anything.
-            if (aabb_sizes[i] == 0) {
-                REQUIRE(cgraph_o[i].empty());
-            }
-            // All the colliding particles must have nonzero size.
-            for (auto idx : cgraph_o[i]) {
-                REQUIRE(aabb_sizes[idx] != 0);
-            }
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_o[i].size() == cmp[i].size());
+                // If the current particle is a point, it cannot
+                // collide with anything.
+                if (aabb_sizes[i] == 0) {
+                    REQUIRE(cgraph_o[i].empty());
+                }
+                // All the colliding particles must have nonzero size.
+                for (auto idx : cgraph_o[i]) {
+                    REQUIRE(aabb_sizes[idx] != 0);
+                }
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // Try different sizes.
-        for (auto i = 0u; i < s; ++i) {
-            aabb_sizes[i] += aabb_sizes[i] / (i + 1u);
-        }
-        aabb_sizes_u = aabb_sizes;
-        for (auto i = 0u; i < s; ++i) {
-            aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
-        }
+            // Try different sizes.
+            for (auto i = 0u; i < s; ++i) {
+                aabb_sizes[i] += aabb_sizes[i] / (i + 1u);
+            }
+            aabb_sizes_u = aabb_sizes;
+            for (auto i = 0u; i < s; ++i) {
+                aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
+            }
 
-        cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
-                                 aabb_sizes_u[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
+                                     aabb_sizes_u[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_u[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_u[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (auto i = 0u; i < s; ++i) {
-            for (auto j = i + 1u; j < s; ++j) {
-                if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j], aabb_sizes[j])) {
-                    cmp[i].push_back(j);
-                    cmp[j].push_back(i);
+            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (auto i = 0u; i < s; ++i) {
+                for (auto j = i + 1u; j < s; ++j) {
+                    if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j],
+                                     aabb_sizes[j])) {
+                        cmp[i].push_back(j);
+                        cmp[j].push_back(i);
+                    }
                 }
             }
-        }
-        for (auto i = 0u; i < s; ++i) {
-            REQUIRE(cgraph_o[i].size() == cmp[i].size());
-            REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                    == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-        }
-        // Clear cmp.
-        for (auto &v : cmp) {
-            v.clear();
-        }
+            for (auto i = 0u; i < s; ++i) {
+                REQUIRE(cgraph_o[i].size() == cmp[i].size());
+                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
+                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
+            }
+            // Clear cmp.
+            for (auto &v : cmp) {
+                v.clear();
+            }
 
-        // All zero aabb sizes.
-        std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
+            // All zero aabb sizes.
+            std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
 
-        cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
-        for (const auto &c : cgraph_u) {
-            REQUIRE(c.empty());
-        }
+            cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+            for (const auto &c : cgraph_u) {
+                REQUIRE(c.empty());
+            }
 
-        cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
-        for (const auto &c : cgraph_o) {
-            REQUIRE(c.empty());
+            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            for (const auto &c : cgraph_o) {
+                REQUIRE(c.empty());
+            }
         }
     }
 }

From 2a9190f388267a2bfd36e3e14ddfa3147cbab732 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 10:58:32 +0200
Subject: [PATCH 22/38] Fix for collision detection in a dead zone, testing
 improvements.

---
 include/rakau/detail/tree_coll.hpp | 109 +++++++++++++++++++++--------
 test/coll.cpp                      |  54 +++++++-------
 2 files changed, 107 insertions(+), 56 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 5228565..6a68839 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -334,39 +334,86 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
 
                     // Iterate over the AABB vertices.
                     for (std::size_t i = 0; i < n_vertices; ++i) {
-                        // Compute the code of the node at level aabb_level
-                        // that encloses the vertex.
-                        const auto s_code
-                            = (aabb_codes[i] >> ((cbits - aabb_level) * NDim)) + (UInt(1) << (aabb_level * NDim));
-
-                        if (aabb_level >= llevel && s_code >> ((aabb_level - llevel) * NDim) == lcode) {
-                            // The s_code node fits within the current leaf node,
-                            // no need for further checks (i.e., s_code does not overlap
-                            // with any leaf node other than the original one).
-                            continue;
+                        // NOTE: within this loop, we will be determining
+                        // a node N at level aabb_level which contains a straddling
+                        // vertex of pidx's AABB. We will then establish a range of leaf nodes
+                        // [l_begin, l_end) that have an overlap with N.
+                        //
+                        // It might be that [l_begin, l_end) turns out to
+                        // be an empty range because the particle straddles into
+                        // an 'empty' area which is not associated to any leaf node (because
+                        // it does not contain the centre of any particle). In such a situation,
+                        // we will end up *not* detecting AABB collisions occurring
+                        // in the empty area. In order to avoid this, if [l_begin, l_end)
+                        // is an empty range we will lower the aabb_level (that is, move
+                        // to the parent node) and repeat the search, until it yields
+                        // a non-empty [l_begin, l_end) range. That is, we are "zooming
+                        // out" until the empty area becomes part of some node N_bigger, which
+                        // is guaranteed to eventually happen, and we will add pidx to
+                        // all leaf nodes overlapping N_bigger.
+
+                        // Init the range iterators.
+                        decltype(c_begin) l_begin, l_end;
+
+                        // In the loop below we may end up determining a node
+                        // which fits wholly in the original leaf node. In such a case,
+                        // we will want to skip the rest of the loop and move to the
+                        // next vertex, because there's no need to add pidx as an
+                        // additional particle to its original node.
+                        bool fits = false;
+
+                        for (auto al_copy(aabb_level);; --al_copy) {
+                            // Compute the code of the node at level al_copy
+                            // that encloses the vertex.
+                            const auto s_code
+                                = (aabb_codes[i] >> ((cbits - al_copy) * NDim)) + (UInt(1) << (al_copy * NDim));
+
+                            if (al_copy >= llevel && s_code >> ((al_copy - llevel) * NDim) == lcode) {
+                                // The s_code node fits within the current leaf node,
+                                // no need for further checks (i.e., s_code does not overlap
+                                // with any leaf node other than the original one).
+                                fits = true;
+                                break;
+                            }
+
+                            // Determine the code range encompassed by s_code.
+                            const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, al_copy);
+
+                            // In the set of leaf nodes, determine either the last node whose
+                            // code range precedes s_code_range, or the first one whose code
+                            // range has some overlap with s_code range.
+                            l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
+                                const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                                return n_max < p.first;
+                            });
+
+                            // Now determine the first node whose code range follows s_code_range.
+                            // NOTE: in upper_bound(), the comparator parameter types are flipped around
+                            // wrt lower_bound().
+                            // NOTE: start the search from l_begin, determined above, as we know
+                            // that l_end must be l_begin or an iterator following it.
+                            l_end = std::upper_bound(l_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
+                                const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                                return p.second < n_min;
+                            });
+
+                            if (l_begin != l_end) {
+                                // A non-empty leaf node range was found, break out
+                                // and add pidx to all the leaf nodes in the range.
+                                break;
+                            }
+
+                            // An empty leaf node range was found. Enlarge the search.
+                            // NOTE: the current al_copy level cannot be zero, because in that case we
+                            // would be at the root node and we would've found something already.
+                            assert(al_copy > 0u);
                         }
 
-                        // Determine the code range encompassed by s_code.
-                        const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, aabb_level);
-
-                        // In the set of leaf nodes, determine either the last node whose
-                        // code range precedes s_code_range, or the first one whose code
-                        // range has some overlap with s_code range.
-                        auto l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
-                            const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
-                            return n_max < p.first;
-                        });
-
-                        // Now determine the first node whose code range follows s_code_range.
-                        // NOTE: in upper_bound(), the comparator parameter types are flipped around
-                        // wrt lower_bound().
-                        // NOTE: start the search from l_begin, determined above, as we know
-                        // that l_end must be l_begin or an iterator following it.
-                        const auto l_end
-                            = std::upper_bound(l_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
-                                  const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
-                                  return p.second < n_min;
-                              });
+                        if (fits) {
+                            // The vertex-enclosing node fits wholly in the original leaf node.
+                            // Move to the next vertex.
+                            continue;
+                        }
 
                         // Iterate over the leaf node range, and add pidx as extra particle
                         // to each leaf node.
diff --git a/test/coll.cpp b/test/coll.cpp
index 2345315..59ca8ad 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -57,27 +57,29 @@ TEST_CASE("compute_cgraph_2d")
     REQUIRE(t.compute_cgraph_o(aabb_sizes.data()).empty());
     REQUIRE(t.compute_cgraph_u(aabb_sizes.data()).empty());
 
-    // Fill with random data.
-    auto parts = get_uniform_particles<2>(s, bsize, rng);
+    // Test with various leaf node sizes.
+    for (auto mln : {1, 4, 8, 16, 400}) {
+        // Test with a variety of aabb sizes, starting from
+        // very small until encompassing the whole domain.
+        for (long k = 15; k >= -1; --k) {
+            // Fill with random data.
+            auto parts = get_uniform_particles<2>(s, bsize, rng);
 
-    const auto xc_o = parts.begin() + s;
-    const auto yc_o = parts.begin() + 2u * s;
+            const auto xc_o = parts.begin() + s;
+            const auto yc_o = parts.begin() + 2u * s;
 
-    for (auto mln : {1, 4, 8, 16, 400}) {
-        t = quadtree<double>{x_coords = xc_o, y_coords = yc_o,  masses = parts.begin(),
-                             nparts = s,      box_size = bsize, max_leaf_n = mln};
+            t = quadtree<double>{x_coords = xc_o, y_coords = yc_o,  masses = parts.begin(),
+                                 nparts = s,      box_size = bsize, max_leaf_n = mln};
 
-        const auto [xc_u, yc_u, m_u] = t.p_its_u();
+            const auto [xc_u, yc_u, m_u] = t.p_its_u();
 
-        // Test with a variety of aabb sizes, starting from
-        // very small until encompassing the whole domain.
-        for (long k = 16; k >= 0; --k) {
             // Collision graph that will be computed with the N**2 algorithm.
             std::vector<std::vector<decltype(t)::size_type>> cmp;
             cmp.resize(s);
 
             // All aabbs same (nonzero) size.
-            const auto aabb_size = 1. / static_cast<double>(1l << k);
+            // NOTE: for k == -1, pick an AABB size much larger than the domain.
+            const auto aabb_size = k >= 0 ? 1. / static_cast<double>(1l << k) : 10.;
             std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
 
             // Unordered testing.
@@ -284,28 +286,30 @@ TEST_CASE("compute_cgraph_3d")
     REQUIRE(t.compute_cgraph_o(aabb_sizes.data()).empty());
     REQUIRE(t.compute_cgraph_u(aabb_sizes.data()).empty());
 
-    // Fill with random data.
-    auto parts = get_uniform_particles<3>(s, bsize, rng);
+    // Test with various leaf node sizes.
+    for (auto mln : {1, 4, 8, 16, 400}) {
+        // Test with a variety of aabb sizes, starting from
+        // very small until encompassing the whole domain.
+        for (long k = 15; k >= -1; --k) {
+            // Fill with random data.
+            auto parts = get_uniform_particles<3>(s, bsize, rng);
 
-    const auto xc_o = parts.begin() + s;
-    const auto yc_o = parts.begin() + 2u * s;
-    const auto zc_o = parts.begin() + 3u * s;
+            const auto xc_o = parts.begin() + s;
+            const auto yc_o = parts.begin() + 2u * s;
+            const auto zc_o = parts.begin() + 3u * s;
 
-    for (auto mln : {1, 4, 8, 16, 400}) {
-        t = octree<double>{x_coords = xc_o, y_coords = yc_o,  z_coords = zc_o, masses = parts.begin(),
-                           nparts = s,      box_size = bsize, max_leaf_n = mln};
+            t = octree<double>{x_coords = xc_o, y_coords = yc_o,  z_coords = zc_o, masses = parts.begin(),
+                               nparts = s,      box_size = bsize, max_leaf_n = mln};
 
-        const auto [xc_u, yc_u, zc_u, m_u] = t.p_its_u();
+            const auto [xc_u, yc_u, zc_u, m_u] = t.p_its_u();
 
-        // Test with a variety of aabb sizes, starting from
-        // very small until encompassing the whole domain.
-        for (long k = 16; k >= 0; --k) {
             // Collision graph that will be computed with the N**2 algorithm.
             std::vector<std::vector<decltype(t)::size_type>> cmp;
             cmp.resize(s);
 
             // All aabbs same (nonzero) size.
-            const auto aabb_size = 1. / static_cast<double>(1l << k);
+            // NOTE: for k == -1, pick an AABB size much larger than the domain.
+            const auto aabb_size = k >= 0 ? 1. / static_cast<double>(1l << k) : 10.;
             std::fill(aabb_sizes.begin(), aabb_sizes.end(), aabb_size);
 
             // Unordered testing.

From 639d5f1befa5b6798fafc75c0b408b25d2e4c24a Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 12:02:21 +0200
Subject: [PATCH 23/38] Fix unused variables warnings and make tests more
 chatty.

---
 include/rakau/detail/tree_coll.hpp | 4 ++--
 test/coll.cpp                      | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 6a68839..2cdf768 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -383,7 +383,7 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                             // code range precedes s_code_range, or the first one whose code
                             // range has some overlap with s_code range.
                             l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
-                                const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                                const auto n_max = detail::tree_coll_node_range<NDim>(n.code, n.level).second;
                                 return n_max < p.first;
                             });
 
@@ -393,7 +393,7 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                             // NOTE: start the search from l_begin, determined above, as we know
                             // that l_end must be l_begin or an iterator following it.
                             l_end = std::upper_bound(l_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
-                                const auto [n_min, n_max] = detail::tree_coll_node_range<NDim>(n.code, n.level);
+                                const auto n_min = detail::tree_coll_node_range<NDim>(n.code, n.level).first;
                                 return p.second < n_min;
                             });
 
diff --git a/test/coll.cpp b/test/coll.cpp
index 59ca8ad..11b852d 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <initializer_list>
+#include <iostream>
 #include <random>
 #include <unordered_set>
 #include <vector>
@@ -62,6 +63,8 @@ TEST_CASE("compute_cgraph_2d")
         // Test with a variety of aabb sizes, starting from
         // very small until encompassing the whole domain.
         for (long k = 15; k >= -1; --k) {
+            std::cout << "Testing mln=" << mln << ", k=" << k << '\n';
+
             // Fill with random data.
             auto parts = get_uniform_particles<2>(s, bsize, rng);
 
@@ -72,6 +75,7 @@ TEST_CASE("compute_cgraph_2d")
                                  nparts = s,      box_size = bsize, max_leaf_n = mln};
 
             const auto [xc_u, yc_u, m_u] = t.p_its_u();
+            detail::ignore(m_u);
 
             // Collision graph that will be computed with the N**2 algorithm.
             std::vector<std::vector<decltype(t)::size_type>> cmp;
@@ -291,6 +295,8 @@ TEST_CASE("compute_cgraph_3d")
         // Test with a variety of aabb sizes, starting from
         // very small until encompassing the whole domain.
         for (long k = 15; k >= -1; --k) {
+            std::cout << "Testing mln=" << mln << ", k=" << k << '\n';
+
             // Fill with random data.
             auto parts = get_uniform_particles<3>(s, bsize, rng);
 
@@ -302,6 +308,7 @@ TEST_CASE("compute_cgraph_3d")
                                nparts = s,      box_size = bsize, max_leaf_n = mln};
 
             const auto [xc_u, yc_u, zc_u, m_u] = t.p_its_u();
+            detail::ignore(m_u);
 
             // Collision graph that will be computed with the N**2 algorithm.
             std::vector<std::vector<decltype(t)::size_type>> cmp;

From 0f7058654f164fe107e9a195857a2c2dd1e7e229 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 13:58:39 +0200
Subject: [PATCH 24/38] Add some parallelisation to the coll test, make it more
 chatty.

---
 test/CMakeLists.txt |   4 +-
 test/coll.cpp       | 144 +++++++++++++++-----------------------------
 2 files changed, 51 insertions(+), 97 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index bcc7e3d..62f97d0 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -13,7 +13,9 @@ function(ADD_RAKAU_TESTCASE arg1)
   endif()
 
   add_executable(${arg1} ${arg1}.cpp)
-  target_link_libraries(${arg1} rakau)
+  # NOTE: explicitly link to tbb as we are using
+  # it to parallelise some tests.
+  target_link_libraries(${arg1} rakau TBB::tbb)
   target_compile_options(${arg1} PRIVATE "$<$<CONFIG:DEBUG>:${RAKAU_CXX_FLAGS_DEBUG}>" "$<$<CONFIG:RELEASE>:${RAKAU_CXX_FLAGS_RELEASE}>")
   set_target_properties(${arg1} PROPERTIES CXX_VISIBILITY_PRESET hidden)
   set_target_properties(${arg1} PROPERTIES VISIBILITY_INLINES_HIDDEN TRUE)
diff --git a/test/coll.cpp b/test/coll.cpp
index 11b852d..e996c3f 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -12,6 +12,7 @@
 #include "catch.hpp"
 
 #include <algorithm>
+#include <atomic>
 #include <initializer_list>
 #include <iostream>
 #include <random>
@@ -20,6 +21,9 @@
 
 #include <boost/iterator/permutation_iterator.hpp>
 
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
+
 #include "test_utils.hpp"
 
 using namespace rakau;
@@ -28,6 +32,38 @@ using namespace rakau_test;
 
 std::mt19937 rng;
 
+template <typename CGraph, typename Cmp>
+inline void compare_results(const CGraph &cgraph, Cmp &cmp)
+{
+    REQUIRE(cgraph.size() == cmp.size());
+
+    std::atomic<int> n_failures(0);
+    std::atomic<unsigned long long> n_coll(0);
+
+    tbb::parallel_for(tbb::blocked_range(decltype(cgraph.size())(0), cgraph.size()),
+                      [&n_failures, &cgraph, &cmp, &n_coll](const auto &r) {
+                          auto loc_n_coll = 0ull;
+
+                          for (auto i = r.begin(); i != r.end(); ++i) {
+                              if (cgraph[i].size() != cmp[i].size()) {
+                                  ++n_failures;
+                              }
+
+                              std::sort(cmp[i].begin(), cmp[i].end());
+                              if (!std::equal(cmp[i].begin(), cmp[i].end(), cgraph[i].begin())) {
+                                  ++n_failures;
+                              }
+
+                              loc_n_coll += cmp[i].size();
+                          }
+
+                          n_coll += loc_n_coll;
+                      });
+
+    REQUIRE(n_failures.load() == 0);
+    std::cout << "Total number of collisions detected: " << n_coll.load() / 2u << '\n';
+}
+
 TEST_CASE("compute_cgraph_2d")
 {
     constexpr auto bsize = 1.;
@@ -96,11 +132,7 @@ TEST_CASE("compute_cgraph_2d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_u[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_u, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -116,11 +148,7 @@ TEST_CASE("compute_cgraph_2d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_o[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_o, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -146,20 +174,7 @@ TEST_CASE("compute_cgraph_2d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_u[i].size() == cmp[i].size());
-                // If the current particle is a point, it cannot
-                // collide with anything.
-                if (aabb_sizes_u[i] == 0) {
-                    REQUIRE(cgraph_u[i].empty());
-                }
-                // All the colliding particles must have nonzero size.
-                for (auto idx : cgraph_u[i]) {
-                    REQUIRE(aabb_sizes_u[idx] != 0);
-                }
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_u, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -174,20 +189,7 @@ TEST_CASE("compute_cgraph_2d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_o[i].size() == cmp[i].size());
-                // If the current particle is a point, it cannot
-                // collide with anything.
-                if (aabb_sizes[i] == 0) {
-                    REQUIRE(cgraph_o[i].empty());
-                }
-                // All the colliding particles must have nonzero size.
-                for (auto idx : cgraph_o[i]) {
-                    REQUIRE(aabb_sizes[idx] != 0);
-                }
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_o, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -211,11 +213,7 @@ TEST_CASE("compute_cgraph_2d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_u[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_u, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -230,11 +228,7 @@ TEST_CASE("compute_cgraph_2d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_o[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_o, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -329,11 +323,7 @@ TEST_CASE("compute_cgraph_3d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_u[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_u, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -349,11 +339,7 @@ TEST_CASE("compute_cgraph_3d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_o[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_o, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -380,20 +366,7 @@ TEST_CASE("compute_cgraph_3d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_u[i].size() == cmp[i].size());
-                // If the current particle is a point, it cannot
-                // collide with anything.
-                if (aabb_sizes_u[i] == 0) {
-                    REQUIRE(cgraph_u[i].empty());
-                }
-                // All the colliding particles must have nonzero size.
-                for (auto idx : cgraph_u[i]) {
-                    REQUIRE(aabb_sizes_u[idx] != 0);
-                }
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_u, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -409,20 +382,7 @@ TEST_CASE("compute_cgraph_3d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_o[i].size() == cmp[i].size());
-                // If the current particle is a point, it cannot
-                // collide with anything.
-                if (aabb_sizes[i] == 0) {
-                    REQUIRE(cgraph_o[i].empty());
-                }
-                // All the colliding particles must have nonzero size.
-                for (auto idx : cgraph_o[i]) {
-                    REQUIRE(aabb_sizes[idx] != 0);
-                }
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_o, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -447,11 +407,7 @@ TEST_CASE("compute_cgraph_3d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_u[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_u[i].begin(), cgraph_u[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_u, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();
@@ -467,11 +423,7 @@ TEST_CASE("compute_cgraph_3d")
                     }
                 }
             }
-            for (auto i = 0u; i < s; ++i) {
-                REQUIRE(cgraph_o[i].size() == cmp[i].size());
-                REQUIRE(std::unordered_set<decltype(t)::size_type>(cgraph_o[i].begin(), cgraph_o[i].end())
-                        == std::unordered_set<decltype(t)::size_type>(cmp[i].begin(), cmp[i].end()));
-            }
+            compare_results(cgraph_o, cmp);
             // Clear cmp.
             for (auto &v : cmp) {
                 v.clear();

From def9caf89b33dfc2a22b25bc2cf01750f3fb9453 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 14:10:16 +0200
Subject: [PATCH 25/38] Update internal docs.

---
 include/rakau/tree.hpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 2b96ae8..3e237bc 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -631,9 +631,13 @@ using f_vector = std::vector<F, di_aligned_allocator<F, XSIMD_DEFAULT_ALIGNMENT>
 //   can try to ensure that the TBB threads are scheduled with the same affinity as the affinity used to write initially
 //   into the particle data vectors. TBB has an affinity partitioner, but it's not clear to me if we can rely on that
 //   for efficient NUMA access. It's probably better to run some tests before embarking in this.
-// - we should probably also think about replacing the morton encoder with some generic solution. It does not
-//   need to be super high performance, as morton encoding is hardly a bottleneck here. It's more important for it
-//   to be generic (i.e., work on a general number of dimensions), correct and compact.
+// - we should think about replacing eventually the current morton encoder. We could try to move either
+//   to a fully generic solution (although it's not clear what the practical benefits would be) or to a
+//   higher-performance one focused on 2d/3d cases - particularly, towards vectorization:
+//   https://lemire.me/blog/2018/01/09/how-fast-can-you-bit-interleave-32-bit-integers-simd-edition/
+//   Currently morton encoding is not really a bottleneck, however there might be some performance gains
+//   when vectorizing, e.g., in the collision code where we end up encoding all the AABB vertices
+//   of each particle.
 // - double precision benchmarking/tuning.
 // - tuning for the potential computation (possibly not much improvement to be had there, but it should be investigated
 //   a bit at least).
@@ -643,10 +647,13 @@ using f_vector = std::vector<F, di_aligned_allocator<F, XSIMD_DEFAULT_ALIGNMENT>
 //   will fail often). It's probably best to start experimenting with such size as a free parameter, check the
 //   performance with various values and then try to understand if there's any heuristic we can deduce from that.
 // - quadrupole moments.
-// - radix sort.
+// - radix sort, or perhaps some type of sort which takes better advantage of almost-sorted data.
 // - would be interesting to see if we can do the permutations in-place efficiently. If that worked, it would probably
 //   help simplifying things on the GPU side. See for instance:
 //   https://stackoverflow.com/questions/7365814/in-place-array-reordering
+// - some vectorisation in the AABB overlap checks should be possible, especially when we are doing
+//   overlap checks on the original particles in a leaf node (whose coordinates we can easily load in
+//   SIMD batches).
 template <std::size_t NDim, typename F, typename UInt, mac MAC>
 class tree
 {

From eaf78ada2d4c6b857daac8af9d31bbd96c3a6d28 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 15:07:20 +0200
Subject: [PATCH 26/38] More test splitting on travis.

---
 .travis.yml | 60 ++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 48 insertions(+), 12 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index ed51852..048dadc 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,7 +16,7 @@ matrix:
     # - env: RAKAU_BUILD="osx_debug" SPLIT_TEST_NUM="1" TEST_NSPLIT="2"
     #   os: osx
     #   osx_image: xcode10.1
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="0" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -25,7 +25,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="1" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -34,7 +34,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="2" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -43,7 +43,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="0" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -52,7 +52,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="1" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -61,7 +61,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="2" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -70,7 +70,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="0" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -79,7 +79,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="1" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -88,7 +88,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="2" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -97,7 +97,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="0" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -106,7 +106,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="1" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:
@@ -115,7 +115,43 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="2" TEST_NSPLIT="3"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
       compiler: gcc
       os: linux
       addons:

From a852627c86c6bffeb93171f4e0291e4ec2d2c195 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 16:20:14 +0200
Subject: [PATCH 27/38] Even more travis splitting.

---
 .travis.yml | 68 ++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 52 insertions(+), 16 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 048dadc..a8aa4d5 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,7 +16,7 @@ matrix:
     # - env: RAKAU_BUILD="osx_debug" SPLIT_TEST_NUM="1" TEST_NSPLIT="2"
     #   os: osx
     #   osx_image: xcode10.1
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="0" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -25,7 +25,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="1" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -34,7 +34,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="2" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -43,7 +43,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="3" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -52,7 +52,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug" SPLIT_TEST_NUM="4" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -61,7 +61,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="0" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -70,7 +70,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="1" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -79,7 +79,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="2" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -88,7 +88,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="3" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -97,7 +97,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_nosimd" SPLIT_TEST_NUM="4" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -106,7 +106,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="0" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -115,7 +115,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="1" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -124,7 +124,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="0" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="2" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -133,7 +133,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="1" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="3" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -142,7 +142,7 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="2" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_native" SPLIT_TEST_NUM="4" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:
@@ -151,7 +151,43 @@ matrix:
           - ubuntu-toolchain-r-test
           packages:
           - g++-7
-    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="3" TEST_NSPLIT="4"
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="0" TEST_NSPLIT="5"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="1" TEST_NSPLIT="5"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="2" TEST_NSPLIT="5"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="3" TEST_NSPLIT="5"
+      compiler: gcc
+      os: linux
+      addons:
+        apt:
+          sources:
+          - ubuntu-toolchain-r-test
+          packages:
+          - g++-7
+    - env: RAKAU_BUILD="gcc7_debug_native_norsqrt" SPLIT_TEST_NUM="4" TEST_NSPLIT="5"
       compiler: gcc
       os: linux
       addons:

From 34afadba8bce51a86b6b4215c362521a2045c3de Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 15 Jul 2019 22:57:46 +0200
Subject: [PATCH 28/38] Small cleanups + optimisation.

---
 include/rakau/detail/tree_coll.hpp | 99 +++++++++++++++++-------------
 include/rakau/tree.hpp             |  1 -
 2 files changed, 55 insertions(+), 45 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 2cdf768..cbe97e8 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -37,24 +37,30 @@
 namespace rakau
 {
 
-// Return the largest node level such that the node
-// size is larger than the value s. If s >= m_box_size,
+inline namespace detail
+{
+
+// Return the largest node level, in a domain of size box_size,
+// such that the node size is larger than the value s. If s >= box_size,
 // 0 will be returned.
-template <std::size_t NDim, typename F, typename UInt, mac MAC>
-inline UInt tree<NDim, F, UInt, MAC>::coll_size_to_level(F s) const
+template <typename UInt, std::size_t NDim, typename F>
+inline UInt coll_size_to_level(F s, F box_size)
 {
     assert(std::isfinite(s));
     // NOTE: we assume we never enter here
     // with a null node size.
     assert(s > F(0));
+    assert(std::isfinite(box_size));
+
+    constexpr auto cbits = cbits_v<UInt, NDim>;
 
     UInt retval = 0;
-    F cur_node_size = m_box_size;
+    auto cur_node_size = box_size;
 
     // Don't return a result larger than cbits
     // (the max level).
     for (; retval != cbits; ++retval) {
-        const auto next_node_size = cur_node_size * F(1) / F(2);
+        const auto next_node_size = cur_node_size * (F(1) / F(2));
         if (next_node_size <= s) {
             // The next node size is not larger
             // than the target. Break out and
@@ -67,40 +73,6 @@ inline UInt tree<NDim, F, UInt, MAC>::coll_size_to_level(F s) const
     return retval;
 }
 
-// Return a vector of indices into tree structure
-// representing the ordered set of leaf nodes
-// NOTE: need to understand if/when/how this should be parallelised.
-template <std::size_t NDim, typename F, typename UInt, mac MAC>
-inline auto tree<NDim, F, UInt, MAC>::coll_leaves_permutation() const
-{
-    // Prepare the output.
-    std::vector<size_type> retval;
-    const auto tsize = m_tree.size();
-    retval.reserve(static_cast<decltype(retval.size())>(tsize));
-
-    for (size_type i = 0; i < tsize; ++i) {
-        if (!m_tree[i].n_children) {
-            // Leaf node, add it.
-            retval.push_back(i);
-        }
-    }
-
-#if !defined(NDEBUG)
-    // Verify the output.
-    size_type tot_parts = 0;
-    for (auto idx : retval) {
-        assert(m_tree[idx].n_children == 0u);
-        tot_parts += m_tree[idx].end - m_tree[idx].begin;
-    }
-    assert(tot_parts == m_parts[0].size());
-#endif
-
-    return retval;
-}
-
-inline namespace detail
-{
-
 // Compute the codes of the vertices of an AABB of size aabb_size around
 // the point p_pos. The coordinates of the AABB vertices will be clamped
 // to the domain boundaries (via inv_box_size).
@@ -204,6 +176,37 @@ inline std::pair<UInt, UInt> tree_coll_node_range(UInt code, UInt level)
 
 } // namespace detail
 
+// Return a vector of indices into the tree structure
+// representing the ordered set of leaf nodes
+// NOTE: need to understand if/when/how this should be parallelised.
+template <std::size_t NDim, typename F, typename UInt, mac MAC>
+inline auto tree<NDim, F, UInt, MAC>::coll_leaves_permutation() const
+{
+    // Prepare the output.
+    std::vector<size_type> retval;
+    const auto tsize = m_tree.size();
+    retval.reserve(static_cast<decltype(retval.size())>(tsize));
+
+    for (size_type i = 0; i < tsize; ++i) {
+        if (!m_tree[i].n_children) {
+            // Leaf node, add it.
+            retval.push_back(i);
+        }
+    }
+
+#if !defined(NDEBUG)
+    // Verify the output.
+    size_type tot_parts = 0;
+    for (auto idx : retval) {
+        assert(m_tree[idx].n_children == 0u);
+        tot_parts += m_tree[idx].end - m_tree[idx].begin;
+    }
+    assert(tot_parts == m_parts[0].size());
+#endif
+
+    return retval;
+}
+
 template <std::size_t NDim, typename F, typename UInt, mac MAC>
 template <bool Ordered, typename It>
 inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
@@ -278,9 +281,10 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                     const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
 
                     // Check it.
-                    if (rakau_unlikely(!std::isfinite(aabb_size))) {
-                        throw std::invalid_argument(
-                            "A non-finite AABB size was detected while computing the collision graph");
+                    if (rakau_unlikely(!std::isfinite(aabb_size) || aabb_size < F(0))) {
+                        throw std::invalid_argument("An invalid AABB size was detected while computing the collision "
+                                                    "graph: the AABB size must be finite and non-negative, but it is "
+                                                    + std::to_string(aabb_size) + " instead");
                     }
 
                     // Particles with a null AABB don't participate in collision
@@ -330,7 +334,7 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                     // overlap the enclosing node set.
 
                     // Convert the AABB size to a node level.
-                    const auto aabb_level = coll_size_to_level(aabb_size);
+                    const auto aabb_level = detail::coll_size_to_level<UInt, NDim>(aabb_size, m_box_size);
 
                     // Iterate over the AABB vertices.
                     for (std::size_t i = 0; i < n_vertices; ++i) {
@@ -475,6 +479,11 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
             std::sort(va.begin(), va.end());
             const auto new_va_end = std::unique(va.begin(), va.end());
             node_indices.insert(node_indices.end(), va.begin(), new_va_end);
+            // We are done with va. Clear it and free any allocated
+            // storage. Like this, we are doing most of the work
+            // of the destructor of v_add in parallel.
+            va.clear();
+            va.shrink_to_fit();
 
             // Run the N**2 AABB overlap detection on all particles
             // in node_indices.
@@ -484,6 +493,8 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
                 const auto idx1 = node_indices[i];
 
                 // Load the AABB size for particle idx1.
+                // NOTE: we checked while building v_add that all
+                // AABB sizes are finite and non-negative.
                 const auto aabb_size1 = Ordered ? *(it + m_perm[idx1]) : *(it + idx1);
 
                 if (aabb_size1 == F(0)) {
diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 3e237bc..804eb45 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -3489,7 +3489,6 @@ class tree
 
 private:
     auto coll_leaves_permutation() const;
-    UInt coll_size_to_level(F) const;
     template <bool Ordered, typename It>
     auto compute_cgraph_impl(It) const;
 

From 0c075c6b127f4c3fbeb8ff1814f17aad43121113 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 16 Jul 2019 10:17:35 +0200
Subject: [PATCH 29/38] Add the ability to pass the return value to the
 collision detection functions.

---
 include/rakau/detail/tree_coll.hpp | 23 +++++++++++++++++------
 include/rakau/tree.hpp             | 26 +++++++++++++++++++++-----
 test/coll.cpp                      | 18 +++++++++---------
 3 files changed, 47 insertions(+), 20 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index cbe97e8..3917b09 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -209,7 +209,8 @@ inline auto tree<NDim, F, UInt, MAC>::coll_leaves_permutation() const
 
 template <std::size_t NDim, typename F, typename UInt, mac MAC>
 template <bool Ordered, typename It>
-inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
+inline void tree<NDim, F, UInt, MAC>::compute_cgraph_impl(std::vector<tbb::concurrent_vector<size_type>> &cgraph,
+                                                          It it) const
 {
     simple_timer st("overall cgraph computation");
 
@@ -225,16 +226,28 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
     // The vector of additional particles for each leaf node.
     std::vector<tbb::concurrent_vector<size_type>> v_add;
 
-    // The return value.
-    std::vector<tbb::concurrent_vector<size_type>> cgraph;
-
     // Prepare storage for cgraph in parallel
     // with the v_add computation.
     tbb::task_group tg;
 
     tg.run([this, &cgraph]() {
         simple_timer st("cgraph prepare");
+
+        // Check if the return value is empty.
+        const auto empty = cgraph.empty();
+
         cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
+
+        if (!empty) {
+            // If the return value was not originally empty,
+            // we must make sure that all its vectors are cleared
+            // up before we write into them.
+            tbb::parallel_for(tbb::blocked_range(cgraph.begin(), cgraph.end()), [](const auto &r) {
+                for (auto &v : r) {
+                    v.clear();
+                }
+            });
+        }
     });
 
     tg.run([this, &clp, &v_add, it, &c_begin, &c_end]() {
@@ -586,8 +599,6 @@ inline auto tree<NDim, F, UInt, MAC>::compute_cgraph_impl(It it) const
         }
     });
 #endif
-
-    return cgraph;
 }
 
 } // namespace rakau
diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 804eb45..870605e 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -377,6 +377,8 @@ struct morton_decoder<2, std::uint32_t> {
 template <std::size_t NDim, typename UInt, bool Clamp = false, typename F>
 inline UInt disc_single_coord(const F &x, const F &inv_box_size)
 {
+    // NOTE: this factor is the total number of available discretised
+    // positions across a single dimension.
     constexpr UInt factor = UInt(1) << cbits_v<UInt, NDim>;
 
     // Translate and rescale the coordinate so that -box_size/2 becomes zero
@@ -3490,18 +3492,32 @@ class tree
 private:
     auto coll_leaves_permutation() const;
     template <bool Ordered, typename It>
-    auto compute_cgraph_impl(It) const;
+    void compute_cgraph_impl(std::vector<tbb::concurrent_vector<size_type>> &out, It) const;
 
 public:
     template <typename It>
-    auto compute_cgraph_u(It it) const
+    std::vector<tbb::concurrent_vector<size_type>> compute_cgraph_u(It it) const
     {
-        return compute_cgraph_impl<false>(it);
+        std::vector<tbb::concurrent_vector<size_type>> retval;
+        compute_cgraph_impl<false>(retval, it);
+        return retval;
+    }
+    template <typename It>
+    std::vector<tbb::concurrent_vector<size_type>> compute_cgraph_o(It it) const
+    {
+        std::vector<tbb::concurrent_vector<size_type>> retval;
+        compute_cgraph_impl<true>(retval, it);
+        return retval;
+    }
+    template <typename It>
+    void compute_cgraph_u(std::vector<tbb::concurrent_vector<size_type>> &out, It it) const
+    {
+        compute_cgraph_impl<false>(out, it);
     }
     template <typename It>
-    auto compute_cgraph_o(It it) const
+    void compute_cgraph_o(std::vector<tbb::concurrent_vector<size_type>> &out, It it) const
     {
-        return compute_cgraph_impl<true>(it);
+        compute_cgraph_impl<true>(out, it);
     }
 
 private:
diff --git a/test/coll.cpp b/test/coll.cpp
index e996c3f..3e19e31 100644
--- a/test/coll.cpp
+++ b/test/coll.cpp
@@ -164,8 +164,8 @@ TEST_CASE("compute_cgraph_2d")
                 aabb_sizes_u[i] = aabb_sizes[t.perm()[i]];
             }
 
-            // Redo the testing.
-            cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+            // Redo the testing, this time with retvals passed in.
+            t.compute_cgraph_u(cgraph_u, aabb_sizes_u.data());
             for (auto i = 0u; i < s; ++i) {
                 for (auto j = i + 1u; j < s; ++j) {
                     if (aabb_overlap(xc_u[i], yc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], aabb_sizes_u[j])) {
@@ -180,7 +180,7 @@ TEST_CASE("compute_cgraph_2d")
                 v.clear();
             }
 
-            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            t.compute_cgraph_o(cgraph_o, aabb_sizes.data());
             for (auto i = 0u; i < s; ++i) {
                 for (auto j = i + 1u; j < s; ++j) {
                     if (aabb_overlap(xc_o[i], yc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], aabb_sizes[j])) {
@@ -237,12 +237,12 @@ TEST_CASE("compute_cgraph_2d")
             // All zero aabb sizes.
             std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
 
-            cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+            t.compute_cgraph_u(cgraph_u, aabb_sizes.data());
             for (const auto &c : cgraph_u) {
                 REQUIRE(c.empty());
             }
 
-            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            t.compute_cgraph_o(cgraph_o, aabb_sizes.data());
             for (const auto &c : cgraph_o) {
                 REQUIRE(c.empty());
             }
@@ -356,7 +356,7 @@ TEST_CASE("compute_cgraph_3d")
             }
 
             // Redo the testing.
-            cgraph_u = t.compute_cgraph_u(aabb_sizes_u.data());
+            t.compute_cgraph_u(cgraph_u, aabb_sizes_u.data());
             for (auto i = 0u; i < s; ++i) {
                 for (auto j = i + 1u; j < s; ++j) {
                     if (aabb_overlap(xc_u[i], yc_u[i], zc_u[i], aabb_sizes_u[i], xc_u[j], yc_u[j], zc_u[j],
@@ -372,7 +372,7 @@ TEST_CASE("compute_cgraph_3d")
                 v.clear();
             }
 
-            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            t.compute_cgraph_o(cgraph_o, aabb_sizes.data());
             for (auto i = 0u; i < s; ++i) {
                 for (auto j = i + 1u; j < s; ++j) {
                     if (aabb_overlap(xc_o[i], yc_o[i], zc_o[i], aabb_sizes[i], xc_o[j], yc_o[j], zc_o[j],
@@ -432,12 +432,12 @@ TEST_CASE("compute_cgraph_3d")
             // All zero aabb sizes.
             std::fill(aabb_sizes.begin(), aabb_sizes.end(), 0.);
 
-            cgraph_u = t.compute_cgraph_u(aabb_sizes.data());
+            t.compute_cgraph_u(cgraph_u, aabb_sizes.data());
             for (const auto &c : cgraph_u) {
                 REQUIRE(c.empty());
             }
 
-            cgraph_o = t.compute_cgraph_o(aabb_sizes.data());
+            t.compute_cgraph_o(cgraph_o, aabb_sizes.data());
             for (const auto &c : cgraph_o) {
                 REQUIRE(c.empty());
             }

From 629c0a8c0bdb0f3814cec3cfb79e14749d6801c4 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 16 Jul 2019 10:45:23 +0200
Subject: [PATCH 30/38] A couple of internal doc bits. [skip ci]

---
 include/rakau/tree.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/include/rakau/tree.hpp b/include/rakau/tree.hpp
index 870605e..51d8d74 100644
--- a/include/rakau/tree.hpp
+++ b/include/rakau/tree.hpp
@@ -374,6 +374,10 @@ struct morton_decoder<2, std::uint32_t> {
 // Discretize a coordinate in a square domain of size 1/inv_box_size.
 // If Clamp is true, then the coordinate will be clamped within
 // the domain.
+// NOTE: for the eventual vectorisation of this function, it looks
+// unlikely we can do it on AVX/AVX2 due to the lack of functions
+// manipulating/converting 64bit integers. AVX-512 looks much more
+// promising in this sense.
 template <std::size_t NDim, typename UInt, bool Clamp = false, typename F>
 inline UInt disc_single_coord(const F &x, const F &inv_box_size)
 {
@@ -385,6 +389,9 @@ inline UInt disc_single_coord(const F &x, const F &inv_box_size)
     // and box_size/2 becomes 1.
     auto tmp = fma_wrap(x, inv_box_size, F(1) / F(2));
     // Rescale by factor.
+    // NOTE: in theory we could avoid this extra multiplication
+    // by having the user pass in factor * inv_box_size, rather
+    // than just inv_box_size.
     tmp *= F(factor);
 
     // Check: don't end up with a nonfinite value.

From bba588b5888da246b124de763a663e1559f7e3be Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 16 Jul 2019 10:48:37 +0200
Subject: [PATCH 31/38] Disable the coll test on travis for some builds.

---
 tools/install_travis.sh | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/tools/install_travis.sh b/tools/install_travis.sh
index 5833dc9..b797d38 100755
--- a/tools/install_travis.sh
+++ b/tools/install_travis.sh
@@ -25,13 +25,16 @@ elif [[ "${RAKAU_BUILD}" == "gcc7_debug" ]]; then
 elif [[ "${RAKAU_BUILD}" == "gcc7_debug_nosimd" ]]; then
     CXX=g++-7 cmake -DCMAKE_INSTALL_PREFIX=$deps_dir -DCMAKE_PREFIX_PATH=$deps_dir -DCMAKE_BUILD_TYPE=Debug -DRAKAU_BUILD_TESTS=yes -DCMAKE_CXX_FLAGS="-D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC -DRAKAU_DISABLE_SIMD" -DRAKAU_TEST_NSPLIT=${TEST_NSPLIT} -DRAKAU_TEST_SPLIT_NUM=${SPLIT_TEST_NUM} ../;
     make -j2 VERBOSE=1;
-    ctest -V;
+    # Don't run the collision test, as there's no SIMD-specific code in there.
+    ctest -V -E coll;
 elif [[ "${RAKAU_BUILD}" == "gcc7_debug_native" ]]; then
     CXX=g++-7 cmake -DCMAKE_INSTALL_PREFIX=$deps_dir -DCMAKE_PREFIX_PATH=$deps_dir -DCMAKE_BUILD_TYPE=Debug -DRAKAU_BUILD_TESTS=yes -DCMAKE_CXX_FLAGS="-D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC -march=native" -DRAKAU_TEST_NSPLIT=${TEST_NSPLIT} -DRAKAU_TEST_SPLIT_NUM=${SPLIT_TEST_NUM} ../;
     make -j2 VERBOSE=1;
-    ctest -V;
+    # Don't run the collision test, as there's no SIMD-specific code in there.
+    ctest -V -E coll;
 elif [[ "${RAKAU_BUILD}" == "gcc7_debug_native_norsqrt" ]]; then
     CXX=g++-7 cmake -DCMAKE_INSTALL_PREFIX=$deps_dir -DCMAKE_PREFIX_PATH=$deps_dir -DCMAKE_BUILD_TYPE=Debug -DRAKAU_BUILD_TESTS=yes -DRAKAU_ENABLE_RSQRT=no -DCMAKE_CXX_FLAGS="-D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC -march=native" -DRAKAU_TEST_NSPLIT=${TEST_NSPLIT} -DRAKAU_TEST_SPLIT_NUM=${SPLIT_TEST_NUM} ../;
     make -j2 VERBOSE=1;
-    ctest -V;
+    # Don't run the collision test, as there's no SIMD-specific code in there.
+    ctest -V -E coll;
 fi

From 267974128d1ee318a61f81421ec248bb0707e0fb Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Wed, 24 Jul 2019 11:43:23 +0200
Subject: [PATCH 32/38] Use aligned_alloc() properly.

---
 include/rakau/detail/di_aligned_allocator.hpp | 22 +++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/include/rakau/detail/di_aligned_allocator.hpp b/include/rakau/detail/di_aligned_allocator.hpp
index d8e86f5..773d9d6 100644
--- a/include/rakau/detail/di_aligned_allocator.hpp
+++ b/include/rakau/detail/di_aligned_allocator.hpp
@@ -11,6 +11,7 @@
 
 #include <cstddef>
 #include <cstdlib>
+#include <limits>
 #include <new>
 #include <type_traits>
 #include <utility>
@@ -47,11 +48,20 @@ struct di_aligned_allocator {
     // https://en.cppreference.com/w/cpp/memory/allocator
     using is_always_equal = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;
+    // Max number of allocatable objects.
+    size_type max_size() const
+    {
+        // For allocating N value_types, we might need up to
+        // N*sizeof(value_type) + Alignment - 1 bytes. This number
+        // must be representable by size_type.
+        // NOTE: drop the -1 from the computation to simplify.
+        return (std::numeric_limits<size_type>::max() - Alignment) / sizeof(value_type);
+    }
     // Allocation.
     T *allocate(size_type n) const
     {
         // Total size in bytes. This is prevented from being too large
-        // by the default implementation of max_size().
+        // by max_size().
         const auto size = n * sizeof(T);
         void *retval;
         if (Alignment == 0u) {
@@ -64,6 +74,8 @@ struct di_aligned_allocator {
             // we will set retval to nullptr to signal that the allocation failed
             // (so that we can handle the allocation failure in the same codepath
             // as aligned_alloc()).
+            // NOTE: unlike aligned_alloc(), posix_memalign() does not have any
+            // constraint on the allocation size.
             if (::posix_memalign(&retval, Alignment, size)) {
                 retval = nullptr;
             }
@@ -75,7 +87,13 @@ struct di_aligned_allocator {
             // NOTE: some early versions of GCC put aligned_alloc in the root namespace rather
             // than std, so let's try to workaround.
             using namespace std;
-            retval = aligned_alloc(Alignment, size);
+
+            const auto rem = size % Alignment;
+            if (rem) {
+                retval = aligned_alloc(Alignment, size + (Alignment - rem));
+            } else {
+                retval = aligned_alloc(Alignment, size);
+            }
 #endif
         }
         if (!retval) {

From 2791922dbd43c96371a4be6bc7e8c7349be68ffb Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Sun, 28 Jul 2019 11:25:00 +0200
Subject: [PATCH 33/38] Updated the FindTBB script.

---
 cmake/FindTBB.cmake | 877 +++++++++++++++++++-------------------------
 1 file changed, 376 insertions(+), 501 deletions(-)

diff --git a/cmake/FindTBB.cmake b/cmake/FindTBB.cmake
index ca28351..b1a3d88 100644
--- a/cmake/FindTBB.cmake
+++ b/cmake/FindTBB.cmake
@@ -1,546 +1,421 @@
-#.rst:
-# FindTBB
-# -------
+# - Find ThreadingBuildingBlocks include dirs and libraries
+# Use this module by invoking find_package with the form:
+#  find_package(TBB
+#    [REQUIRED]             # Fail with error if TBB is not found
+#    )                      #
+# Once done, this will define
+#
+#  TBB_FOUND - system has TBB
+#  TBB_INCLUDE_DIRS - the TBB include directories
+#  TBB_LIBRARIES - TBB libraries to be lined, doesn't include malloc or
+#                  malloc proxy
+#  TBB::tbb - imported target for the TBB library
+#
+#  TBB_VERSION_MAJOR - Major Product Version Number
+#  TBB_VERSION_MINOR - Minor Product Version Number
+#  TBB_INTERFACE_VERSION - Engineering Focused Version Number
+#  TBB_COMPATIBLE_INTERFACE_VERSION - The oldest major interface version
+#                                     still supported. This uses the engineering
+#                                     focused interface version numbers.
+#
+#  TBB_MALLOC_FOUND - system has TBB malloc library
+#  TBB_MALLOC_INCLUDE_DIRS - the TBB malloc include directories
+#  TBB_MALLOC_LIBRARIES - The TBB malloc libraries to be lined
+#  TBB::malloc - imported target for the TBB malloc library
+#
+#  TBB_MALLOC_PROXY_FOUND - system has TBB malloc proxy library
+#  TBB_MALLOC_PROXY_INCLUDE_DIRS = the TBB malloc proxy include directories
+#  TBB_MALLOC_PROXY_LIBRARIES - The TBB malloc proxy libraries to be lined
+#  TBB::malloc_proxy - imported target for the TBB malloc proxy library
 #
-# Find Intel's Threading Building Blocks (TBB) include path and libraries.
 #
 # This module reads hints about search locations from variables:
-#
-# ::
-#
-#    TBB_ROOT                         - Root directory of pre-built TBB package.
-#                                       Can be an environment variable instead. It is
-#                                       derived from the found TBB_INCLUDE_DIR if unset.
-#    TBB_ARCH_PLATFORM                - Environment variable which can be used to specify
-#                                       architecture and platform specific library path
-#                                       suffix (excluding "/lib/" suffix or prefix).
-#                                       For MSVC, the appropriate link library path of the
-#                                       official pre-built download package from the TBB
-#                                       web site is chosen by this module. The path suffix
-#                                       derived from this variable takes precedence.
-#
-# This module considers the following CMake variables set by find_package:
-#
-# ::
-#
-#    TBB_FIND_COMPONENTS              - Case-insensitive names of requested libraries:
-#                                       tbb, [tbb]malloc, [tbb]malloc_proxy
-#    TBB_FIND_REQUIRED_<C>            - Whether TBB library component <C> is required.
-#                                       TBB is considered to be not found when at least
-#                                       one required library or its include path is missing.
-#                                       When no TBB_FIND_COMPONENTS are specified, only the
-#                                       threading library "tbb" is required.
-#    TBB_FIND_REQUIRED                - Raise FATAL_ERROR when required components not found.
-#    TBB_FIND_QUIETLY                 - Suppress all other (status) messages.
-#
-# The TBB_DEBUG variable can be set to TRUE before find_package(TBB) to
-# enable verbose output which helps to debug the processing of this module:
-#
-# ::
-#
-#    set(TBB_DEBUG TRUE)
-#    find_package(TBB)
-#
-# This module defines the following variables:
-#
-# ::
-#
-#    TBB_FOUND                        - Whether TBB libraries were found.
-#    TBB_INCLUDE_DIR                  - TBB library include path where tbb/tbb_stddef.h is located.
-#                                       Used as HINTS for find_path of TBB_<C>_INCLUDE_DIR.
-#    TBB_INCLUDE_DIRS                 - Include paths of found TBB libraries.
-#    TBB_LIBRARIES                    - File paths of found TBB libraries.
-#    TBB_VERSION                      - Version for use in VERSION_LESS et al. comparisons.
-#    TBB_VERSION_MAJOR                - Major library version number.
-#    TBB_VERSION_MINOR                - Minor library version number.
-#    TBB_VERSION_STRING               - Version string for output messages.
-#    TBB_INTERFACE_VERSION            - API version number.
-#    TBB_COMPATIBLE_INTERFACE_VERSION - The oldest major version still supported.
-#
-# Additionally, for each requested component, this module defines the following variables:
-#
-# ::
-#
-#    TBB_TBB_FOUND                    - Whether TBB threading library was found.
-#    TBB_TBB_INCLUDE_DIR              - Include path of TBB threading library.
-#    TBB_TBB_INCLUDE_DIRS             - Include paths for use of TBB library.
-#    TBB_TBB_LIBRARIES                - TBB threading library and transitive link dependencies.
-#    TBB_TBB_LIBRARY_RELEASE          - File path of optimized TBB link library.
-#    TBB_TBB_LIBRARY_DEBUG            - File path of TBB link library with debug symbols.
-#    TBB_TBB_LIBRARY                  - File paths of both "optimized" and "debug" TBB threading link libraries.
-#                                       When only one of these is found, this variable is set to either
-#                                       TBB_TBB_LIBRARY_RELEASE or TBB_TBB_LIBRARY_DEBUG.
-#
-#    TBB_MALLOC_FOUND                 - Whether TBB malloc library was found.
-#    TBB_MALLOC_INCLUDE_DIR           - Include path of TBB malloc library.
-#    TBB_MALLOC_INCLUDE_DIRS          - Include paths for use of TBB malloc library.
-#    TBB_MALLOC_LIBRARIES             - TBB malloc library and transitive link dependencies.
-#    TBB_MALLOC_LIBRARY_RELEASE       - File path of optimized TBB malloc link library.
-#    TBB_MALLOC_LIBRARY_DEBUG         - File path of TBB malloc link library with debug symbols.
-#    TBB_MALLOC_LIBRARY               - File paths of both "optimized" and "debug" TBB malloc link libraries.
-#                                       When only one of these is found, this variable is set to either
-#                                       TBB_MALLOC_LIBRARY_RELEASE or TBB_MALLOC_LIBRARY_DEBUG.
-#
-#    TBB_MALLOC_PROXY_FOUND           - Whether TBB malloc proxy library was found.
-#    TBB_MALLOC_PROXY_INCLUDE_DIR     - Include path of TBB malloc proxy library.
-#    TBB_MALLOC_PROXY_INCLUDE_DIRS    - Include paths for use of TBB malloc proxy library.
-#    TBB_MALLOC_PROXY_LIBRARIES       - TBB malloc proxy library and transitive link dependencies.
-#    TBB_MALLOC_PROXY_LIBRARY_RELEASE - File path of optimized TBB malloc proxy link library.
-#    TBB_MALLOC_PROXY_LIBRARY_DEBUG   - File path of TBB malloc proxy link library with debug symbols.
-#    TBB_MALLOC_PROXY_LIBRARY         - File paths of both "optimized" and "debug" TBB malloc proxy link libraries.
-#                                       When only one of these is found, this variable is set to either
-#                                       TBB_MALLOC_PROXY_LIBRARY_RELEASE or TBB_MALLOC_PROXY_LIBRARY_DEBUG.
-#
-# of these, the following variables are added as advanced cache entries:
-#
-# ::
-#
-#    TBB_INCLUDE_DIR
-#    TBB_<C>_INCLUDE_DIR
-#    TBB_<C>_LIBRARY_RELEASE
-#    TBB_<C>_LIBRARY_DEBUG
-#
-# This module further defines the following import targets with the IMPORTED and INTERFACE
-# properties set appropriately such that only a target_link_libraries command is required
-# to declare the dependency of another target on the respective TBB library component.
-# The use of these import targets instead of above defined variables is recommended.
-#
-# ::
-#
-#    TBB::tbb          - TBB threading library.
-#    TBB::malloc       - TBB malloc library.
-#    TBB::malloc_proxy - TBB malloc proxy library.
-#
-# Example usage:
-#
-# ::
-#
-#    find_package(TBB REQUIRED COMPONENTS tbb OPTIONAL_COMPONENTS malloc)
-#
-#    add_executable(foo foo.cc)
-#    target_link_libraries(foo TBB::tbb)
-#    if (TARGET TBB::malloc)
-#    # or if (TBB_MALLOC_FOUND)
-#      target_link_libraries(foo TBB::malloc)
-#    endif ()
-#
-# This module was written by Andreas Schuh for CMake BASIS with inspiration
-# from the FindTBB module which was originally part of the Object-oriented
-# Graphics Rendering Engine (OGRE) project with modifications by Robert Maynard.
-
-# Copyright (c) 2011-2012 University of Pennsylvania
-# Copyright (c) 2013-2014 Carnegie Mellon University
-# Copyright (c) 2013-2016 Andreas Schuh
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met: 
-#
-# 1. Redistributions of source code must retain the above copyright notice, this
-#    list of conditions and the following disclaimer. 
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-#    this list of conditions and the following disclaimer in the documentation
-#    and/or other materials provided with the distribution. 
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-if (NOT TBB_FIND_QUIETLY)
-  set(_TBB_FIND_STATUS "Looking for TBB")
-  if (TBB_FIND_COMPONENTS)
-    set(_TBB_FIND_STATUS "${_TBB_FIND_STATUS} [${TBB_FIND_COMPONENTS}]")
+#  ENV TBB_ARCH_PLATFORM - for eg. set it to "mic" for Xeon Phi builds
+#  ENV TBB_ROOT or just TBB_ROOT - root directory of tbb installation
+#  ENV TBB_BUILD_PREFIX - specifies the build prefix for user built tbb
+#                         libraries. Should be specified with ENV TBB_ROOT
+#                         and optionally...
+#  ENV TBB_BUILD_DIR - if build directory is different than ${TBB_ROOT}/build
+#
+#
+# Modified by Robert Maynard from the original OGRE source
+#
+#-------------------------------------------------------------------
+# This file is part of the CMake build system for OGRE
+#     (Object-oriented Graphics Rendering Engine)
+# For the latest info, see http://www.ogre3d.org/
+#
+# The contents of this file are placed in the public domain. Feel
+# free to make use of it in any way you like.
+#-------------------------------------------------------------------
+#
+#=============================================================================
+# Copyright 2010-2012 Kitware, Inc.
+# Copyright 2012      Rolf Eike Beer <eike@sf-mail.de>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+#=============================================================================
+#  FindTBB helper functions and macros
+#
+
+#====================================================
+# Fix the library path in case it is a linker script
+#====================================================
+function(tbb_extract_real_library library real_library)
+  if(NOT UNIX OR NOT EXISTS ${library})
+    set(${real_library} "${library}" PARENT_SCOPE)
+    return()
+  endif()
+
+  #Read in the first 4 bytes and see if they are the ELF magic number
+  set(_elf_magic "7f454c46")
+  file(READ ${library} _hex_data OFFSET 0 LIMIT 4 HEX)
+  if(_hex_data STREQUAL _elf_magic)
+    #we have opened a elf binary so this is what
+    #we should link to
+    set(${real_library} "${library}" PARENT_SCOPE)
+    return()
+  endif()
+
+  file(READ ${library} _data OFFSET 0 LIMIT 1024)
+  if("${_data}" MATCHES "INPUT \\(([^(]+)\\)")
+    #extract out the .so name from REGEX MATCH command
+    set(_proper_so_name "${CMAKE_MATCH_1}")
+
+    #construct path to the real .so which is presumed to be in the same directory
+    #as the input file
+    get_filename_component(_so_dir "${library}" DIRECTORY)
+    set(${real_library} "${_so_dir}/${_proper_so_name}" PARENT_SCOPE)
+  else()
+    #unable to determine what this library is so just hope everything works
+    #and pass it unmodified.
+    set(${real_library} "${library}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+#===============================================
+# Do the final processing for the package find.
+#===============================================
+macro(findpkg_finish PREFIX TARGET_NAME)
+  # skip if already processed during this run
+  if (NOT ${PREFIX}_FOUND)
+    if (${PREFIX}_INCLUDE_DIR AND ${PREFIX}_LIBRARY)
+      set(${PREFIX}_FOUND TRUE)
+      set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIR})
+      set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARY})
+    else ()
+      if (${PREFIX}_FIND_REQUIRED AND NOT ${PREFIX}_FIND_QUIETLY)
+        message(FATAL_ERROR "Required library ${PREFIX} not found.")
+      endif ()
+    endif ()
+
+    if (NOT TARGET "TBB::${TARGET_NAME}")
+      if (${PREFIX}_LIBRARY_RELEASE)
+        tbb_extract_real_library(${${PREFIX}_LIBRARY_RELEASE} real_release)
+      endif ()
+      if (${PREFIX}_LIBRARY_DEBUG)
+        tbb_extract_real_library(${${PREFIX}_LIBRARY_DEBUG} real_debug)
+      endif ()
+      add_library(TBB::${TARGET_NAME} UNKNOWN IMPORTED)
+      set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${${PREFIX}_INCLUDE_DIR}")
+      if (${PREFIX}_LIBRARY_DEBUG AND ${PREFIX}_LIBRARY_RELEASE)
+        set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+          IMPORTED_LOCATION "${real_release}"
+          IMPORTED_LOCATION_DEBUG "${real_debug}"
+          IMPORTED_LOCATION_RELEASE "${real_release}")
+      elseif (${PREFIX}_LIBRARY_RELEASE)
+        set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+          IMPORTED_LOCATION "${real_release}")
+      elseif (${PREFIX}_LIBRARY_DEBUG)
+        set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+          IMPORTED_LOCATION "${real_debug}")
+      endif ()
+    endif ()
+
+   #mark the following variables as internal variables
+   mark_as_advanced(${PREFIX}_INCLUDE_DIR
+                    ${PREFIX}_LIBRARY
+                    ${PREFIX}_LIBRARY_DEBUG
+                    ${PREFIX}_LIBRARY_RELEASE)
   endif ()
-  if (NOT TBB_FIND_REQUIRED)
-    set(_TBB_FIND_STATUS "${_TBB_FIND_STATUS} (optional)")
+endmacro()
+
+#===============================================
+# Generate debug names from given release names
+#===============================================
+macro(get_debug_names PREFIX)
+  foreach(i ${${PREFIX}})
+    set(${PREFIX}_DEBUG ${${PREFIX}_DEBUG} ${i}d ${i}D ${i}_d ${i}_D ${i}_debug ${i})
+  endforeach()
+endmacro()
+
+#===============================================
+# See if we have env vars to help us find tbb
+#===============================================
+macro(getenv_path VAR)
+   set(ENV_${VAR} $ENV{${VAR}})
+   # replace won't work if var is blank
+   if (ENV_${VAR})
+     string( REGEX REPLACE "\\\\" "/" ENV_${VAR} ${ENV_${VAR}} )
+   endif ()
+endmacro()
+
+#===============================================
+# Couple a set of release AND debug libraries
+#===============================================
+macro(make_library_set PREFIX)
+  if (${PREFIX}_RELEASE AND ${PREFIX}_DEBUG)
+    set(${PREFIX} optimized ${${PREFIX}_RELEASE} debug ${${PREFIX}_DEBUG})
+  elseif (${PREFIX}_RELEASE)
+    set(${PREFIX} ${${PREFIX}_RELEASE})
+  elseif (${PREFIX}_DEBUG)
+    set(${PREFIX} ${${PREFIX}_DEBUG})
   endif ()
-  message(STATUS "${_TBB_FIND_STATUS}...")
-endif ()
+endmacro()
 
-# ------------------------------------------------------------------------------
-# Default required/optional components
-if (NOT TBB_FIND_COMPONENTS)
-  set(TBB_FIND_COMPONENTS tbb malloc malloc_proxy)
-  set(TBB_FIND_REQUIRED_tbb          TRUE)
-  set(TBB_FIND_REQUIRED_malloc       FALSE)
-  set(TBB_FIND_REQUIRED_malloc_proxy FALSE)
-endif ()
 
-# ------------------------------------------------------------------------------
-# Normalize component names
-set(_TBB_FIND_COMPONENTS)
-foreach (__TBB_COMPONENT IN LISTS TBB_FIND_COMPONENTS)
-  string(TOUPPER "${__TBB_COMPONENT}" _TBB_COMPONENT)
-  string(REGEX REPLACE "^TBB_?([A-Z_]+)$" "\\1" _TBB_COMPONENT "${_TBB_COMPONENT}")
-  if (_TBB_COMPONENT MATCHES "^(TBB|MALLOC|MALLOC_PROXY)$")
-    set(_TBB_${_TBB_COMPONENT}_NAME ${__TBB_COMPONENT})
-    list(APPEND _TBB_FIND_COMPONENTS ${_TBB_COMPONENT})
-    if (TBB_FIND_REQUIRED_${__TBB_COMPONENT})
-      set(_TBB_FIND_REQUIRED_${_TBB_COMPONENT} TRUE)
-    else ()
-      set(_TBB_FIND_REQUIRED_${_TBB_COMPONENT} FALSE)
-    endif ()
-  else ()
-    message(FATAL_ERROR "Unknown TBB library component: ${__TBB_COMPONENT}\n"
-                        "Valid component names are: tbb, [tbb]malloc, [tbb]malloc_proxy")
+#=============================================================================
+#  Now to actually find TBB
+#
+
+# Get path, convert backslashes as ${ENV_${var}}
+getenv_path(TBB_ROOT)
+
+# initialize search paths
+set(TBB_PREFIX_PATH ${TBB_ROOT} ${ENV_TBB_ROOT})
+set(TBB_INC_SEARCH_PATH "")
+set(TBB_LIB_SEARCH_PATH "")
+
+
+# If user built from sources
+set(TBB_BUILD_PREFIX $ENV{TBB_BUILD_PREFIX})
+if (TBB_BUILD_PREFIX AND ENV_TBB_ROOT)
+  getenv_path(TBB_BUILD_DIR)
+  if (NOT ENV_TBB_BUILD_DIR)
+    set(ENV_TBB_BUILD_DIR ${ENV_TBB_ROOT}/build)
   endif ()
-endforeach ()
-unset(__TBB_COMPONENT)
 
-if (TBB_DEBUG)
-  message("** FindTBB: Components = [${_TBB_FIND_COMPONENTS}]")
+  # include directory under ${ENV_TBB_ROOT}/include
+  list(APPEND TBB_LIB_SEARCH_PATH
+    ${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_release
+    ${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_debug)
 endif ()
 
-# ------------------------------------------------------------------------------
-# Names of headers and libraries for each component
-set(_TBB_TBB_LIB_NAMES_RELEASE          tbb)
-set(_TBB_TBB_LIB_NAMES_DEBUG            tbb_debug)
-set(_TBB_TBB_INC_NAMES                  tbb/tbb.h)
-
-set(_TBB_MALLOC_LIB_NAMES_RELEASE       tbbmalloc)
-set(_TBB_MALLOC_LIB_NAMES_DEBUG         tbbmalloc_debug)
-set(_TBB_MALLOC_INC_NAMES               tbb/tbb.h)
-
-set(_TBB_MALLOC_PROXY_LIB_NAMES_RELEASE tbbmalloc_proxy)
-set(_TBB_MALLOC_PROXY_LIB_NAMES_DEBUG   tbbmalloc_proxy_debug)
-set(_TBB_MALLOC_PROXY_INC_NAMES         tbb/tbbmalloc_proxy.h)
-
-# ------------------------------------------------------------------------------
-# Transitive link dependencies
-set(_TBB_TBB_LIB_LINK_DEPENDS)
-set(_TBB_MALLOC_LIB_LINK_DEPENDS)
-set(_TBB_MALLOC_PROXY_LIB_LINK_DEPENDS)
-
-if (UNIX AND NOT APPLE)
-  # On Linux, the TBB threading library requires librt.so
-  list(APPEND _TBB_TBB_LIB_LINK_DEPENDS rt)
-endif ()
 
-# ------------------------------------------------------------------------------
-# Construct a set of search paths
-set(_TBB_ARCH_PLATFORM $ENV{TBB_ARCH_PLATFORM})
+# For Windows, let's assume that the user might be using the precompiled
+# TBB packages from the main website. These use a rather awkward directory
+# structure (at least for automatically finding the right files) depending
+# on platform and compiler, but we'll do our best to accommodate it.
+# Not adding the same effort for the precompiled linux builds, though. Those
+# have different versions for CC compiler versions and linux kernels which
+# will never adequately match the user's setup, so there is no feasible way
+# to detect the "best" version to use. The user will have to manually
+# select the right files. (Chances are the distributions are shipping their
+# custom version of tbb, anyway, so the problem is probably nonexistent.)
+if (WIN32 AND MSVC)
+  set(COMPILER_PREFIX "vc7.1")
+  if (MSVC_VERSION EQUAL 1400)
+    set(COMPILER_PREFIX "vc8")
+  elseif(MSVC_VERSION EQUAL 1500)
+    set(COMPILER_PREFIX "vc9")
+  elseif(MSVC_VERSION EQUAL 1600)
+    set(COMPILER_PREFIX "vc10")
+  elseif(MSVC_VERSION EQUAL 1700)
+    set(COMPILER_PREFIX "vc11")
+  elseif(MSVC_VERSION EQUAL 1800)
+    set(COMPILER_PREFIX "vc12")
+  elseif(MSVC_VERSION EQUAL 1900)
+    set(COMPILER_PREFIX "vc14")
+  endif ()
 
-if (NOT TBB_ROOT)
-  file(TO_CMAKE_PATH "$ENV{TBB_ROOT}" TBB_ROOT)
+  # for each prefix path, add ia32/64\${COMPILER_PREFIX}\lib to the lib search path
+  foreach (dir IN LISTS TBB_PREFIX_PATH)
+    if (CMAKE_CL_64)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia64/${COMPILER_PREFIX}/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia64/${COMPILER_PREFIX})
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${COMPILER_PREFIX}/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${COMPILER_PREFIX})
+    else ()
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${COMPILER_PREFIX}/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${COMPILER_PREFIX})
+    endif ()
+  endforeach ()
 endif ()
 
-set(_TBB_INC_PATH_SUFFIXES include)
+# For OS X binary distribution, choose libc++ based libraries for Mavericks (10.9)
+# and above and AppleClang
+if (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND
+    NOT CMAKE_SYSTEM_VERSION VERSION_LESS 13.0)
+  set (USE_LIBCXX OFF)
+  cmake_policy(GET CMP0025 POLICY_VAR)
 
-set(_TBB_LIB_PATH_SUFFIXES)
-if (_TBB_ARCH_PLATFORM)
-  list(APPEND _TBB_LIB_PATH_SUFFIXES lib/${_TBB_ARCH_PLATFORM})
-  list(APPEND _TBB_LIB_PATH_SUFFIXES ${_TBB_ARCH_PLATFORM}/lib)
-endif ()
-list(APPEND _TBB_LIB_PATH_SUFFIXES lib)
-
-if (WIN32 AND MSVC AND CMAKE_GENERATOR MATCHES "Visual Studio ([0-9]+)")
-  set(_TBB_MSVS_VERSION ${CMAKE_MATCH_1})
-  if (CMAKE_CL_64)
-    list(APPEND _TBB_LIB_PATH_SUFFIXES lib/intel64/vc${_TBB_MSVS_VERSION})
-    list(APPEND _TBB_LIB_PATH_SUFFIXES intel64/vc${_TBB_MSVS_VERSION}/lib)
-    list(APPEND _TBB_LIB_PATH_SUFFIXES lib/ia64/vc${_TBB_MSVS_VERSION})
-    list(APPEND _TBB_LIB_PATH_SUFFIXES ia64/vc${_TBB_MSVS_VERSION}/lib)
+  if (POLICY_VAR STREQUAL "NEW")
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+      set (USE_LIBCXX ON)
+    endif ()
   else ()
-    list(APPEND _TBB_LIB_PATH_SUFFIXES lib/ia32/vc${_TBB_MSVS_VERSION})
-    list(APPEND _TBB_LIB_PATH_SUFFIXES ia32/vc${_TBB_MSVS_VERSION}/lib)
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+      set (USE_LIBCXX ON)
+    endif ()
   endif ()
-  unset(_TBB_MSVS_VERSION)
-endif ()
 
-if (TBB_DEBUG)
-  message("** FindTBB: Initial search paths:")
-  message("** FindTBB: - Root directory hints  = [${TBB_ROOT}]")
-  message("** FindTBB: - Include path suffixes = [${_TBB_INC_PATH_SUFFIXES}]")
-  message("** FindTBB: - Library path suffixes = [${_TBB_LIB_PATH_SUFFIXES}]")
-endif ()
-
-# ------------------------------------------------------------------------------
-# Find common include directory 
-#
-# Looking for tbb/tbb_stddef.h because we use this path later to read this file
-# in order to extract the version information. The tbb.h header should be in the
-# same directory and is searched for separately as part of the "tbb" and "malloc"
-# component search. The TBB_INCLUDE_DIR is then used as HINTS.
-find_path(TBB_INCLUDE_DIR
-  NAMES tbb/tbb_stddef.h
-  HINTS ${TBB_ROOT}
-  PATH_SUFFIXES ${_TBB_INC_PATH_SUFFIXES}
-)
-
-mark_as_advanced(TBB_INCLUDE_DIR)
-
-# ------------------------------------------------------------------------------
-# Derive TBB_ROOT from TBB_INCLUDE_DIR if unset
-if (TBB_INCLUDE_DIR AND NOT TBB_ROOT)
-  if (_TBB_INC_PATH_SUFFIXES MATCHES "[^/;]/[^/;]")
-    string(LENGTH "${TBB_INCLUDE_DIR}" _TBB_INCLUDE_DIR_LENGTH)
-    foreach (_TBB_INC_PATH_SUFFIX IN LISTS _TBB_INC_PATH_SUFFIXES)
-      string(LENGTH "${_TBB_INC_PATH_SUFFIX}" _TBB_INC_PATH_SUFFIX_LENGTH)
-      if (_TBB_INC_PATH_SUFFIX_LENGTH GREATER 0)
-        math(EXPR _TBB_SUBSTRING_START "${_TBB_INCLUDE_DIR_LENGTH} - ${_TBB_INC_PATH_SUFFIX_LENGTH}")
-        string(SUBSTRING "${TBB_INCLUDE_DIR}" _TBB_SUBSTRING_START -1 _TBB_SUBSTRING)
-        if (_TBB_SUBSTRING STREQUAL _TBB_INC_PATH_SUFFIX)
-          if (_TBB_SUBSTRING_START GREATER 0)
-            string(SUBSTRING "${TBB_INCLUDE_DIR}" 0 _TBB_SUBSTRING_START TBB_ROOT)
-            string(REGEX REPLACE "/+$" "" TBB_ROOT "${TBB_ROOT}")
-          else ()
-            set(TBB_ROOT "/")
-          endif ()
-          break()
-        endif ()
-      endif ()
+  if (USE_LIBCXX)
+    foreach (dir IN LISTS TBB_PREFIX_PATH)
+      list (APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/libc++ ${dir}/libc++/lib)
     endforeach ()
-    unset(_TBB_SUBSTRING)
-    unset(_TBB_SUBSTRING_START)
-    unset(_TBB_INCLUDE_DIR_LENGTH)
-    unset(_TBB_INC_PATH_SUFFIX_LENGTH)
-  else ()
-    get_filename_component(TBB_ROOT "${TBB_INCLUDE_DIR}" DIRECTORY)
   endif ()
 endif ()
 
-if (TBB_DEBUG)
-  message("** FindTBB: After initial search of TBB include path")
-  message("** FindTBB: - TBB_INCLUDE_DIR = ${TBB_INCLUDE_DIR}")
-  message("** FindTBB: - TBB_ROOT        = [${TBB_ROOT}]")
+# check compiler ABI
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  set(COMPILER_PREFIX)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
+    list(APPEND COMPILER_PREFIX "gcc4.7")
+  endif()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4)
+    list(APPEND COMPILER_PREFIX "gcc4.4")
+  endif()
+  list(APPEND COMPILER_PREFIX "gcc4.1")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set(COMPILER_PREFIX)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6)
+    list(APPEND COMPILER_PREFIX "gcc4.7")
+  endif()
+  list(APPEND COMPILER_PREFIX "gcc4.4")
+else() # Assume compatibility with 4.4 for other compilers
+  list(APPEND COMPILER_PREFIX "gcc4.4")
 endif ()
 
-# ------------------------------------------------------------------------------
-# Find library components
-set(TBB_INCLUDE_DIRS)
-set(TBB_LIBRARIES)
+# if platform architecture is explicitly specified
+set(TBB_ARCH_PLATFORM $ENV{TBB_ARCH_PLATFORM})
+if (TBB_ARCH_PLATFORM)
+  foreach (dir IN LISTS TBB_PREFIX_PATH)
+    list(APPEND TBB_LIB_SEARCH_PATH ${dir}/${TBB_ARCH_PLATFORM}/lib)
+    list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/${TBB_ARCH_PLATFORM})
+  endforeach ()
+endif ()
 
-foreach (_TBB_COMPONENT IN LISTS _TBB_FIND_COMPONENTS)
-  if (TBB_DEBUG)
-    message("** FindTBB: Looking for component ${_TBB_COMPONENT}...")
-  endif ()
+foreach (dir IN LISTS TBB_PREFIX_PATH)
+  foreach (prefix IN LISTS COMPILER_PREFIX)
+    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${prefix})
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${prefix}/lib)
+    else ()
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${prefix})
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${prefix}/lib)
+    endif ()
+  endforeach()
+endforeach ()
 
-  # Find include path and library files of this component
-  find_path(TBB_${_TBB_COMPONENT}_INCLUDE_DIR
-    NAMES ${_TBB_${_TBB_COMPONENT}_INC_NAMES}
-    HINTS ${TBB_INCLUDE_DIR} ${TBB_ROOT}
-    PATH_SUFFIXES ${_TBB_INC_PATH_SUFFIXES}
-  )
-
-  find_library(TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE
-    NAMES ${_TBB_${_TBB_COMPONENT}_LIB_NAMES_RELEASE}
-    HINTS ${TBB_ROOT}
-    PATH_SUFFIXES ${_TBB_LIB_PATH_SUFFIXES}
-  )
-
-  find_library(TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG
-    NAMES ${_TBB_${_TBB_COMPONENT}_LIB_NAMES_DEBUG}
-    HINTS ${TBB_ROOT}
-    PATH_SUFFIXES ${_TBB_LIB_PATH_SUFFIXES}
-  )
-
-  if (TBB_DEBUG)
-    message("** FindTBB: - TBB_${_TBB_COMPONENT}_INCLUDE_DIR     = ${TBB_${_TBB_COMPONENT}_INCLUDE_DIR}")
-    message("** FindTBB: - TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE = ${TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE}")
-    message("** FindTBB: - TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG   = ${TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG}")
-  endif ()
+# add general search paths
+foreach (dir IN LISTS TBB_PREFIX_PATH)
+  list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib ${dir}/Lib ${dir}/lib/tbb
+    ${dir}/Libs)
+  list(APPEND TBB_INC_SEARCH_PATH ${dir}/include ${dir}/Include
+    ${dir}/include/tbb)
+endforeach ()
 
-  # Mark cache entries as advanced
-  mark_as_advanced(TBB_${_TBB_COMPONENT}_INCLUDE_DIR)
-  mark_as_advanced(TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE)
-  mark_as_advanced(TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG)
-
-  # Set TBB_<C>_LIBRARY
-  if (TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE AND TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG)
-    set(TBB_${_TBB_COMPONENT}_LIBRARY
-      optimized ${TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE}
-      debug     ${TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG}
-    )
-  elseif (TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE)
-    set(TBB_${_TBB_COMPONENT}_LIBRARY ${TBB_${_TBB_COMPONENT}_LIBRARY_RELEASE})
-  elseif (TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG)
-    set(TBB_${_TBB_COMPONENT}_LIBRARY ${TBB_${_TBB_COMPONENT}_LIBRARY_DEBUG})
-  else ()
-    set(TBB_${_TBB_COMPONENT}_LIBRARY TBB_${_TBB_COMPONENT}_LIBRARY-NOTFOUND)
-  endif ()
+set(TBB_LIBRARY_NAMES tbb)
+get_debug_names(TBB_LIBRARY_NAMES)
 
-  # Set TBB_<C>_FOUND
-  if (TBB_${_TBB_COMPONENT}_INCLUDE_DIR AND TBB_${_TBB_COMPONENT}_LIBRARY)
-    set(TBB_${_TBB_COMPONENT}_FOUND TRUE)
-  else ()
-    set(TBB_${_TBB_COMPONENT}_FOUND FALSE)
-  endif ()
-  set(TBB_${_TBB_${_TBB_COMPONENT}_NAME}_FOUND ${TBB_${_TBB_COMPONENT}_FOUND})
 
-  if (TBB_${_TBB_COMPONENT}_FOUND)
+find_path(TBB_INCLUDE_DIR
+          NAMES tbb/tbb.h
+          PATHS ${TBB_INC_SEARCH_PATH})
+
+find_library(TBB_LIBRARY_RELEASE
+             NAMES ${TBB_LIBRARY_NAMES}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+find_library(TBB_LIBRARY_DEBUG
+             NAMES ${TBB_LIBRARY_NAMES_DEBUG}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+make_library_set(TBB_LIBRARY)
+
+findpkg_finish(TBB tbb)
+
+#if we haven't found TBB no point on going any further
+if (NOT TBB_FOUND)
+  return()
+endif ()
 
-    # Add transitive dependencies
-    set(TBB_${_TBB_COMPONENT}_INCLUDE_DIRS ${TBB_${_TBB_COMPONENT}_INCLUDE_DIR})
-    set(TBB_${_TBB_COMPONENT}_LIBRARIES    ${TBB_${_TBB_COMPONENT}_LIBRARY})
-    if (_TBB_${_TBB_COMPONENT}_LIB_LINK_DEPENDS)
-      list(APPEND TBB_${_TBB_COMPONENT}_LIBRARIES "${_TBB_${_TBB_COMPONENT}_LIB_LINK_DEPENDS}")
-    endif ()
+#=============================================================================
+# Look for TBB's malloc package
+set(TBB_MALLOC_LIBRARY_NAMES tbbmalloc)
+get_debug_names(TBB_MALLOC_LIBRARY_NAMES)
 
-    if (TBB_DEBUG)
-      message("** FindTBB: - TBB_${_TBB_COMPONENT}_INCLUDE_DIRS    = [${TBB_${_TBB_COMPONENT}_INCLUDE_DIRS}]")
-      message("** FindTBB: - TBB_${_TBB_COMPONENT}_LIBRARIES       = [${TBB_${_TBB_COMPONENT}_LIBRARIES}]")
-    endif ()
+find_path(TBB_MALLOC_INCLUDE_DIR
+          NAMES tbb/tbb.h
+          PATHS ${TBB_INC_SEARCH_PATH})
 
-    # Add to TBB_INCLUDE_DIRS and TBB_LIBRARIES
-    list(APPEND TBB_INCLUDE_DIRS ${TBB_${_TBB_COMPONENT}_INCLUDE_DIRS})
-    list(APPEND TBB_LIBRARIES    ${TBB_${_TBB_COMPONENT}_LIBRARIES})
-
-    # Add TBB::<C> import target
-    string(TOLOWER ${_TBB_COMPONENT} _TBB_TARGET_NAME)
-    set(_TBB_TARGET_NAME "TBB::${_TBB_TARGET_NAME}")
-    add_library(${_TBB_TARGET_NAME} SHARED IMPORTED)
-
-    set_target_properties(${_TBB_TARGET_NAME} PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES     "${TBB_${_TBB_COMPONENT}_INCLUDE_DIRS}"
-      IMPORTED_LINK_INTERFACE_LANGUAGES CXX
-      IMPORTED_NO_SONAME                TRUE
-    )
-    if (_TBB_${_TBB_COMPONENT}_LIB_LINK_DEPENDS)
-      set_target_properties(${_TBB_TARGET_NAME} PROPERTIES
-        INTERFACE_LINK_LIBRARIES "${_TBB_${_TBB_COMPONENT}_LIB_LINK_DEPENDS}"
-      )
-    endif ()
+find_library(TBB_MALLOC_LIBRARY_RELEASE
+             NAMES ${TBB_MALLOC_LIBRARY_NAMES}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+find_library(TBB_MALLOC_LIBRARY_DEBUG
+             NAMES ${TBB_MALLOC_LIBRARY_NAMES_DEBUG}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+make_library_set(TBB_MALLOC_LIBRARY)
 
-    foreach (_TBB_CONFIGURATION IN ITEMS DEBUG RELEASE)
-      if (TBB_${_TBB_COMPONENT}_LIBRARY_${_TBB_CONFIGURATION})
-        set_property(TARGET ${_TBB_TARGET_NAME} APPEND PROPERTY IMPORTED_CONFIGURATIONS ${_TBB_CONFIGURATION})
-        if (WIN32)
-          set_target_properties(${_TBB_TARGET_NAME} PROPERTIES
-            IMPORTED_IMPLIB_${_TBB_CONFIGURATION} "${TBB_${_TBB_COMPONENT}_LIBRARY_${_TBB_CONFIGURATION}}"
-          )
-          string(REPLACE       "/lib/"   "/bin/" _TBB_LIB_PATH_DLL "${TBB_${_TBB_COMPONENT}_LIBRARY_${_TBB_CONFIGURATION}}")
-          string(REGEX REPLACE "\\.lib$" ".dll"  _TBB_LIB_PATH_DLL "${_TBB_LIB_PATH_DLL}")
-          if (EXISTS "${_TBB_LIB_PATH_DLL}")
-            set_target_properties(${_TBB_TARGET_NAME} PROPERTIES
-              IMPORTED_LOCATION_${_TBB_CONFIGURATION} "${_TBB_LIB_PATH_DLL}"
-            )
-            if (TBB_DEBUG)
-              message("** FindTBB: - IMPORTED_LOCATION_${_TBB_CONFIGURATION} = ${_TBB_LIB_PATH_DLL}")
-            endif ()
-          elseif (TBB_DEBUG)
-            message("** FindTBB: Could not determine ${_TBB_CONFIGURATION} DLL path from import library, tried: "
-                    "\n\t${_TBB_LIB_PATH_DLL}")
-          endif ()
-        else ()
-          set_target_properties(${_TBB_TARGET_NAME} PROPERTIES
-            IMPORTED_LOCATION_${_TBB_CONFIGURATION} "${TBB_${_TBB_COMPONENT}_LIBRARY_${_TBB_CONFIGURATION}}"
-          )
-        endif ()
-      endif ()
-    endforeach ()
+findpkg_finish(TBB_MALLOC tbbmalloc)
 
-    if (TBB_DEBUG)
-      message("** FindTBB: Looking for component ${_TBB_COMPONENT}... - found")
-    endif ()
+#=============================================================================
+# Look for TBB's malloc proxy package
+set(TBB_MALLOC_PROXY_LIBRARY_NAMES tbbmalloc_proxy)
+get_debug_names(TBB_MALLOC_PROXY_LIBRARY_NAMES)
 
-  else ()
+find_path(TBB_MALLOC_PROXY_INCLUDE_DIR
+          NAMES tbb/tbbmalloc_proxy.h
+          PATHS ${TBB_INC_SEARCH_PATH})
 
-    if (TBB_DEBUG)
-      message("** FindTBB: Looking for component ${_TBB_COMPONENT}... - not found")
-    endif ()
-    unset(TBB_${_TBB_COMPONENT}_INCLUDE_DIRS)
-    unset(TBB_${_TBB_COMPONENT}_LIBRARIES)
+find_library(TBB_MALLOC_PROXY_LIBRARY_RELEASE
+             NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+find_library(TBB_MALLOC_PROXY_LIBRARY_DEBUG
+             NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES_DEBUG}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+make_library_set(TBB_MALLOC_PROXY_LIBRARY)
 
-  endif ()
-endforeach ()
+findpkg_finish(TBB_MALLOC_PROXY tbbmalloc_proxy)
 
-if (TBB_INCLUDE_DIRS)
-  list(REMOVE_DUPLICATES TBB_INCLUDE_DIRS)
-endif ()
 
-if (TBB_DEBUG)
-  message("** FindTBB: Include paths and libraries of all found components:")
-  message("** FindTBB: - TBB_INCLUDE_DIRS = [${TBB_INCLUDE_DIRS}]")
-  message("** FindTBB: - TBB_LIBRARIES    = [${TBB_LIBRARIES}]")
-endif ()
+#=============================================================================
+#parse all the version numbers from tbb
+if(NOT TBB_VERSION)
 
-# ------------------------------------------------------------------------------
-# Extract library version from start of tbb_stddef.h
-if (TBB_INCLUDE_DIR)
-  if (NOT DEFINED TBB_VERSION_MAJOR OR
-      NOT DEFINED TBB_VERSION_MINOR OR
-      NOT DEFINED TBB_INTERFACE_VERSION OR
-      NOT DEFINED TBB_COMPATIBLE_INTERFACE_VERSION)
-    file(READ "${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS LIMIT 2048)
-    string(REGEX REPLACE
-      ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1"
-      TBB_VERSION_MAJOR "${_TBB_VERSION_CONTENTS}"
-    )
-    string(REGEX REPLACE
-      ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1"
-      TBB_VERSION_MINOR "${_TBB_VERSION_CONTENTS}"
-    )
-    string(REGEX REPLACE
-      ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1"
-      TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}"
-    )
-    string(REGEX REPLACE
-      ".*#define TBB_COMPATIBLE_INTERFACE_VERSION ([0-9]+).*" "\\1"
-      TBB_COMPATIBLE_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}"
-    )
-    unset(_TBB_VERSION_CONTENTS)
-  endif ()
-  set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}")
-  set(TBB_VERSION_STRING "${TBB_VERSION}")
-else ()
-  unset(TBB_VERSION)
-  unset(TBB_VERSION_MAJOR)
-  unset(TBB_VERSION_MINOR)
-  unset(TBB_VERSION_STRING)
-  unset(TBB_INTERFACE_VERSION)
-  unset(TBB_COMPATIBLE_INTERFACE_VERSION)
-endif ()
+ #only read the start of the file
+ file(STRINGS
+      "${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h"
+      TBB_VERSION_CONTENTS
+      REGEX "VERSION")
 
-if (TBB_DEBUG)
-  message("** FindTBB: Version information from ${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h")
-  message("** FindTBB: - TBB_VERSION_STRING               = ${TBB_VERSION_STRING}")
-  message("** FindTBB: - TBB_VERSION_MAJOR                = ${TBB_VERSION_MAJOR}")
-  message("** FindTBB: - TBB_VERSION_MINOR                = ${TBB_VERSION_MINOR}")
-  message("** FindTBB: - TBB_INTERFACE_VERSION            = ${TBB_INTERFACE_VERSION}")
-  message("** FindTBB: - TBB_COMPATIBLE_INTERFACE_VERSION = ${TBB_COMPATIBLE_INTERFACE_VERSION}")
-endif ()
+  string(REGEX REPLACE
+    ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1"
+    TBB_VERSION_MAJOR "${TBB_VERSION_CONTENTS}")
 
-# ------------------------------------------------------------------------------
-# Handle QUIET, REQUIRED, and [EXACT] VERSION arguments and set TBB_FOUND
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(TBB
-  REQUIRED_VARS TBB_INCLUDE_DIR
-  VERSION_VAR   TBB_VERSION
-  HANDLE_COMPONENTS
-)
-
-if (NOT TBB_FIND_QUIETLY)
-  if (TBB_FOUND)
-    message(STATUS "${_TBB_FIND_STATUS}... - found v${TBB_VERSION_STRING}")
-  else ()
-    message(STATUS "${_TBB_FIND_STATUS}... - not found")
-  endif ()
-endif ()
+  string(REGEX REPLACE
+    ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1"
+    TBB_VERSION_MINOR "${TBB_VERSION_CONTENTS}")
 
-# ------------------------------------------------------------------------------
-# Unset local auxiliary variables
-foreach (_TBB_COMPONENT IN ITEMS TBB MALLOC MALLOC_PROXY)
-  unset(_TBB_FIND_REQUIRED_${_TBB_COMPONENT})
-  unset(_TBB_${_TBB_COMPONENT}_LIB_NAMES_RELEASE)
-  unset(_TBB_${_TBB_COMPONENT}_LIB_NAMES_DEBUG)
-  unset(_TBB_${_TBB_COMPONENT}_LIB_LINK_DEPENDS)
-  unset(_TBB_${_TBB_COMPONENT}_INC_NAMES)
-  unset(_TBB_${_TBB_COMPONENT}_NAME)
-endforeach ()
+  string(REGEX REPLACE
+        ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1"
+        TBB_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
+
+  string(REGEX REPLACE
+        ".*#define TBB_COMPATIBLE_INTERFACE_VERSION ([0-9]+).*" "\\1"
+        TBB_COMPATIBLE_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
 
-unset(_TBB_COMPONENT)
-unset(_TBB_TARGET_NAME)
-unset(_TBB_FIND_COMPONENTS)
-unset(_TBB_FIND_STATUS)
-unset(_TBB_INC_PATH_SUFFIXES)
-unset(_TBB_LIB_PATH_SUFFIXES)
-unset(_TBB_LIB_PATH_DLL)
-unset(_TBB_LIB_NAME)
-unset(_TBB_ARCH_PLATFORM)
+endif()

From 6434f22f1afbabe3055b3e08e74e1f2cce280af3 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 29 Jul 2019 09:18:08 +0200
Subject: [PATCH 34/38] Function rename and use the FMA primitives.

---
 include/rakau/detail/tree_coll.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 3917b09..441773d 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -44,7 +44,7 @@ inline namespace detail
 // such that the node size is larger than the value s. If s >= box_size,
 // 0 will be returned.
 template <typename UInt, std::size_t NDim, typename F>
-inline UInt coll_size_to_level(F s, F box_size)
+inline UInt tree_coll_size_to_level(F s, F box_size)
 {
     assert(std::isfinite(s));
     // NOTE: we assume we never enter here
@@ -347,7 +347,7 @@ inline void tree<NDim, F, UInt, MAC>::compute_cgraph_impl(std::vector<tbb::concu
                     // overlap the enclosing node set.
 
                     // Convert the AABB size to a node level.
-                    const auto aabb_level = detail::coll_size_to_level<UInt, NDim>(aabb_size, m_box_size);
+                    const auto aabb_level = detail::tree_coll_size_to_level<UInt, NDim>(aabb_size, m_box_size);
 
                     // Iterate over the AABB vertices.
                     for (std::size_t i = 0; i < n_vertices; ++i) {
@@ -518,8 +518,8 @@ inline void tree<NDim, F, UInt, MAC>::compute_cgraph_impl(std::vector<tbb::concu
 
                 // Determine the min/max aabb coordinates for the particle idx1.
                 for (std::size_t k = 0; k < NDim; ++k) {
-                    min_aabb[k] = m_parts[k][idx1] - aabb_size1 * (F(1) / F(2));
-                    max_aabb[k] = m_parts[k][idx1] + aabb_size1 * (F(1) / F(2));
+                    min_aabb[k] = detail::fma_wrap(aabb_size1, -F(1) / F(2), m_parts[k][idx1]);
+                    max_aabb[k] = detail::fma_wrap(aabb_size1, F(1) / F(2), m_parts[k][idx1]);
                 }
 
                 for (auto j = i + 1u; j < tot_n; ++j) {

From 3509c8c412dbf4e00dce7c277742ba2b1bbd9208 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 29 Jul 2019 09:20:51 +0200
Subject: [PATCH 35/38] Missed one.

---
 include/rakau/detail/tree_coll.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 441773d..1f8ed41 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -540,8 +540,8 @@ inline void tree<NDim, F, UInt, MAC>::compute_cgraph_impl(std::vector<tbb::concu
                     // Check for AABB overlap.
                     bool overlap = true;
                     for (std::size_t k = 0; k < NDim; ++k) {
-                        const auto min2 = m_parts[k][idx2] - aabb_size2 * (F(1) / F(2));
-                        const auto max2 = m_parts[k][idx2] + aabb_size2 * (F(1) / F(2));
+                        const auto min2 = detail::fma_wrap(aabb_size2, -F(1) / F(2), m_parts[k][idx2]);
+                        const auto max2 = detail::fma_wrap(aabb_size2, F(1) / F(2), m_parts[k][idx2]);
 
                         // NOTE: we regard the AABBs as closed ranges, that is,
                         // a single point in common in two segments is enough

From ad3dbd43595a2b71d2e42e0a98443b9903faaa97 Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Tue, 27 Aug 2019 23:55:36 +0200
Subject: [PATCH 36/38] A couple of build system improvements.

---
 CMakeLists.txt | 52 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 14 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b30274a..bc641f9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,19 +1,21 @@
 cmake_minimum_required(VERSION 3.3.0)
 
-project(rakau VERSION 0.1 LANGUAGES CXX C)
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/yacma")
-
-message(STATUS "System name: ${CMAKE_SYSTEM_NAME}")
-message(STATUS "rakau version: ${rakau_VERSION}")
-
 # Set default build type to "Release".
+# NOTE: this should be done before the project command since the latter can set
+# CMAKE_BUILD_TYPE itself (it does so for nmake).
 if(NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE Release CACHE STRING
 		"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
 	FORCE)
 endif()
 
+project(rakau VERSION 0.1 LANGUAGES CXX C)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/yacma")
+
+message(STATUS "System name: ${CMAKE_SYSTEM_NAME}")
+message(STATUS "rakau version: ${rakau_VERSION}")
+
 # The build options.
 option(RAKAU_BUILD_TESTS "Build unit tests." OFF)
 option(RAKAU_BUILD_BENCHMARKS "Build benchmarks." OFF)
@@ -104,6 +106,28 @@ find_package(TBB REQUIRED)
 # Threading setup.
 include(RakauFindThreads)
 
+# NOTE: on Unix systems, the correct library installation path
+# could be something other than just "lib", such as "lib64",
+# "lib32", etc., depending on platform/configuration. Apparently,
+# CMake provides this information via the GNUInstallDirs module.
+# Let's enable this for now on all Unixes except OSX.
+# NOTE: potentially, this could be applicable to Cygwin as well.
+#
+# https://cmake.org/cmake/help/v3.15/module/GNUInstallDirs.html
+# https://cmake.org/pipermail/cmake/2013-July/055375.html
+if(UNIX AND NOT APPLE)
+    include(GNUInstallDirs)
+    set(_RAKAU_INSTALL_LIBDIR_DEFAULT "${CMAKE_INSTALL_LIBDIR}")
+else()
+    set(_RAKAU_INSTALL_LIBDIR_DEFAULT "lib")
+endif()
+if(NOT RAKAU_INSTALL_LIBDIR)
+    set(RAKAU_INSTALL_LIBDIR "${_RAKAU_INSTALL_LIBDIR_DEFAULT}" CACHE STRING
+        "Library installation directory." FORCE)
+endif()
+mark_as_advanced(RAKAU_INSTALL_LIBDIR)
+message(STATUS "Library installation directory: ${RAKAU_INSTALL_LIBDIR}")
+
 # Initial setup of the rakau library.
 if(RAKAU_WITH_ROCM)
   add_library(rakau SHARED "${CMAKE_CURRENT_SOURCE_DIR}/src/rakau_rocm.cpp")
@@ -185,20 +209,20 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/config.hpp.in" "${CMAKE_CURRENT_BINA
 set(_RAKAU_CONFIG_OPTIONAL_DEPS)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/rakau-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/rakau-config.cmake" @ONLY)
 if(RAKAU_WITH_ROCM OR RAKAU_WITH_CUDA)
-  install(TARGETS rakau EXPORT rakau_export LIBRARY DESTINATION "lib")
+  install(TARGETS rakau EXPORT rakau_export LIBRARY DESTINATION "${RAKAU_INSTALL_LIBDIR}")
 else()
   install(TARGETS rakau EXPORT rakau_export)
 endif()
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/rakau-config.cmake" DESTINATION "lib/cmake/rakau")
-install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/RakauFindBoost.cmake" DESTINATION "lib/cmake/rakau")
-install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindTBB.cmake" DESTINATION "lib/cmake/rakau")
-install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/RakauFindThreads.cmake" DESTINATION "lib/cmake/rakau")
-install(EXPORT rakau_export NAMESPACE rakau:: DESTINATION lib/cmake/rakau)
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/rakau-config.cmake" DESTINATION "${RAKAU_INSTALL_LIBDIR}/cmake/rakau")
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/RakauFindBoost.cmake" DESTINATION "${RAKAU_INSTALL_LIBDIR}/cmake/rakau")
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindTBB.cmake" DESTINATION "${RAKAU_INSTALL_LIBDIR}/cmake/rakau")
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/RakauFindThreads.cmake" DESTINATION "${RAKAU_INSTALL_LIBDIR}/cmake/rakau")
+install(EXPORT rakau_export NAMESPACE rakau:: DESTINATION ${RAKAU_INSTALL_LIBDIR}/cmake/rakau)
 # Take care of versioning.
 include(CMakePackageConfigHelpers)
 write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/rakau-config-version.cmake" VERSION ${rakau_VERSION}
 	COMPATIBILITY SameMajorVersion)
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/rakau-config-version.cmake" DESTINATION "lib/cmake/rakau")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/rakau-config-version.cmake" DESTINATION "${RAKAU_INSTALL_LIBDIR}/cmake/rakau")
 unset(_RAKAU_CONFIG_OPTIONAL_DEPS)
 
 # Installation of the header files.

From 7bd4d37a30e17e829eb9696e8932e0947682538b Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Mon, 13 Jan 2020 12:09:24 +0100
Subject: [PATCH 37/38] Small improvements/cleanups.

---
 include/rakau/detail/tree_coll.hpp | 405 ++++++++++++++---------------
 1 file changed, 202 insertions(+), 203 deletions(-)

diff --git a/include/rakau/detail/tree_coll.hpp b/include/rakau/detail/tree_coll.hpp
index 1f8ed41..efe3aad 100644
--- a/include/rakau/detail/tree_coll.hpp
+++ b/include/rakau/detail/tree_coll.hpp
@@ -29,7 +29,7 @@
 #include <tbb/blocked_range.h>
 #include <tbb/concurrent_vector.h>
 #include <tbb/parallel_for.h>
-#include <tbb/task_group.h>
+#include <tbb/parallel_invoke.h>
 
 #include <rakau/detail/simple_timer.hpp>
 #include <rakau/detail/tree_fwd.hpp>
@@ -228,229 +228,228 @@ inline void tree<NDim, F, UInt, MAC>::compute_cgraph_impl(std::vector<tbb::concu
 
     // Prepare storage for cgraph in parallel
     // with the v_add computation.
-    tbb::task_group tg;
-
-    tg.run([this, &cgraph]() {
-        simple_timer st("cgraph prepare");
+    tbb::parallel_invoke(
+        [this, &cgraph]() {
+            simple_timer st("cgraph prepare");
+
+            // Check if the return value is empty.
+            const auto was_empty = cgraph.empty();
+
+            cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
+
+            if (!was_empty) {
+                // If the return value was not originally empty,
+                // we must make sure that all its vectors are cleared
+                // up before we write into them.
+                tbb::parallel_for(tbb::blocked_range(cgraph.begin(), cgraph.end()), [](const auto &r) {
+                    for (auto &v : r) {
+                        v.clear();
+                    }
+                });
+            }
+        },
+        [this, &clp, &v_add, it, &c_begin, &c_end]() {
+            {
+                simple_timer st("leaves permutation");
+                clp = coll_leaves_permutation();
+            }
 
-        // Check if the return value is empty.
-        const auto empty = cgraph.empty();
+            {
+                simple_timer st("v_add prepare");
+                v_add.resize(boost::numeric_cast<decltype(v_add.size())>(clp.size()));
+            }
 
-        cgraph.resize(boost::numeric_cast<decltype(cgraph.size())>(m_parts[0].size()));
+            simple_timer st("v_add computation");
+
+            // Create the iterators for accessing the leaf nodes.
+            // NOTE: make sure we don't overflow when indexing.
+            detail::it_diff_check<decltype(m_tree.begin())>(m_tree.size());
+            c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
+            c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
+
+            // Pre-compute the inverse of the domain size.
+            const auto inv_box_size = F(1) / m_box_size;
+
+            // Determine the additional particles for each node.
+            tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &v_add, inv_box_size, it, c_begin,
+                                                                   c_end](const auto &r) {
+                // Temporary vector for the particle position.
+                std::array<F, NDim> p_pos;
+
+                // Iteration over the leaf nodes.
+                for (const auto &lnode : r) {
+                    // Fetch/cache some properties of the leaf node.
+                    const auto lcode = lnode.code;
+                    const auto llevel = lnode.level;
+
+                    // Iterate over the particles of the leaf node.
+                    const auto e = lnode.end;
+                    for (auto pidx = lnode.begin; pidx != e; ++pidx) {
+                        // Load the particle's AABB size.
+                        // NOTE: if Ordered, we must transform the original
+                        // pidx, as 'it' points to a vector of aabb sizes sorted
+                        // in the original order.
+                        const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
+
+                        // Check it.
+                        if (rakau_unlikely(!std::isfinite(aabb_size) || aabb_size < F(0))) {
+                            throw std::invalid_argument(
+                                "An invalid AABB size was detected while computing the collision "
+                                "graph: the AABB size must be finite and non-negative, but it is "
+                                + std::to_string(aabb_size) + " instead");
+                        }
 
-        if (!empty) {
-            // If the return value was not originally empty,
-            // we must make sure that all its vectors are cleared
-            // up before we write into them.
-            tbb::parallel_for(tbb::blocked_range(cgraph.begin(), cgraph.end()), [](const auto &r) {
-                for (auto &v : r) {
-                    v.clear();
-                }
-            });
-        }
-    });
+                        // Particles with a null AABB don't participate in collision
+                        // detection and cannot straddle into other nodes.
+                        if (aabb_size == F(0)) {
+                            continue;
+                        }
 
-    tg.run([this, &clp, &v_add, it, &c_begin, &c_end]() {
-        {
-            simple_timer st("leaves permutation");
-            clp = coll_leaves_permutation();
-        }
+                        // Fill in the particle position.
+                        for (std::size_t j = 0; j < NDim; ++j) {
+                            p_pos[j] = m_parts[j][pidx];
+                        }
 
-        {
-            simple_timer st("v_add prepare");
-            v_add.resize(boost::numeric_cast<decltype(v_add.size())>(clp.size()));
-        }
+                        // Compute the clamped codes of the AABB vertices.
+                        const auto aabb_codes = detail::tree_coll_get_aabb_codes<UInt>(p_pos, aabb_size, inv_box_size);
 
-        simple_timer st("v_add computation");
-
-        // Create the iterators for accessing the leaf nodes.
-        // NOTE: make sure we don't overflow when indexing.
-        detail::it_diff_check<decltype(m_tree.begin())>(m_tree.size());
-        c_begin = boost::make_permutation_iterator(m_tree.begin(), clp.begin());
-        c_end = boost::make_permutation_iterator(m_tree.end(), clp.end());
-
-        // Pre-compute the inverse of the domain size.
-        const auto inv_box_size = F(1) / m_box_size;
-
-        // Determine the additional particles for each node.
-        tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &v_add, inv_box_size, it, c_begin,
-                                                               c_end](const auto &r) {
-            // Temporary vector for the particle position.
-            std::array<F, NDim> p_pos;
-
-            // Iteration over the leaf nodes.
-            for (const auto &lnode : r) {
-                // Fetch/cache some properties of the leaf node.
-                const auto lcode = lnode.code;
-                const auto llevel = lnode.level;
-
-                // Iterate over the particles of the leaf node.
-                const auto e = lnode.end;
-                for (auto pidx = lnode.begin; pidx != e; ++pidx) {
-                    // Load the particle's AABB size.
-                    // NOTE: if Ordered, we must transform the original
-                    // pidx, as 'it' points to a vector of aabb sizes sorted
-                    // in the original order.
-                    const auto aabb_size = Ordered ? *(it + m_perm[pidx]) : *(it + pidx);
-
-                    // Check it.
-                    if (rakau_unlikely(!std::isfinite(aabb_size) || aabb_size < F(0))) {
-                        throw std::invalid_argument("An invalid AABB size was detected while computing the collision "
-                                                    "graph: the AABB size must be finite and non-negative, but it is "
-                                                    + std::to_string(aabb_size) + " instead");
-                    }
+                        // Fetch the number of vertices.
+                        constexpr auto n_vertices = std::tuple_size_v<std::remove_const_t<decltype(aabb_codes)>>;
 
-                    // Particles with a null AABB don't participate in collision
-                    // detection and cannot straddle into other nodes.
-                    if (aabb_size == F(0)) {
-                        continue;
-                    }
+                        // Check if the particle straddles.
+                        // NOTE: the idea here is that the codes for all positions in the current node share
+                        // the same initial llevel*NDim digits, which we can determine from the particle code.
+                        const auto straddles = [llevel, &aabb_codes, pcode = m_codes[pidx]]() {
+                            const auto shift_amount = (cbits - llevel) * NDim;
+                            const auto common_prefix = pcode >> shift_amount;
 
-                    // Fill in the particle position.
-                    for (std::size_t j = 0; j < NDim; ++j) {
-                        p_pos[j] = m_parts[j][pidx];
-                    }
-
-                    // Compute the clamped codes of the AABB vertices.
-                    const auto aabb_codes = detail::tree_coll_get_aabb_codes<UInt>(p_pos, aabb_size, inv_box_size);
-
-                    // Fetch the number of vertices.
-                    constexpr auto n_vertices = std::tuple_size_v<std::remove_const_t<decltype(aabb_codes)>>;
+                            for (std::size_t i = 0; i < n_vertices; ++i) {
+                                if (aabb_codes[i] >> shift_amount != common_prefix) {
+                                    return true;
+                                }
+                            }
 
-                    // Check if the particle straddles.
-                    // NOTE: the idea here is that the codes for all positions in the current node share
-                    // the same initial llevel*NDim digits, which we can determine from the particle code.
-                    const auto straddles = [llevel, &aabb_codes, pcode = m_codes[pidx]]() {
-                        const auto shift_amount = (cbits - llevel) * NDim;
-                        const auto common_prefix = pcode >> shift_amount;
+                            return false;
+                        }();
 
-                        for (std::size_t i = 0; i < n_vertices; ++i) {
-                            if (aabb_codes[i] >> shift_amount != common_prefix) {
-                                return true;
-                            }
+                        if (!straddles) {
+                            // The particle does not straddle, move on.
+                            continue;
                         }
 
-                        return false;
-                    }();
+                        // The particle straddles. To know into which leaf nodes it straddles,
+                        // the first step is to construct a set of adjacent nodes which are guaranteed
+                        // to contain the AABB of pidx. We can do that by establishing for each AABB
+                        // vertex the smallest node of size greater than aabb_size that contains
+                        // the vertex. The set of equal-sized nodes thus determined will completely
+                        // enclose the AABB of pidx. We will then figure out which leaf nodes
+                        // overlap the enclosing node set.
 
-                    if (!straddles) {
-                        // The particle does not straddle, move on.
-                        continue;
-                    }
+                        // Convert the AABB size to a node level.
+                        const auto aabb_level = detail::tree_coll_size_to_level<UInt, NDim>(aabb_size, m_box_size);
 
-                    // The particle straddles. To know into which leaf nodes it straddles,
-                    // the first step is to construct a set of adjacent nodes which are guaranteed
-                    // to contain the AABB of pidx. We can do that by establishing for each AABB
-                    // vertex the smallest node of size greater than aabb_size that contains
-                    // the vertex. The set of equal-sized nodes thus determined will completely
-                    // enclose the AABB of pidx. We will then figure out which leaf nodes
-                    // overlap the enclosing node set.
-
-                    // Convert the AABB size to a node level.
-                    const auto aabb_level = detail::tree_coll_size_to_level<UInt, NDim>(aabb_size, m_box_size);
-
-                    // Iterate over the AABB vertices.
-                    for (std::size_t i = 0; i < n_vertices; ++i) {
-                        // NOTE: within this loop, we will be determining
-                        // a node N at level aabb_level which contains a straddling
-                        // vertex of pidx's AABB. We will then establish a range of leaf nodes
-                        // [l_begin, l_end) that have an overlap with N.
-                        //
-                        // It might be that [l_begin, l_end) turns out to
-                        // be an empty range because the particle straddles into
-                        // an 'empty' area which is not associated to any leaf node (because
-                        // it does not contain the centre of any particle). In such a situation,
-                        // we will end up *not* detecting AABB collisions occurring
-                        // in the empty area. In order to avoid this, if [l_begin, l_end)
-                        // is an empty range we will lower the aabb_level (that is, move
-                        // to the parent node) and repeat the search, until it yields
-                        // a non-empty [l_begin, l_end) range. That is, we are "zooming
-                        // out" until the empty area becomes part of some node N_bigger, which
-                        // is guaranteed to eventually happen, and we will add pidx to
-                        // all leaf nodes overlapping N_bigger.
-
-                        // Init the range iterators.
-                        decltype(c_begin) l_begin, l_end;
-
-                        // In the loop below we may end up determining a node
-                        // which fits wholly in the original leaf node. In such a case,
-                        // we will want to skip the rest of the loop and move to the
-                        // next vertex, because there's no need to add pidx as an
-                        // additional particle to its original node.
-                        bool fits = false;
-
-                        for (auto al_copy(aabb_level);; --al_copy) {
-                            // Compute the code of the node at level al_copy
-                            // that encloses the vertex.
-                            const auto s_code
-                                = (aabb_codes[i] >> ((cbits - al_copy) * NDim)) + (UInt(1) << (al_copy * NDim));
-
-                            if (al_copy >= llevel && s_code >> ((al_copy - llevel) * NDim) == lcode) {
-                                // The s_code node fits within the current leaf node,
-                                // no need for further checks (i.e., s_code does not overlap
-                                // with any leaf node other than the original one).
-                                fits = true;
-                                break;
+                        // Iterate over the AABB vertices.
+                        for (std::size_t i = 0; i < n_vertices; ++i) {
+                            // NOTE: within this loop, we will be determining
+                            // a node N at level aabb_level which contains a straddling
+                            // vertex of pidx's AABB. We will then establish a range of leaf nodes
+                            // [l_begin, l_end) that have an overlap with N.
+                            //
+                            // It might be that [l_begin, l_end) turns out to
+                            // be an empty range because the particle straddles into
+                            // an 'empty' area which is not associated to any leaf node (because
+                            // it does not contain the centre of any particle). In such a situation,
+                            // we will end up *not* detecting AABB collisions occurring
+                            // in the empty area. In order to avoid this, if [l_begin, l_end)
+                            // is an empty range we will lower the aabb_level (that is, move
+                            // to the parent node) and repeat the search, until it yields
+                            // a non-empty [l_begin, l_end) range. That is, we are "zooming
+                            // out" until the empty area becomes part of some node N_bigger, which
+                            // is guaranteed to eventually happen, and we will add pidx to
+                            // all leaf nodes overlapping N_bigger.
+
+                            // Init the range iterators.
+                            decltype(c_begin) l_begin, l_end;
+
+                            // In the loop below we may end up determining a node
+                            // which fits wholly in the original leaf node. In such a case,
+                            // we will want to skip the rest of the loop and move to the
+                            // next vertex, because there's no need to add pidx as an
+                            // additional particle to its original node.
+                            bool fits = false;
+
+                            for (auto al_copy(aabb_level);; --al_copy) {
+                                // Compute the code of the node at level al_copy
+                                // that encloses the vertex.
+                                const auto s_code
+                                    = (aabb_codes[i] >> ((cbits - al_copy) * NDim)) + (UInt(1) << (al_copy * NDim));
+
+                                if (al_copy >= llevel && s_code >> ((al_copy - llevel) * NDim) == lcode) {
+                                    // The s_code node fits within the current leaf node,
+                                    // no need for further checks (i.e., s_code does not overlap
+                                    // with any leaf node other than the original one).
+                                    fits = true;
+                                    break;
+                                }
+
+                                // Determine the code range encompassed by s_code.
+                                const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, al_copy);
+
+                                // In the set of leaf nodes, determine either the last node whose
+                                // code range precedes s_code_range, or the first one whose code
+                                // range has some overlap with s_code range.
+                                l_begin
+                                    = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
+                                          const auto n_max = detail::tree_coll_node_range<NDim>(n.code, n.level).second;
+                                          return n_max < p.first;
+                                      });
+
+                                // Now determine the first node whose code range follows s_code_range.
+                                // NOTE: in upper_bound(), the comparator parameter types are flipped around
+                                // wrt lower_bound().
+                                // NOTE: start the search from l_begin, determined above, as we know
+                                // that l_end must be l_begin or an iterator following it.
+                                l_end
+                                    = std::upper_bound(l_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
+                                          const auto n_min = detail::tree_coll_node_range<NDim>(n.code, n.level).first;
+                                          return p.second < n_min;
+                                      });
+
+                                if (l_begin != l_end) {
+                                    // A non-empty leaf node range was found, break out
+                                    // and add pidx to all the leaf nodes in the range.
+                                    break;
+                                }
+
+                                // An empty leaf node range was found. Enlarge the search.
+                                // NOTE: the current al_copy level cannot be zero, because in that case we
+                                // would be at the root node and we would've found something already.
+                                assert(al_copy > 0u);
                             }
 
-                            // Determine the code range encompassed by s_code.
-                            const auto s_code_range = detail::tree_coll_node_range<NDim>(s_code, al_copy);
-
-                            // In the set of leaf nodes, determine either the last node whose
-                            // code range precedes s_code_range, or the first one whose code
-                            // range has some overlap with s_code range.
-                            l_begin = std::lower_bound(c_begin, c_end, s_code_range, [](const auto &n, const auto &p) {
-                                const auto n_max = detail::tree_coll_node_range<NDim>(n.code, n.level).second;
-                                return n_max < p.first;
-                            });
-
-                            // Now determine the first node whose code range follows s_code_range.
-                            // NOTE: in upper_bound(), the comparator parameter types are flipped around
-                            // wrt lower_bound().
-                            // NOTE: start the search from l_begin, determined above, as we know
-                            // that l_end must be l_begin or an iterator following it.
-                            l_end = std::upper_bound(l_begin, c_end, s_code_range, [](const auto &p, const auto &n) {
-                                const auto n_min = detail::tree_coll_node_range<NDim>(n.code, n.level).first;
-                                return p.second < n_min;
-                            });
-
-                            if (l_begin != l_end) {
-                                // A non-empty leaf node range was found, break out
-                                // and add pidx to all the leaf nodes in the range.
-                                break;
+                            if (fits) {
+                                // The vertex-enclosing node fits wholly in the original leaf node.
+                                // Move to the next vertex.
+                                continue;
                             }
 
-                            // An empty leaf node range was found. Enlarge the search.
-                            // NOTE: the current al_copy level cannot be zero, because in that case we
-                            // would be at the root node and we would've found something already.
-                            assert(al_copy > 0u);
-                        }
-
-                        if (fits) {
-                            // The vertex-enclosing node fits wholly in the original leaf node.
-                            // Move to the next vertex.
-                            continue;
-                        }
-
-                        // Iterate over the leaf node range, and add pidx as extra particle
-                        // to each leaf node.
-                        for (; l_begin != l_end; ++l_begin) {
-                            // NOTE: don't add pidx as an extra particle
-                            // to its original node.
-                            if (l_begin->code != lcode) {
-                                // NOTE: we checked earlier that c_begin's
-                                // diff type can represent m_tree.size() and,
-                                // by extension, v_add.size().
-                                v_add[static_cast<decltype(v_add.size())>(l_begin - c_begin)].push_back(pidx);
+                            // Iterate over the leaf node range, and add pidx as extra particle
+                            // to each leaf node.
+                            for (; l_begin != l_end; ++l_begin) {
+                                // NOTE: don't add pidx as an extra particle
+                                // to its original node.
+                                if (l_begin->code != lcode) {
+                                    // NOTE: we checked earlier that c_begin's
+                                    // diff type can represent m_tree.size() and,
+                                    // by extension, v_add.size().
+                                    v_add[static_cast<decltype(v_add.size())>(l_begin - c_begin)].push_back(pidx);
+                                }
                             }
                         }
                     }
                 }
-            }
+            });
         });
-    });
-
-    tg.wait();
 
 #if !defined(NDEBUG)
     // Verify v_add.
@@ -468,9 +467,9 @@ inline void tree<NDim, F, UInt, MAC>::compute_cgraph_impl(std::vector<tbb::concu
 
     // Build the collision graph.
     tbb::parallel_for(tbb::blocked_range(c_begin, c_end), [this, &v_add, &cgraph, c_begin, it](const auto &r) {
-        // A thread local vector to store all the particle indices
+        // A local vector to store all the particle indices
         // of a node, including the extra particles.
-        static thread_local std::vector<size_type> node_indices;
+        std::vector<size_type> node_indices;
 
         // Vectors to hold the min/max aabb coordinates
         // for a particle.

From 528c68168b7ebb007ac64a272be0fad908d58b1e Mon Sep 17 00:00:00 2001
From: Francesco Biscani <bluescarni@gmail.com>
Date: Fri, 3 Apr 2020 12:18:08 +0200
Subject: [PATCH 38/38] Squashed 'cmake/yacma/' changes from b2f0ede..9b55530

9b55530 More YACMA bits.
8d4e291 yacma fix for recent CMake versions.
4942670 Merge commit '9dd6fbba6dc9283ac77899901e6c026d0b016e23' into pr/dates
a0fa858 Update copyright dates for 2020.
19ed5f9 Update yacma copyright date.
14b830d Tentative yacma fix.
ee88350 Include Python dirs as SYSTEM.
eac192c Merge pull request #1 from bluescarni/pr/py_fixes
d841133 Another simplification.
ba89892 Tentative Python libs linking fix.
ba6dd38 Avoid setting the Python module compilation flags for clang-cl.
4fc0633 Remove the hcc bits from yacma.
e50bcb9 Last minute tweaks.
89acd28 Remove the explicit setting of the '_MT' definition on MSVC, as this seems unnecessary.
89647b7 Merge commit 'b33ce5313e6b723090d3f057d7b2ff6f975f18b6'
bf087bc Another small yacma simplification.
b1f6b74 Merge commit '168443070fe46d395235eb0fe30ddb5214aadb83' into pr/circleci
d7e9df3 Some yacma simplifications.
a55db40 Merge commit 'e781b7c72abab2a4adc59eb6fde9f1f3d53a3b39' into pr/circleci
3936275 Second batch of copyright updates.
0311a6d Slight yacma tweak.
ceff571 Merge commit '5351f3f3128b4ac75eccfc4bad58d46a829209f9' into pr/real_iter
8707bb1 Internal docs and changelog update.
b11af0d Again. [skip appveyor]
4a3f2cb Derp. [skip appveyor]
cffc8aa Try the "-undefined dynamic_lookup" flag for Clang OSX.
e130517 Try to avoid linking to the Python library on OSX when building pygmo.
23ec264 Merge commit 'b5f0f92b47cc884ed18e53e7608cdbcfc3223710' [skip ci]
ac8cec0 A few new compiler flags in yacma.
5b34743 Merge commit '023ca6868644202d38fa70d89a570bb4eb53afbd' into pr/iter
51b588e Merge commit '0caaf93af2bb470b63a6c1e7140f01ec5770375d' into pr/yacma_update
bf63d41 Merge commit 'ab914a3611dc60b3d0e3e441e65095c197468380' into pr/integer_iterate
0916451 Merge commit 'f4147ad3acb77c56dd2cf78a1b87790c041ba896' into pr/s11n
1686d01 YACMA copyright date update.
167b40c Merge commit '246f92d131f58efef03b6591814bee25e0fb2b85' into pr/pybind11_utils
c159972 Fix yacma debug flag.
ff24b2a Merge branch 'master' into pr/mp_real
c6ea431 A yacma update to enable more warnings.

git-subtree-dir: cmake/yacma
git-subtree-split: 9b5553088aba21f8deab536aae3551f09cce4e49
---
 LICENSE                           |  2 +-
 YACMACompilerLinkerSettings.cmake | 56 ++++++++++++++++++-------------
 YACMAPythonSetup.cmake            | 48 +++++++++++++-------------
 YACMAThreadingSetup.cmake         |  5 ---
 4 files changed, 59 insertions(+), 52 deletions(-)

diff --git a/LICENSE b/LICENSE
index 3203c9a..edd52cf 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2018 Francesco Biscani
+Copyright (c) 2016-2020 Francesco Biscani
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/YACMACompilerLinkerSettings.cmake b/YACMACompilerLinkerSettings.cmake
index 97659bf..7d7aa1b 100644
--- a/YACMACompilerLinkerSettings.cmake
+++ b/YACMACompilerLinkerSettings.cmake
@@ -27,15 +27,11 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     set(YACMA_COMPILER_IS_GNUCXX TRUE)
 endif()
 
-# Detect the hcc compiler.
-if(YACMA_COMPILER_IS_CLANGXX AND "${CMAKE_CXX_COMPILER}" MATCHES "hcc")
-    set(YACMA_COMPILER_IS_HCC TRUE)
-endif()
-
 # This is an OS X specific setting that is suggested to be enabled. See:
 # https://blog.kitware.com/upcoming-in-cmake-2-8-12-osx-rpath-support/
 # http://stackoverflow.com/questions/31561309/cmake-warnings-under-os-x-macosx-rpath-is-not-specified-for-the-following-targe
-if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+if(APPLE)
+    message(STATUS "OSX detected, setting the 'CMAKE_MACOSX_RPATH' option to TRUE.")
     set(CMAKE_MACOSX_RPATH TRUE)
 endif()
 
@@ -48,36 +44,32 @@ endfunction()
 
 # Enable conditionally a CXX flag, if supported by the compiler.
 # This is for flags intended to be enabled in all configurations.
-# NOTE: we use macros and go through temporary private variables
-# because it's apparently impossible to append to an internal
+# NOTE: we use macros because it's apparently impossible to append to an internal
 # CACHEd list.
 macro(_YACMA_CHECK_ENABLE_CXX_FLAG flag)
     set(CMAKE_REQUIRED_QUIET TRUE)
-    check_cxx_compiler_flag("${flag}" YACMA_CHECK_CXX_FLAG)
+    check_cxx_compiler_flag("${flag}" YACMA_CHECK_CXX_FLAG::${flag})
     unset(CMAKE_REQUIRED_QUIET)
-    if(YACMA_CHECK_CXX_FLAG)
+    if(YACMA_CHECK_CXX_FLAG::${flag})
         message(STATUS "'${flag}': flag is supported by the compiler, enabling.")
         list(APPEND _YACMA_CXX_FLAGS "${flag}")
     else()
         message(STATUS "'${flag}': flag is not supported by the compiler.")
     endif()
-    # NOTE: check_cxx_compiler stores variables in the cache.
-    unset(YACMA_CHECK_CXX_FLAG CACHE)
 endmacro()
 
 # Enable conditionally a debug CXX flag, is supported by the compiler.
 # This is for flags intended to be enabled in debug mode.
 macro(_YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG flag)
     set(CMAKE_REQUIRED_QUIET TRUE)
-    check_cxx_compiler_flag("${flag}" YACMA_CHECK_DEBUG_CXX_FLAG)
+    check_cxx_compiler_flag("${flag}" YACMA_CHECK_DEBUG_CXX_FLAG::${flag})
     unset(CMAKE_REQUIRED_QUIET)
-    if(YACMA_CHECK_DEBUG_CXX_FLAG)
+    if(YACMA_CHECK_DEBUG_CXX_FLAG::${flag})
         message(STATUS "'${flag}': debug flag is supported by the compiler, enabling.")
         list(APPEND _YACMA_CXX_FLAGS_DEBUG "${flag}")
     else()
         message(STATUS "'${flag}': debug flag is not supported by the compiler.")
     endif()
-    unset(YACMA_CHECK_DEBUG_CXX_FLAG CACHE)
 endmacro()
 
 # What we want to avoid is to re-run the expensive flag checks. We will set cache variables
@@ -90,6 +82,8 @@ if(NOT _YACMACompilerLinkerSettingsRun)
     # Configuration bits specific for GCC.
     if(YACMA_COMPILER_IS_GNUCXX)
         _YACMA_CHECK_ENABLE_CXX_FLAG(-fdiagnostics-color=auto)
+        # New in GCC 9.
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Waddress-of-packed-member)
     endif()
 
     # Configuration bits specific for clang.
@@ -98,7 +92,26 @@ if(NOT _YACMACompilerLinkerSettingsRun)
         # for the time being.
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wshadow)
         # Clang is better at this flag than GCC.
-        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Werror)
+        # NOTE: enable unconditionally, as it seems like the CMake
+        # machinery for detecting this fails. Perhaps the source code
+        # used for checking the flag emits warnings?
+        list(APPEND _YACMA_CXX_FLAGS_DEBUG "-Werror")
+        # New warnings in clang 8.
+        # NOTE: a few issues with macros here, let's disable for now.
+        # _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wextra-semi-stmt)
+        # New warnings in clang 10.
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wtautological-overlap-compare)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wtautological-compare)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wtautological-bitwise-compare)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wbitwise-conditional-parentheses)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wrange-loop-analysis)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wmisleading-indentation)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wc99-designator)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wreorder-init-list)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wsizeof-pointer-div)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wsizeof-array-div)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wxor-used-as-pow)
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wfinal-dtor-non-final-class)
     endif()
 
     # Common configuration for GCC, clang and Intel.
@@ -106,7 +119,8 @@ if(NOT _YACMACompilerLinkerSettingsRun)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wall)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wextra)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wnon-virtual-dtor)
-        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wnoexcept)
+        # NOTE: this flag is a bit too chatty, let's disable it for the moment.
+        #_YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wnoexcept)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wlogical-op)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wconversion)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wdeprecated)
@@ -120,11 +134,7 @@ if(NOT _YACMACompilerLinkerSettingsRun)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wdisabled-optimization)
         # This is useful when the compiler decides the template backtrace is too verbose.
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-ftemplate-backtrace-limit=0)
-        if(YACMA_COMPILER_IS_HCC)
-            message(STATUS "hcc compiler detected, the '-fstack-protector-all' flag will not be enabled.")
-        else()
-            _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-fstack-protector-all)
-        endif()
+        _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-fstack-protector-all)
         # A few suggestion flags.
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wsuggest-attribute=pure)
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(-Wsuggest-attribute=const)
@@ -166,7 +176,7 @@ if(NOT _YACMACompilerLinkerSettingsRun)
     endif()
 
     # MSVC setup.
-    if(YACMA_COMPILER_IS_MSVC)
+    if(YACMA_COMPILER_IS_MSVC AND NOT YACMA_COMPILER_IS_CLANGXX)
         # Enable higher warning level than usual.
         _YACMA_CHECK_ENABLE_DEBUG_CXX_FLAG(/W4)
         # Treat warnings as errors.
diff --git a/YACMAPythonSetup.cmake b/YACMAPythonSetup.cmake
index 126fd1f..2d31ceb 100644
--- a/YACMAPythonSetup.cmake
+++ b/YACMAPythonSetup.cmake
@@ -3,14 +3,8 @@ if(YACMAPythonSetupIncluded)
 endif()
 
 # NOTE: this is a heuristic to determine whether we need to link to the Python library.
-# In theory, Python extensions don't need to, as they are dlopened() by the Python process
-# and thus they don't need to be linked to the Python library at compile time. However,
-# the dependency on Boost.Python muddies the waters, as BP itself does link to the Python
-# library, at least on some platforms. The following configuration seems to be working fine
-# on various CI setups.
-# NOTE: apparently homebrew requires NOT to link to the Python library. We might want
-# to add a config option to accommodate that eventually.
-if(WIN32 OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+# The linking seems to be necessary only on Windows.
+if(WIN32)
   message(STATUS "Python modules require linking to the Python library.")
   set(_YACMA_PYTHON_MODULE_NEED_LINK TRUE)
 else()
@@ -42,6 +36,11 @@ else()
 endif()
 mark_as_advanced(YACMA_PYTHON_INCLUDE_DIR)
 
+# Add an interface imported target for the
+# Python include dir.
+add_library(YACMA::PythonIncludeDir INTERFACE IMPORTED)
+set_target_properties(YACMA::PythonIncludeDir PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${YACMA_PYTHON_INCLUDE_DIR})
+
 message(STATUS "Python interpreter: ${PYTHON_EXECUTABLE}")
 message(STATUS "Python interpreter version: ${PYTHON_VERSION_STRING}")
 if(_YACMA_PYTHON_MODULE_NEED_LINK)
@@ -49,16 +48,6 @@ if(_YACMA_PYTHON_MODULE_NEED_LINK)
 endif()
 message(STATUS "Python include dir: ${YACMA_PYTHON_INCLUDE_DIR}")
 
-# An imported target to be used when building extension modules.
-if(_YACMA_PYTHON_MODULE_NEED_LINK)
-  add_library(YACMA::PythonModule UNKNOWN IMPORTED)
-  set_target_properties(YACMA::PythonModule PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${YACMA_PYTHON_INCLUDE_DIR}"
-    IMPORTED_LOCATION "${PYTHON_LIBRARIES}" IMPORTED_LINK_INTERFACE_LANGUAGES "C")
-else()
-  add_library(YACMA::PythonModule INTERFACE IMPORTED)
-  set_target_properties(YACMA::PythonModule PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${YACMA_PYTHON_INCLUDE_DIR}")
-endif()
-
 # This flag is used to signal the need to override the default extension of the Python modules
 # depending on the architecture. Under Windows, for instance, CMake produces shared objects as
 # .dll files, but Python from 2.5 onwards requires .pyd files (hence the need to override).
@@ -66,7 +55,7 @@ set(_YACMA_PY_MODULE_EXTENSION "")
 
 # Platform-specific setup.
 if(UNIX)
-  if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  if(APPLE)
     message(STATUS "OS X platform detected.")
     # Apparently on OS X Python expects the .so extension for compiled modules.
 	  message(STATUS "Output extension for compiled modules will be '.so'.")
@@ -125,11 +114,9 @@ function(YACMA_PYTHON_MODULE name)
     # with clang and gcc. See:
     # https://bugs.python.org/issue11149
     # http://www.python.org/dev/peps/pep-3123/
-    # NOTE: not sure here how we should set flags up for MSVC or clang on windows, need
-    # to check in the future.
     # NOTE: do not use the yacma compiler linker settings bits, so this module
     # can be used stand-alone.
-    if(CMAKE_COMPILER_IS_GNUCXX OR ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
+    if(CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND NOT MSVC))
         message(STATUS "Setting up extra compiler flag '-fwrapv' for the Python module '${name}'.")
         target_compile_options(${name} PRIVATE "-fwrapv")
         if(${PYTHON_VERSION_MAJOR} LESS 3)
@@ -137,7 +124,22 @@ function(YACMA_PYTHON_MODULE name)
             target_compile_options(${name} PRIVATE "-fno-strict-aliasing")
         endif()
     endif()
-    target_link_libraries("${name}" PRIVATE YACMA::PythonModule)
+    if(APPLE AND ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
+      # On OSX + Clang this link flag is apparently necessary in order to avoid
+      # undefined references to symbols defined in the Python library. See also:
+      # https://github.com/potassco/clingo/issues/79
+      # https://stackoverflow.com/questions/25421479/clang-and-undefined-symbols-when-building-a-library
+      # https://cmake.org/pipermail/cmake/2017-March/065115.html
+      set_target_properties(${name} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
+    endif()
+
+    # Add the Python include dirs.
+    target_include_directories("${name}" SYSTEM PRIVATE ${YACMA_PYTHON_INCLUDE_DIR})
+
+    # Link to the Python libs, if necessary.
+    if(_YACMA_PYTHON_MODULE_NEED_LINK)
+      target_link_libraries("${name}" PRIVATE ${PYTHON_LIBRARIES})
+    endif()
 endfunction()
 
 # Mark as included.
diff --git a/YACMAThreadingSetup.cmake b/YACMAThreadingSetup.cmake
index c9e24f9..011e512 100644
--- a/YACMAThreadingSetup.cmake
+++ b/YACMAThreadingSetup.cmake
@@ -40,11 +40,6 @@ if(MINGW)
 	list(APPEND YACMA_THREADING_CXX_FLAGS "-mthreads")
 endif()
 
-if(YACMA_COMPILER_IS_MSVC)
-	message(STATUS "Enabling the '_MT' definition for MSVC.")
-	list(APPEND YACMA_THREADING_CXX_FLAGS "/D_MT")
-endif()
-
 # Check if we have thread_local.
 # NOTE: we need to double check what happens with OSX's clang here.
 list(FIND CMAKE_CXX_COMPILE_FEATURES "cxx_thread_local" YACMA_HAVE_THREAD_LOCAL)