diff --git a/src/mlpack/tests/CMakeLists.txt b/src/mlpack/tests/CMakeLists.txt
index b411343411..54fee13a21 100644
--- a/src/mlpack/tests/CMakeLists.txt
+++ b/src/mlpack/tests/CMakeLists.txt
@@ -42,7 +42,6 @@ add_executable(mlpack_test
   qdafn_test.cpp
   radical_test.cpp
   random_test.cpp
-  range_search_test.cpp
   rectangle_tree_test.cpp
   reward_clipping_test.cpp
   rl_components_test.cpp
@@ -85,7 +84,6 @@ add_executable(mlpack_test
   main_tests/nmf_test.cpp
   main_tests/perceptron_test.cpp
   main_tests/radical_test.cpp
-  main_tests/range_search_test.cpp
   main_tests/test_helper.hpp
 )
 
@@ -139,6 +137,7 @@ add_executable(mlpack_catch_test
   quic_svd_test.cpp
   random_forest_test.cpp
   randomized_svd_test.cpp
+  range_search_test.cpp
   rbm_network_test.cpp
   recurrent_network_test.cpp
   regularized_svd_test.cpp
@@ -179,6 +178,7 @@ add_executable(mlpack_catch_test
   main_tests/random_forest_test.cpp
   main_tests/softmax_regression_test.cpp
   main_tests/sparse_coding_test.cpp
+  main_tests/range_search_test.cpp
   main_tests/test_helper.hpp
 )
 
diff --git a/src/mlpack/tests/main_tests/range_search_test.cpp b/src/mlpack/tests/main_tests/range_search_test.cpp
index 8102aae4e9..3d9fd08bb5 100644
--- a/src/mlpack/tests/main_tests/range_search_test.cpp
+++ b/src/mlpack/tests/main_tests/range_search_test.cpp
@@ -17,7 +17,7 @@ static const std::string testName = "RangeSearchMain";
 #include "test_helper.hpp"
 #include <mlpack/methods/range_search/range_search_main.cpp>
 #include "range_search_utils.hpp"
-#include <boost/test/unit_test.hpp>
+#include "../catch.hpp"
 
 using namespace mlpack;
 
@@ -37,34 +37,35 @@ struct RangeSearchTestFixture
   }
 };
 
-BOOST_FIXTURE_TEST_SUITE(RangeSearchMainTest, RangeSearchTestFixture);
-
 /**
  * Check that we have to specify a reference set or input model.
  */
-BOOST_AUTO_TEST_CASE(RangeSearchNoReference)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSearchNoReference",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   Log::Fatal.ignoreInput = true;
-  BOOST_REQUIRE_THROW(mlpackMain(), std::runtime_error);
+  REQUIRE_THROWS_AS(mlpackMain(), std::runtime_error);
   Log::Fatal.ignoreInput = false;
 }
 
 /**
  * Check that we cannot pass an incorrect parameter.
  */
-BOOST_AUTO_TEST_CASE(RangeSearchWrongParameter)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSearchWrongParameter",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   string wrongString = "abc";
 
   Log::Fatal.ignoreInput = true;
-  BOOST_REQUIRE_THROW(SetInputParam("RST", wrongString), std::runtime_error);
+  REQUIRE_THROWS_AS(SetInputParam("RST", wrongString), std::runtime_error);
   Log::Fatal.ignoreInput = false;
 }
 
 /**
  * Check that we have to specify a query if an input model is specified.
  */
-BOOST_AUTO_TEST_CASE(RangeSearchInputModelNoQuery)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSearchInputModelNoQuery",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat inputData;
   double minVal = 0, maxVal = 3;
@@ -72,7 +73,7 @@ BOOST_AUTO_TEST_CASE(RangeSearchInputModelNoQuery)
   string neighborsFile = "neighbors.csv";
 
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
 
   SetInputParam("reference", move(inputData));
   SetInputParam("min", minVal);
@@ -86,7 +87,7 @@ BOOST_AUTO_TEST_CASE(RangeSearchInputModelNoQuery)
   SetInputParam("input_model", move(IO::GetParam<RSModel*>("output_model")));
 
   Log::Fatal.ignoreInput = true;
-  BOOST_REQUIRE_THROW(mlpackMain(), std::runtime_error);
+  REQUIRE_THROWS_AS(mlpackMain(), std::runtime_error);
   Log::Fatal.ignoreInput = false;
 
   remove(neighborsFile.c_str());
@@ -96,7 +97,8 @@ BOOST_AUTO_TEST_CASE(RangeSearchInputModelNoQuery)
 /**
  * Check that we cannot specify a tree type which is not available or wrong.
  */
-BOOST_AUTO_TEST_CASE(RangeSearchDifferentTree)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSearchDifferentTree",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat inputData;
   double minVal = 0, maxVal = 3;
@@ -104,7 +106,7 @@ BOOST_AUTO_TEST_CASE(RangeSearchDifferentTree)
   string neighborsFile = "neighbors.csv";
   string wrongTreeType = "RST";
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
 
   SetInputParam("reference", move(inputData));
   SetInputParam("min", minVal);
@@ -114,7 +116,7 @@ BOOST_AUTO_TEST_CASE(RangeSearchDifferentTree)
   SetInputParam("tree_type", wrongTreeType);
 
   Log::Fatal.ignoreInput = true;
-  BOOST_REQUIRE_THROW(mlpackMain(), std::runtime_error);
+  REQUIRE_THROWS_AS(mlpackMain(), std::runtime_error);
   Log::Fatal.ignoreInput = false;
 
   remove(neighborsFile.c_str());
@@ -124,7 +126,8 @@ BOOST_AUTO_TEST_CASE(RangeSearchDifferentTree)
 /**
  * Check that we cannot specify both a reference set and input model.
  */
-BOOST_AUTO_TEST_CASE(RangeSearchBothReferenceAndModel)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSearchBothReferenceAndModel",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat inputData, queryData;
   double minVal = 0, maxVal = 3;
@@ -132,9 +135,9 @@ BOOST_AUTO_TEST_CASE(RangeSearchBothReferenceAndModel)
   string neighborsFile = "neighbors.csv";
 
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
   if (!data::Load("iris_test.csv", queryData))
-    BOOST_FAIL("Unable to load dataset iris_test.csv!");
+    FAIL("Unable to load dataset iris_test.csv!");
 
   SetInputParam("reference", move(inputData));
   SetInputParam("min", minVal);
@@ -149,7 +152,7 @@ BOOST_AUTO_TEST_CASE(RangeSearchBothReferenceAndModel)
   SetInputParam("query", move(queryData));
 
   Log::Fatal.ignoreInput = true;
-  BOOST_REQUIRE_THROW(mlpackMain(), std::runtime_error);
+  REQUIRE_THROWS_AS(mlpackMain(), std::runtime_error);
   Log::Fatal.ignoreInput = false;
 
   remove(neighborsFile.c_str());
@@ -161,7 +164,8 @@ BOOST_AUTO_TEST_CASE(RangeSearchBothReferenceAndModel)
  * by comparing with pre-calculated neighbor and distance values, when no query
  * set is specified.
  */
-BOOST_AUTO_TEST_CASE(RangeSearchTest)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSearchTest",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat x = {{0, 3, 3, 4, 3, 1},
                  {4, 4, 4, 5, 5, 2},
@@ -208,7 +212,8 @@ BOOST_AUTO_TEST_CASE(RangeSearchTest)
  * Check that the correct output is returned for a small synthetic input case,
  * when a query set is provided.
  */
-BOOST_AUTO_TEST_CASE(RangeSeachTestwithQuery)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RangeSeachTestwithQuery",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat queryData = {{5, 3, 1}, {4, 2, 4}, {3, 1, 7}};
   arma::mat x = {{0, 3, 3, 4, 3, 1},
@@ -252,7 +257,8 @@ BOOST_AUTO_TEST_CASE(RangeSeachTestwithQuery)
  * Train a model using a synthetic dataset and then output the model, and ensure
  * it can be used again.
  */
-BOOST_AUTO_TEST_CASE(ModelCheck)
+TEST_CASE_METHOD(RangeSearchTestFixture, "ModelCheck",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat inputData, queryData;
   double minVal = 0, maxVal = 3;
@@ -262,9 +268,9 @@ BOOST_AUTO_TEST_CASE(ModelCheck)
   vector<vector<double>> distances, distancetemp;
 
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
   if (!data::Load("iris_test.csv", queryData))
-    BOOST_FAIL("Unable to load dataset iris_test.csv!");
+    FAIL("Unable to load dataset iris_test.csv!");
 
   SetInputParam("reference", move(inputData));
   SetInputParam("min", minVal);
@@ -292,8 +298,8 @@ BOOST_AUTO_TEST_CASE(ModelCheck)
   CheckMatrices(neighbors, neighborsTemp);
   CheckMatrices(distances, distancetemp);
 
-  BOOST_REQUIRE_EQUAL(ModelToString(outputModel),
-                      ModelToString(IO::GetParam<RSModel*>("output_model")));
+  REQUIRE(ModelToString(outputModel) ==
+          ModelToString(IO::GetParam<RSModel*>("output_model")));
 
   remove(neighborsFile.c_str());
   remove(distanceFile.c_str());
@@ -303,11 +309,12 @@ BOOST_AUTO_TEST_CASE(ModelCheck)
  * Check that the models are different but the results are the same for three
  * different leaf size parameters.
  */
-BOOST_AUTO_TEST_CASE(LeafValueTesting)
+TEST_CASE_METHOD(RangeSearchTestFixture, "LeafValueTesting",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   arma::mat inputData;
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
 
   string distanceFile = "distances.csv";
   string neighborsFile = "neighbors.csv";
@@ -349,8 +356,8 @@ BOOST_AUTO_TEST_CASE(LeafValueTesting)
     CheckMatrices(neighbors, neighborsTemp);
     CheckMatrices(distances, distancestemp);
 
-    BOOST_REQUIRE_NE(ModelToString(outputModel1),
-                     ModelToString(IO::GetParam<RSModel*>("output_model")));
+    REQUIRE(ModelToString(outputModel1) !=
+            ModelToString(IO::GetParam<RSModel*>("output_model")));
 
     if (i != leafSizes.size() - 1)
       delete IO::GetParam<RSModel*>("output_model");
@@ -367,7 +374,8 @@ BOOST_AUTO_TEST_CASE(LeafValueTesting)
  * different tree types.  We use the default kd-tree as the base model to
  * compare against.
  */
-BOOST_AUTO_TEST_CASE(TreeTypeTesting)
+TEST_CASE_METHOD(RangeSearchTestFixture, "TreeTypeTesting",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   string distanceFile = "distances.csv";
   string neighborsFile = "neighbors.csv";
@@ -381,9 +389,9 @@ BOOST_AUTO_TEST_CASE(TreeTypeTesting)
                           "max-rp", "ub", "oct"};
 
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
   if (!data::Load("iris_test.csv", queryData))
-    BOOST_FAIL("Unable to load dataset iris_test.csv!");
+    FAIL("Unable to load dataset iris_test.csv!");
 
   // Define base parameters with the kd-tree.
   SetInputParam("tree_type", trees[0]);
@@ -403,9 +411,9 @@ BOOST_AUTO_TEST_CASE(TreeTypeTesting)
   for (size_t i = 1; i < trees.size(); ++i)
   {
     if (!data::Load("iris.csv", inputData))
-      BOOST_FAIL("Unable to load dataset iris.csv!");
+      FAIL("Unable to load dataset iris.csv!");
     if (!data::Load("iris_test.csv", queryData))
-      BOOST_FAIL("Unable to load dataset iris_test.csv!");
+      FAIL("Unable to load dataset iris_test.csv!");
 
     SetInputParam("min", minVal);
     SetInputParam("max", maxVal);
@@ -422,8 +430,8 @@ BOOST_AUTO_TEST_CASE(TreeTypeTesting)
 
     CheckMatrices(neighbors, neighborsTemp);
     CheckMatrices(distances, distancestemp);
-    BOOST_REQUIRE_NE(ModelToString(outputModel1),
-                     ModelToString(IO::GetParam<RSModel*>("output_model")));
+    REQUIRE(ModelToString(outputModel1) !=
+            ModelToString(IO::GetParam<RSModel*>("output_model")));
 
     if (i != trees.size() - 1)
       delete IO::GetParam<RSModel*>("output_model");
@@ -439,7 +447,8 @@ BOOST_AUTO_TEST_CASE(TreeTypeTesting)
  * Project the data onto a random basis and ensure that this gives identical
  * results to non-projected data but different models.
  */
-BOOST_AUTO_TEST_CASE(RandomBasisTesting)
+TEST_CASE_METHOD(RangeSearchTestFixture, "RandomBasisTesting",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   string distanceFile = "distances.csv";
   string neighborsFile = "neighbors.csv";
@@ -447,9 +456,9 @@ BOOST_AUTO_TEST_CASE(RandomBasisTesting)
 
   arma::mat queryData, inputData;
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
   if (!data::Load("iris_test.csv", queryData))
-    BOOST_FAIL("Unable to load dataset iris_test.csv!");
+    FAIL("Unable to load dataset iris_test.csv!");
 
   SetInputParam("min", minVal);
   SetInputParam("max", maxVal);
@@ -470,8 +479,8 @@ BOOST_AUTO_TEST_CASE(RandomBasisTesting)
 
   mlpackMain();
 
-  BOOST_REQUIRE_NE(ModelToString(outputModel),
-                   ModelToString(IO::GetParam<RSModel*>("output_model")));
+  REQUIRE(ModelToString(outputModel) !=
+          ModelToString(IO::GetParam<RSModel*>("output_model")));
 
   delete outputModel;
 
@@ -482,7 +491,8 @@ BOOST_AUTO_TEST_CASE(RandomBasisTesting)
 /**
  * Ensure that naive mode gives the same result, but different models.
  */
-BOOST_AUTO_TEST_CASE(NaiveModeTest)
+TEST_CASE_METHOD(RangeSearchTestFixture, "NaiveModeTest",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   string distanceFile = "distances.csv";
   string neighborsFile = "neighbors.csv";
@@ -493,9 +503,9 @@ BOOST_AUTO_TEST_CASE(NaiveModeTest)
   vector<vector<double>> distances, distancestemp;
 
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
   if (!data::Load("iris_test.csv", queryData))
-    BOOST_FAIL("Unable to load dataset iris_test.csv!");
+    FAIL("Unable to load dataset iris_test.csv!");
 
   SetInputParam("min", minVal);
   SetInputParam("max", maxVal);
@@ -524,8 +534,8 @@ BOOST_AUTO_TEST_CASE(NaiveModeTest)
   CheckMatrices(neighbors, neighborsTemp);
   CheckMatrices(distances, distancestemp);
 
-  BOOST_REQUIRE_NE(ModelToString(outputModel),
-                   ModelToString(IO::GetParam<RSModel*>("output_model")));
+  REQUIRE(ModelToString(outputModel) !=
+          ModelToString(IO::GetParam<RSModel*>("output_model")));
 
   delete outputModel;
 
@@ -536,7 +546,8 @@ BOOST_AUTO_TEST_CASE(NaiveModeTest)
 /**
  * Ensure that single-tree mode gives the same result but different models.
  */
-BOOST_AUTO_TEST_CASE(SingleModeTest)
+TEST_CASE_METHOD(RangeSearchTestFixture, "SingleModeTest",
+                 "[RangeSearchMainTest][BindingTests]")
 {
   string distanceFile = "distances.csv";
   string neighborsFile = "neighbors.csv";
@@ -547,9 +558,9 @@ BOOST_AUTO_TEST_CASE(SingleModeTest)
   vector<vector<double>> distances, distancestemp;
 
   if (!data::Load("iris.csv", inputData))
-    BOOST_FAIL("Unable to load dataset iris.csv!");
+    FAIL("Unable to load dataset iris.csv!");
   if (!data::Load("iris_test.csv", queryData))
-    BOOST_FAIL("Unable to load dataset iris_test.csv!");
+    FAIL("Unable to load dataset iris_test.csv!");
 
   SetInputParam("min", minVal);
   SetInputParam("max", maxVal);
@@ -577,13 +588,11 @@ BOOST_AUTO_TEST_CASE(SingleModeTest)
 
   CheckMatrices(neighbors, neighborsTemp);
   CheckMatrices(distances, distancestemp);
-  BOOST_REQUIRE_NE(ModelToString(outputModel),
-                   ModelToString(IO::GetParam<RSModel*>("output_model")));
+  REQUIRE(ModelToString(outputModel) !=
+          ModelToString(IO::GetParam<RSModel*>("output_model")));
 
   delete outputModel;
 
   remove(neighborsFile.c_str());
   remove(distanceFile.c_str());
 }
-
-BOOST_AUTO_TEST_SUITE_END();
diff --git a/src/mlpack/tests/main_tests/range_search_utils.hpp b/src/mlpack/tests/main_tests/range_search_utils.hpp
index 8f1385eafb..f628b741ff 100644
--- a/src/mlpack/tests/main_tests/range_search_utils.hpp
+++ b/src/mlpack/tests/main_tests/range_search_utils.hpp
@@ -12,10 +12,10 @@
 #ifndef MLPACK_TESTS_MAIN_TESTS_RANGE_SEARCH_TEST_UTILS_HPP
 #define MLPACK_TESTS_MAIN_TESTS_RANGE_SEARCH_TEST_UTILS_HPP
 
-#include <boost/test/unit_test.hpp>
 #include <mlpack/methods/range_search/rs_model.hpp>
 #include <mlpack/core.hpp>
 #include <mlpack/core/util/mlpack_main.hpp>
+#include "../catch.hpp"
 
 /**
  * Convert a model to a string using the text_oarchive of boost::serialization.
@@ -42,15 +42,15 @@ inline void CheckMatrices(std::vector<std::vector<double>>& vec1,
                           std::vector<std::vector<double>>& vec2,
                           const double tolerance = 1e-3)
 {
-  BOOST_REQUIRE_EQUAL(vec1.size() , vec2.size());
+  REQUIRE(vec1.size()  == vec2.size());
   for (size_t i = 0; i < vec1.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(vec1[i].size(), vec2[i].size());
+    REQUIRE(vec1[i].size() == vec2[i].size());
     std::sort(vec1[i].begin(), vec1[i].end());
     std::sort(vec2[i].begin(), vec2[i].end());
     for (size_t j = 0 ; j < vec1[i].size(); ++j)
     {
-      BOOST_REQUIRE_CLOSE(vec1[i][j], vec2[i][j], tolerance);
+      REQUIRE(vec1[i][j] == Approx(vec2[i][j]).epsilon(tolerance));
     }
   }
 }
@@ -64,15 +64,15 @@ inline void CheckMatrices(std::vector<std::vector<double>>& vec1,
 inline void CheckMatrices(std::vector<std::vector<size_t>>& vec1,
                           std::vector<std::vector<size_t>>& vec2)
 {
-  BOOST_REQUIRE_EQUAL(vec1.size() , vec2.size());
+  REQUIRE(vec1.size()  == vec2.size());
   for (size_t i = 0; i < vec1.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(vec1[i].size(), vec2[i].size());
+    REQUIRE(vec1[i].size() == vec2[i].size());
     std::sort(vec1[i].begin(), vec1[i].end());
     std::sort(vec2[i].begin(), vec2[i].end());
     for (size_t j = 0; j < vec1[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(vec1[i][j], vec2[i][j]);
+      REQUIRE(vec1[i][j] == vec2[i][j]);
     }
   }
 }
diff --git a/src/mlpack/tests/range_search_test.cpp b/src/mlpack/tests/range_search_test.cpp
index 33dd5c56ca..7bd714beaf 100644
--- a/src/mlpack/tests/range_search_test.cpp
+++ b/src/mlpack/tests/range_search_test.cpp
@@ -13,8 +13,9 @@
 #include <mlpack/methods/range_search/range_search.hpp>
 #include <mlpack/core/tree/cover_tree.hpp>
 #include <mlpack/methods/range_search/rs_model.hpp>
-#include <boost/test/unit_test.hpp>
-#include "test_tools.hpp"
+
+#include "catch.hpp"
+#include "test_catch_tools.hpp"
 
 using namespace mlpack;
 using namespace mlpack::range;
@@ -24,8 +25,6 @@ using namespace mlpack::bound;
 using namespace mlpack::metric;
 using namespace std;
 
-BOOST_AUTO_TEST_SUITE(RangeSearchTest);
-
 // Get our results into a sorted format, so we can actually then test for
 // correctness.
 void SortResults(const vector<vector<size_t>>& neighbors,
@@ -62,7 +61,7 @@ void CleanTree(TreeType& node)
  * dataset is in one dimension for simplicity -- the correct functionality of
  * distance functions is not tested here.
  */
-BOOST_AUTO_TEST_CASE(ExhaustiveSyntheticTest)
+TEST_CASE("ExhaustiveSyntheticTest", "[RangeSearchTest]")
 {
   // Set up our data.
   arma::mat data(1, 11);
@@ -111,109 +110,109 @@ BOOST_AUTO_TEST_CASE(ExhaustiveSyntheticTest)
     vector<vector<pair<double, size_t>>> sortedOutput;
     SortResults(neighbors, distances, sortedOutput);
 
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][0].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][0].first, 0.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][1].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][1].first, 0.27, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][2].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][2].first, 0.30, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][3].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][3].first, 0.40, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[0]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[0]][0].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[0]][0].first == Approx(0.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][1].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[0]][1].first == Approx(0.27).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][2].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[0]][2].first == Approx(0.30).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][3].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[0]][3].first == Approx(0.40).epsilon(1e-7));
 
     // Neighbors of point 1.
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]].size() == 6);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][0].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][0].first, 0.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][1].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][1].first, 0.20, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][2].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][2].first, 0.30, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][3].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][3].first, 0.55, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][4].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][4].first, 0.57, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][5].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][5].first, 0.65, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[1]].size() == 6);
+    REQUIRE(sortedOutput[newFromOld[1]][0].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[1]][0].first == Approx(0.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][1].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[1]][1].first == Approx(0.20).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][2].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[1]][2].first == Approx(0.30).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][3].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[1]][3].first == Approx(0.55).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][4].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[1]][4].first == Approx(0.57).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][5].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[1]][5].first == Approx(0.65).epsilon(1e-7));
 
     // Neighbors of point 2.
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][0].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][0].first, 0.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][1].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][1].first, 0.20, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][2].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][2].first, 0.30, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][3].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][3].first, 0.37, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[2]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[2]][0].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[2]][0].first == Approx(0.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][1].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[2]][1].first == Approx(0.20).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][2].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[2]][2].first == Approx(0.30).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][3].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[2]][3].first == Approx(0.37).epsilon(1e-7));
 
     // Neighbors of point 3.
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]].size() == 2);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][0].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][0].first, 0.25, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][1].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][1].first, 0.35, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[3]].size() == 2);
+    REQUIRE(sortedOutput[newFromOld[3]][0].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[3]][0].first == Approx(0.25).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][1].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[3]][1].first == Approx(0.35).epsilon(1e-7));
 
     // Neighbors of point 4.
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]].size() == 0);
+    REQUIRE(sortedOutput[newFromOld[4]].size() == 0);
 
     // Neighbors of point 5.
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][0].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][0].first, 0.27, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][1].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][1].first, 0.37, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][2].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][2].first, 0.57, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][3].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][3].first, 0.67, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[5]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[5]][0].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[5]][0].first == Approx(0.27).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][1].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[5]][1].first == Approx(0.37).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][2].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[5]][2].first == Approx(0.57).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][3].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[5]][3].first == Approx(0.67).epsilon(1e-7));
 
     // Neighbors of point 6.
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]].size() == 1);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][0].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][0].first, 0.70, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[6]].size() == 1);
+    REQUIRE(sortedOutput[newFromOld[6]][0].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[6]][0].first == Approx(0.70).epsilon(1e-7));
 
     // Neighbors of point 7.
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]].size() == 1);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][0].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][0].first, 0.70, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[7]].size() == 1);
+    REQUIRE(sortedOutput[newFromOld[7]][0].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[7]][0].first == Approx(0.70).epsilon(1e-7));
 
     // Neighbors of point 8.
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]].size() == 6);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][0].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][0].first, 0.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][1].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][1].first, 0.30, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][2].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][2].first, 0.40, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][3].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][3].first, 0.45, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][4].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][4].first, 0.55, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][5].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][5].first, 0.67, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[8]].size() == 6);
+    REQUIRE(sortedOutput[newFromOld[8]][0].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[8]][0].first == Approx(0.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][1].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[8]][1].first == Approx(0.30).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][2].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[8]][2].first == Approx(0.40).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][3].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[8]][3].first == Approx(0.45).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][4].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[8]][4].first == Approx(0.55).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][5].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[8]][5].first == Approx(0.67).epsilon(1e-7));
 
     // Neighbors of point 9.
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][0].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][0].first, 0.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][1].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][1].first, 0.35, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][2].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][2].first, 0.45, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][3].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][3].first, 0.55, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[9]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[9]][0].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[9]][0].first == Approx(0.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][1].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[9]][1].first == Approx(0.35).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][2].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[9]][2].first == Approx(0.45).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][3].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[9]][3].first == Approx(0.55).epsilon(1e-7));
 
     // Neighbors of point 10.
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][0].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][0].first, 0.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][1].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][1].first, 0.25, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][2].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][2].first, 0.55, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][3].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][3].first, 0.65, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[10]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[10]][0].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[10]][0].first == Approx(0.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][1].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[10]][1].first == Approx(0.25).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][2].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[10]][2].first == Approx(0.55).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][3].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[10]][3].first == Approx(0.65).epsilon(1e-7));
 
     // Now do it again with a different range: [sqrt(0.5) 1.0].
     if (rs->ReferenceTree())
@@ -222,61 +221,61 @@ BOOST_AUTO_TEST_CASE(ExhaustiveSyntheticTest)
     SortResults(neighbors, distances, sortedOutput);
 
     // Neighbors of point 0.
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]].size() == 2);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][0].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][0].first, 0.85, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][1].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][1].first, 0.95, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[0]].size() == 2);
+    REQUIRE(sortedOutput[newFromOld[0]][0].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[0]][0].first == Approx(0.85).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][1].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[0]][1].first == Approx(0.95).epsilon(1e-7));
 
     // Neighbors of point 1.
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]].size() == 1);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][0].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][0].first, 0.90, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[1]].size() == 1);
+    REQUIRE(sortedOutput[newFromOld[1]][0].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[1]][0].first == Approx(0.90).epsilon(1e-7));
 
     // Neighbors of point 2.
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]].size() == 2);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][0].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][0].first, 0.75, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][1].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][1].first, 0.85, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[2]].size() == 2);
+    REQUIRE(sortedOutput[newFromOld[2]][0].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[2]][0].first == Approx(0.75).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][1].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[2]][1].first == Approx(0.85).epsilon(1e-7));
 
     // Neighbors of point 3.
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]].size() == 2);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][0].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][0].first, 0.80, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][1].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][1].first, 0.90, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[3]].size() == 2);
+    REQUIRE(sortedOutput[newFromOld[3]][0].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[3]][0].first == Approx(0.80).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][1].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[3]][1].first == Approx(0.90).epsilon(1e-7));
 
     // Neighbors of point 4.
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]].size() == 0);
+    REQUIRE(sortedOutput[newFromOld[4]].size() == 0);
 
     // Neighbors of point 5.
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]].size() == 0);
+    REQUIRE(sortedOutput[newFromOld[5]].size() == 0);
 
     // Neighbors of point 6.
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]].size() == 0);
+    REQUIRE(sortedOutput[newFromOld[6]].size() == 0);
 
     // Neighbors of point 7.
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]].size() == 0);
+    REQUIRE(sortedOutput[newFromOld[7]].size() == 0);
 
     // Neighbors of point 8.
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]].size() == 1);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][0].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][0].first, 0.80, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[8]].size() == 1);
+    REQUIRE(sortedOutput[newFromOld[8]][0].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[8]][0].first == Approx(0.80).epsilon(1e-7));
 
     // Neighbors of point 9.
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]].size() == 2);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][0].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][0].first, 0.75, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][1].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][1].first, 0.85, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[9]].size() == 2);
+    REQUIRE(sortedOutput[newFromOld[9]][0].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[9]][0].first == Approx(0.75).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][1].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[9]][1].first == Approx(0.85).epsilon(1e-7));
 
     // Neighbors of point 10.
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]].size() == 2);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][0].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][0].first, 0.85, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][1].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][1].first, 0.95, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[10]].size() == 2);
+    REQUIRE(sortedOutput[newFromOld[10]][0].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[10]][0].first == Approx(0.85).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][1].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[10]][1].first == Approx(0.95).epsilon(1e-7));
 
     // Now do it again with a different range: [1.0 inf].
     if (rs->ReferenceTree())
@@ -286,161 +285,161 @@ BOOST_AUTO_TEST_CASE(ExhaustiveSyntheticTest)
     SortResults(neighbors, distances, sortedOutput);
 
     // Neighbors of point 0.
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][0].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][0].first, 1.20, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][1].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][1].first, 1.35, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][2].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][2].first, 2.05, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[0]][3].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[0]][3].first, 5.00, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[0]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[0]][0].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[0]][0].first == Approx(1.20).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][1].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[0]][1].first == Approx(1.35).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][2].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[0]][2].first == Approx(2.05).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[0]][3].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[0]][3].first == Approx(5.00).epsilon(1e-7));
 
     // Neighbors of point 1.
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]].size() == 3);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][0].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][0].first, 1.65, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][1].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][1].first, 2.35, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[1]][2].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[1]][2].first, 4.70, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[1]].size() == 3);
+    REQUIRE(sortedOutput[newFromOld[1]][0].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[1]][0].first == Approx(1.65).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][1].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[1]][1].first == Approx(2.35).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[1]][2].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[1]][2].first == Approx(4.70).epsilon(1e-7));
 
     // Neighbors of point 2.
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][0].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][0].first, 1.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][1].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][1].first, 1.45, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][2].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][2].first, 2.15, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[2]][3].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[2]][3].first, 4.90, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[2]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[2]][0].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[2]][0].first == Approx(1.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][1].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[2]][1].first == Approx(1.45).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][2].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[2]][2].first == Approx(2.15).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[2]][3].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[2]][3].first == Approx(4.90).epsilon(1e-7));
 
     // Neighbors of point 3.
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]].size() == 6);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][0].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][0].first, 1.10, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][1].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][1].first, 1.20, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][2].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][2].first, 1.47, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][3].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][3].first, 2.55, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][4].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][4].first, 3.25, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[3]][5].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[3]][5].first, 3.80, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[3]].size() == 6);
+    REQUIRE(sortedOutput[newFromOld[3]][0].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[3]][0].first == Approx(1.10).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][1].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[3]][1].first == Approx(1.20).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][2].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[3]][2].first == Approx(1.47).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][3].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[3]][3].first == Approx(2.55).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][4].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[3]][4].first == Approx(3.25).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[3]][5].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[3]][5].first == Approx(3.80).epsilon(1e-7));
 
     // Neighbors of point 4.
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]].size() == 10);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][0].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][0].first, 3.80, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][1].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][1].first, 4.05, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][2].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][2].first, 4.15, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][3].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][3].first, 4.60, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][4].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][4].first, 4.70, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][5].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][5].first, 4.90, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][6].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][6].first, 5.00, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][7].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][7].first, 5.27, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][8].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][8].first, 6.35, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[4]][9].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[4]][9].first, 7.05, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[4]].size() == 10);
+    REQUIRE(sortedOutput[newFromOld[4]][0].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[4]][0].first == Approx(3.80).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][1].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[4]][1].first == Approx(4.05).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][2].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[4]][2].first == Approx(4.15).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][3].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[4]][3].first == Approx(4.60).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][4].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[4]][4].first == Approx(4.70).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][5].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[4]][5].first == Approx(4.90).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][6].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[4]][6].first == Approx(5.00).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][7].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[4]][7].first == Approx(5.27).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][8].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[4]][8].first == Approx(6.35).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[4]][9].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[4]][9].first == Approx(7.05).epsilon(1e-7));
 
     // Neighbors of point 5.
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]].size() == 6);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][0].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][0].first, 1.08, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][1].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][1].first, 1.12, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][2].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][2].first, 1.22, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][3].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][3].first, 1.47, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][4].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][4].first, 1.78, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[5]][5].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[5]][5].first, 5.27, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[5]].size() == 6);
+    REQUIRE(sortedOutput[newFromOld[5]][0].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[5]][0].first == Approx(1.08).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][1].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[5]][1].first == Approx(1.12).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][2].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[5]][2].first == Approx(1.22).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][3].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[5]][3].first == Approx(1.47).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][4].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[5]][4].first == Approx(1.78).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[5]][5].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[5]][5].first == Approx(5.27).epsilon(1e-7));
 
     // Neighbors of point 6.
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]].size() == 9);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][0].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][0].first, 1.78, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][1].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][1].first, 2.05, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][2].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][2].first, 2.15, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][3].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][3].first, 2.35, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][4].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][4].first, 2.45, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][5].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][5].first, 2.90, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][6].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][6].first, 3.00, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][7].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][7].first, 3.25, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[6]][8].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[6]][8].first, 7.05, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[6]].size() == 9);
+    REQUIRE(sortedOutput[newFromOld[6]][0].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[6]][0].first == Approx(1.78).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][1].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[6]][1].first == Approx(2.05).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][2].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[6]][2].first == Approx(2.15).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][3].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[6]][3].first == Approx(2.35).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][4].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[6]][4].first == Approx(2.45).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][5].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[6]][5].first == Approx(2.90).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][6].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[6]][6].first == Approx(3.00).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][7].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[6]][7].first == Approx(3.25).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[6]][8].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[6]][8].first == Approx(7.05).epsilon(1e-7));
 
     // Neighbors of point 7.
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]].size() == 9);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][0].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][0].first, 1.08, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][1].second == newFromOld[0]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][1].first, 1.35, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][2].second == newFromOld[2]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][2].first, 1.45, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][3].second == newFromOld[1]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][3].first, 1.65, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][4].second == newFromOld[8]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][4].first, 1.75, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][5].second == newFromOld[9]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][5].first, 2.20, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][6].second == newFromOld[10]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][6].first, 2.30, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][7].second == newFromOld[3]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][7].first, 2.55, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[7]][8].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[7]][8].first, 6.35, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[7]].size() == 9);
+    REQUIRE(sortedOutput[newFromOld[7]][0].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[7]][0].first == Approx(1.08).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][1].second == newFromOld[0]);
+    REQUIRE(sortedOutput[newFromOld[7]][1].first == Approx(1.35).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][2].second == newFromOld[2]);
+    REQUIRE(sortedOutput[newFromOld[7]][2].first == Approx(1.45).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][3].second == newFromOld[1]);
+    REQUIRE(sortedOutput[newFromOld[7]][3].first == Approx(1.65).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][4].second == newFromOld[8]);
+    REQUIRE(sortedOutput[newFromOld[7]][4].first == Approx(1.75).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][5].second == newFromOld[9]);
+    REQUIRE(sortedOutput[newFromOld[7]][5].first == Approx(2.20).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][6].second == newFromOld[10]);
+    REQUIRE(sortedOutput[newFromOld[7]][6].first == Approx(2.30).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][7].second == newFromOld[3]);
+    REQUIRE(sortedOutput[newFromOld[7]][7].first == Approx(2.55).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[7]][8].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[7]][8].first == Approx(6.35).epsilon(1e-7));
 
     // Neighbors of point 8.
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]].size() == 3);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][0].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][0].first, 1.75, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][1].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][1].first, 2.45, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[8]][2].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[8]][2].first, 4.60, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[8]].size() == 3);
+    REQUIRE(sortedOutput[newFromOld[8]][0].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[8]][0].first == Approx(1.75).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][1].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[8]][1].first == Approx(2.45).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[8]][2].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[8]][2].first == Approx(4.60).epsilon(1e-7));
 
     // Neighbors of point 9.
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][0].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][0].first, 1.12, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][1].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][1].first, 2.20, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][2].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][2].first, 2.90, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[9]][3].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[9]][3].first, 4.15, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[9]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[9]][0].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[9]][0].first == Approx(1.12).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][1].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[9]][1].first == Approx(2.20).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][2].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[9]][2].first == Approx(2.90).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[9]][3].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[9]][3].first == Approx(4.15).epsilon(1e-7));
 
     // Neighbors of point 10.
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]].size() == 4);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][0].second == newFromOld[5]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][0].first, 1.22, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][1].second == newFromOld[7]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][1].first, 2.30, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][2].second == newFromOld[6]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][2].first, 3.00, 1e-5);
-    BOOST_REQUIRE(sortedOutput[newFromOld[10]][3].second == newFromOld[4]);
-    BOOST_REQUIRE_CLOSE(sortedOutput[newFromOld[10]][3].first, 4.05, 1e-5);
+    REQUIRE(sortedOutput[newFromOld[10]].size() == 4);
+    REQUIRE(sortedOutput[newFromOld[10]][0].second == newFromOld[5]);
+    REQUIRE(sortedOutput[newFromOld[10]][0].first == Approx(1.22).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][1].second == newFromOld[7]);
+    REQUIRE(sortedOutput[newFromOld[10]][1].first == Approx(2.30).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][2].second == newFromOld[6]);
+    REQUIRE(sortedOutput[newFromOld[10]][2].first == Approx(3.00).epsilon(1e-7));
+    REQUIRE(sortedOutput[newFromOld[10]][3].second == newFromOld[4]);
+    REQUIRE(sortedOutput[newFromOld[10]][3].first == Approx(4.05).epsilon(1e-7));
 
     // Clean the memory.
     delete rs;
@@ -455,13 +454,13 @@ BOOST_AUTO_TEST_CASE(ExhaustiveSyntheticTest)
  *
  * Errors are produced if the results are not identical.
  */
-BOOST_AUTO_TEST_CASE(DualTreeVsNaive1)
+TEST_CASE("DualTreeVsNaive1", "[RangeSearchTest]")
 {
   arma::mat dataForTree;
 
   // Hard-coded filename: bad!
   if (!data::Load("test_data_3_1000.csv", dataForTree))
-    BOOST_FAIL("Cannot load test dataset test_data_3_1000.csv!");
+    FAIL("Cannot load test dataset test_data_3_1000.csv!");
 
   // Set up matrices to work with.
   arma::mat dualQuery(dataForTree);
@@ -487,13 +486,13 @@ BOOST_AUTO_TEST_CASE(DualTreeVsNaive1)
 
   for (size_t i = 0; i < sortedTree.size(); ++i)
   {
-    BOOST_REQUIRE(sortedTree[i].size() == sortedNaive[i].size());
+    REQUIRE(sortedTree[i].size() == sortedNaive[i].size());
 
     for (size_t j = 0; j < sortedTree[i].size(); ++j)
     {
-      BOOST_REQUIRE(sortedTree[i][j].second == sortedNaive[i][j].second);
-      BOOST_REQUIRE_CLOSE(sortedTree[i][j].first, sortedNaive[i][j].first,
-          1e-5);
+      REQUIRE(sortedTree[i][j].second == sortedNaive[i][j].second);
+      REQUIRE(sortedTree[i][j].first ==
+          Approx(sortedNaive[i][j].first).epsilon(1e-7));
     }
   }
 }
@@ -504,14 +503,14 @@ BOOST_AUTO_TEST_CASE(DualTreeVsNaive1)
  *
  * Errors are produced if the results are not identical.
  */
-BOOST_AUTO_TEST_CASE(DualTreeVsNaive2)
+TEST_CASE("DualTreeVsNaive2", "[RangeSearchTest]")
 {
   arma::mat dataForTree;
 
   // Hard-coded filename: bad!
   // Code duplication: also bad!
   if (!data::Load("test_data_3_1000.csv", dataForTree))
-    BOOST_FAIL("Cannot load test dataset test_data_3_1000.csv!");
+    FAIL("Cannot load test dataset test_data_3_1000.csv!");
 
   // Set up matrices to work with.
   arma::mat dualQuery(dataForTree);
@@ -536,13 +535,13 @@ BOOST_AUTO_TEST_CASE(DualTreeVsNaive2)
 
   for (size_t i = 0; i < sortedTree.size(); ++i)
   {
-    BOOST_REQUIRE(sortedTree[i].size() == sortedNaive[i].size());
+    REQUIRE(sortedTree[i].size() == sortedNaive[i].size());
 
     for (size_t j = 0; j < sortedTree[i].size(); ++j)
     {
-      BOOST_REQUIRE(sortedTree[i][j].second == sortedNaive[i][j].second);
-      BOOST_REQUIRE_CLOSE(sortedTree[i][j].first, sortedNaive[i][j].first,
-          1e-5);
+      REQUIRE(sortedTree[i][j].second == sortedNaive[i][j].second);
+      REQUIRE(sortedTree[i][j].first ==
+          Approx(sortedNaive[i][j].first).epsilon(1e-7));
     }
   }
 }
@@ -553,14 +552,14 @@ BOOST_AUTO_TEST_CASE(DualTreeVsNaive2)
  *
  * Errors are produced if the results are not identical.
  */
-BOOST_AUTO_TEST_CASE(SingleTreeVsNaive)
+TEST_CASE("SingleTreeVsNaive", "[RangeSearchTest]")
 {
   arma::mat dataForTree;
 
   // Hard-coded filename: bad!
   // Code duplication: also bad!
   if (!data::Load("test_data_3_1000.csv", dataForTree))
-    BOOST_FAIL("Cannot load test dataset test_data_3_1000.csv!");
+    FAIL("Cannot load test dataset test_data_3_1000.csv!");
 
   // Set up matrices to work with (may not be necessary with no ALIAS_MATRIX?).
   arma::mat singleQuery(dataForTree);
@@ -585,13 +584,13 @@ BOOST_AUTO_TEST_CASE(SingleTreeVsNaive)
 
   for (size_t i = 0; i < sortedTree.size(); ++i)
   {
-    BOOST_REQUIRE(sortedTree[i].size() == sortedNaive[i].size());
+    REQUIRE(sortedTree[i].size() == sortedNaive[i].size());
 
     for (size_t j = 0; j < sortedTree[i].size(); ++j)
     {
-      BOOST_REQUIRE(sortedTree[i][j].second == sortedNaive[i][j].second);
-      BOOST_REQUIRE_CLOSE(sortedTree[i][j].first, sortedNaive[i][j].first,
-          1e-5);
+      REQUIRE(sortedTree[i][j].second == sortedNaive[i][j].second);
+      REQUIRE(sortedTree[i][j].first ==
+          Approx(sortedNaive[i][j].first).epsilon(1e-7));
     }
   }
 }
@@ -600,7 +599,7 @@ BOOST_AUTO_TEST_CASE(SingleTreeVsNaive)
  * Ensure that dual tree range search with cover trees works by comparing
  * with the kd-tree implementation.
  */
-BOOST_AUTO_TEST_CASE(CoverTreeTest)
+TEST_CASE("CoverTreeTest", "[RangeSearchTest]")
 {
   arma::mat data;
   data.randu(8, 1000); // 1000 points in 8 dimensions.
@@ -662,11 +661,11 @@ BOOST_AUTO_TEST_CASE(CoverTreeTest)
     {
       for (size_t j = 0; j < kdSorted[i].size(); ++j)
       {
-        BOOST_REQUIRE_EQUAL(kdSorted[i][j].second, coverSorted[i][j].second);
-        BOOST_REQUIRE_CLOSE(kdSorted[i][j].first, coverSorted[i][j].first,
-            1e-5);
+        REQUIRE(kdSorted[i][j].second == coverSorted[i][j].second);
+        REQUIRE(kdSorted[i][j].first ==
+            Approx(coverSorted[i][j].first).epsilon(1e-7));
       }
-      BOOST_REQUIRE_EQUAL(kdSorted[i].size(), coverSorted[i].size());
+      REQUIRE(kdSorted[i].size() == coverSorted[i].size());
     }
   }
 }
@@ -675,7 +674,7 @@ BOOST_AUTO_TEST_CASE(CoverTreeTest)
  * Ensure that dual tree range search with cover trees works when using
  * two datasets.
  */
-BOOST_AUTO_TEST_CASE(CoverTreeTwoDatasetsTest)
+TEST_CASE("CoverTreeTwoDatasetsTest", "[RangeSearchTest]")
 {
   arma::mat data;
   data.randu(8, 1000); // 1000 points in 8 dimensions.
@@ -740,11 +739,11 @@ BOOST_AUTO_TEST_CASE(CoverTreeTwoDatasetsTest)
     {
       for (size_t j = 0; j < kdSorted[i].size(); ++j)
       {
-        BOOST_REQUIRE_EQUAL(kdSorted[i][j].second, coverSorted[i][j].second);
-        BOOST_REQUIRE_CLOSE(kdSorted[i][j].first, coverSorted[i][j].first,
-            1e-5);
+        REQUIRE(kdSorted[i][j].second == coverSorted[i][j].second);
+        REQUIRE(kdSorted[i][j].first ==
+            Approx(coverSorted[i][j].first).epsilon(1e-7));
       }
-      BOOST_REQUIRE_EQUAL(kdSorted[i].size(), coverSorted[i].size());
+      REQUIRE(kdSorted[i].size() == coverSorted[i].size());
     }
   }
 }
@@ -752,7 +751,7 @@ BOOST_AUTO_TEST_CASE(CoverTreeTwoDatasetsTest)
 /**
  * Ensure that single-tree cover tree range search works.
  */
-BOOST_AUTO_TEST_CASE(CoverTreeSingleTreeTest)
+TEST_CASE("CoverTreeSingleTreeTest", "[RangeSearchTest]")
 {
   arma::mat data;
   data.randu(8, 1000); // 1000 points in 8 dimensions.
@@ -814,11 +813,11 @@ BOOST_AUTO_TEST_CASE(CoverTreeSingleTreeTest)
     {
       for (size_t j = 0; j < kdSorted[i].size(); ++j)
       {
-        BOOST_REQUIRE_EQUAL(kdSorted[i][j].second, coverSorted[i][j].second);
-        BOOST_REQUIRE_CLOSE(kdSorted[i][j].first, coverSorted[i][j].first,
-            1e-5);
+        REQUIRE(kdSorted[i][j].second == coverSorted[i][j].second);
+        REQUIRE(kdSorted[i][j].first ==
+            Approx(coverSorted[i][j].first).epsilon(1e-7));
       }
-      BOOST_REQUIRE_EQUAL(kdSorted[i].size(), coverSorted[i].size());
+      REQUIRE(kdSorted[i].size() == coverSorted[i].size());
     }
   }
 }
@@ -826,7 +825,7 @@ BOOST_AUTO_TEST_CASE(CoverTreeSingleTreeTest)
 /**
  * Ensure that single-tree ball tree range search works.
  */
-BOOST_AUTO_TEST_CASE(SingleBallTreeTest)
+TEST_CASE("SingleBallTreeTest", "[RangeSearchTest]")
 {
   arma::mat data;
   data.randu(8, 1000); // 1000 points in 8 dimensions.
@@ -888,11 +887,11 @@ BOOST_AUTO_TEST_CASE(SingleBallTreeTest)
     {
       for (size_t j = 0; j < kdSorted[i].size(); ++j)
       {
-        BOOST_REQUIRE_EQUAL(kdSorted[i][j].second, ballSorted[i][j].second);
-        BOOST_REQUIRE_CLOSE(kdSorted[i][j].first, ballSorted[i][j].first,
-            1e-5);
+        REQUIRE(kdSorted[i][j].second == ballSorted[i][j].second);
+        REQUIRE(kdSorted[i][j].first ==
+            Approx(ballSorted[i][j].first).epsilon(1e-7));
       }
-      BOOST_REQUIRE_EQUAL(kdSorted[i].size(), ballSorted[i].size());
+      REQUIRE(kdSorted[i].size() == ballSorted[i].size());
     }
   }
 }
@@ -901,7 +900,7 @@ BOOST_AUTO_TEST_CASE(SingleBallTreeTest)
  * Ensure that dual tree range search with ball trees works by comparing
  * with the kd-tree implementation.
  */
-BOOST_AUTO_TEST_CASE(DualBallTreeTest)
+TEST_CASE("DualBallTreeTest", "[RangeSearchTest]")
 {
   arma::mat data;
   data.randu(8, 1000); // 1000 points in 8 dimensions.
@@ -962,11 +961,11 @@ BOOST_AUTO_TEST_CASE(DualBallTreeTest)
     {
       for (size_t j = 0; j < kdSorted[i].size(); ++j)
       {
-        BOOST_REQUIRE_EQUAL(kdSorted[i][j].second, ballSorted[i][j].second);
-        BOOST_REQUIRE_CLOSE(kdSorted[i][j].first, ballSorted[i][j].first,
-            1e-5);
+        REQUIRE(kdSorted[i][j].second == ballSorted[i][j].second);
+        REQUIRE(kdSorted[i][j].first ==
+            Approx(ballSorted[i][j].first).epsilon(1e-7));
       }
-      BOOST_REQUIRE_EQUAL(kdSorted[i].size(), ballSorted[i].size());
+      REQUIRE(kdSorted[i].size() == ballSorted[i].size());
     }
   }
 }
@@ -975,7 +974,7 @@ BOOST_AUTO_TEST_CASE(DualBallTreeTest)
  * Ensure that dual tree range search with ball trees works when using
  * two datasets.
  */
-BOOST_AUTO_TEST_CASE(DualBallTreeTest2)
+TEST_CASE("DualBallTreeTest2", "[RangeSearchTest]")
 {
   arma::mat data;
   data.randu(8, 1000); // 1000 points in 8 dimensions.
@@ -1038,12 +1037,12 @@ BOOST_AUTO_TEST_CASE(DualBallTreeTest2)
     // Now compare the results.
     for (size_t i = 0; i < kdSorted.size(); ++i)
     {
-      BOOST_REQUIRE_EQUAL(kdSorted[i].size(), ballSorted[i].size());
+      REQUIRE(kdSorted[i].size() == ballSorted[i].size());
       for (size_t j = 0; j < kdSorted[i].size(); ++j)
       {
-        BOOST_REQUIRE_EQUAL(kdSorted[i][j].second, ballSorted[i][j].second);
-        BOOST_REQUIRE_CLOSE(kdSorted[i][j].first, ballSorted[i][j].first,
-            1e-5);
+        REQUIRE(kdSorted[i][j].second == ballSorted[i][j].second);
+        REQUIRE(kdSorted[i][j].first ==
+            Approx(ballSorted[i][j].first).epsilon (1e-7));
       }
     }
   }
@@ -1053,7 +1052,7 @@ BOOST_AUTO_TEST_CASE(DualBallTreeTest2)
  * Make sure that no results are returned when we build a range search object
  * with no reference set.
  */
-BOOST_AUTO_TEST_CASE(EmptySearchTest)
+TEST_CASE("EmptySearchTest", "[RangeSearchTest]")
 {
   RangeSearch<EuclideanDistance, arma::mat, KDTree> rs;
 
@@ -1062,20 +1061,20 @@ BOOST_AUTO_TEST_CASE(EmptySearchTest)
 
   rs.Search(math::Range(0.0, 10.0), neighbors, distances);
 
-  BOOST_REQUIRE_EQUAL(neighbors.size(), 0);
-  BOOST_REQUIRE_EQUAL(distances.size(), 0);
+  REQUIRE(neighbors.size() == 0);
+  REQUIRE(distances.size() == 0);
 
   // Now check with a query set.
   arma::mat querySet = arma::randu<arma::mat>(3, 100);
 
-  BOOST_REQUIRE_THROW(rs.Search(querySet, math::Range(0.0, 10.0), neighbors,
+  REQUIRE_THROWS_AS(rs.Search(querySet, math::Range(0.0, 10.0), neighbors,
       distances), std::invalid_argument);
 }
 
 /**
  * Make sure things work right after Train() is called.
  */
-BOOST_AUTO_TEST_CASE(TrainTest)
+TEST_CASE("RangeSearchTrainTest", "[RangeSearchTest]")
 {
   RangeSearch<> empty;
 
@@ -1090,8 +1089,8 @@ BOOST_AUTO_TEST_CASE(TrainTest)
   empty.Search(math::Range(0.5, 0.7), neighbors, distances);
   baseline.Search(math::Range(0.5, 0.7), baselineNeighbors, baselineDistances);
 
-  BOOST_REQUIRE_EQUAL(neighbors.size(), baselineNeighbors.size());
-  BOOST_REQUIRE_EQUAL(distances.size(), baselineDistances.size());
+  REQUIRE(neighbors.size() == baselineNeighbors.size());
+  REQUIRE(distances.size() == baselineDistances.size());
 
   // Sort the results before comparing.
   vector<vector<pair<double, size_t>>> sorted;
@@ -1101,11 +1100,12 @@ BOOST_AUTO_TEST_CASE(TrainTest)
 
   for (size_t i = 0; i < sorted.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(sorted[i].size(), baselineSorted[i].size());
+    REQUIRE(sorted[i].size() == baselineSorted[i].size());
     for (size_t j = 0; j < sorted[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(sorted[i][j].second, baselineSorted[i][j].second);
-      BOOST_REQUIRE_CLOSE(sorted[i][j].first, baselineSorted[i][j].first, 1e-5);
+      REQUIRE(sorted[i][j].second == baselineSorted[i][j].second);
+      REQUIRE(sorted[i][j].first ==
+          Approx(baselineSorted[i][j].first).epsilon(1e-7));
     }
   }
 }
@@ -1113,7 +1113,7 @@ BOOST_AUTO_TEST_CASE(TrainTest)
 /**
  * Test training when a tree is given.
  */
-BOOST_AUTO_TEST_CASE(TrainTreeTest)
+TEST_CASE("TrainTreeTest", "[RangeSearchTest]")
 {
   // Avoid mappings by using the cover tree.
   typedef RangeSearch<EuclideanDistance, arma::mat, StandardCoverTree> RSType;
@@ -1131,8 +1131,8 @@ BOOST_AUTO_TEST_CASE(TrainTreeTest)
   empty.Search(math::Range(0.5, 0.7), neighbors, distances);
   baseline.Search(math::Range(0.5, 0.7), baselineNeighbors, baselineDistances);
 
-  BOOST_REQUIRE_EQUAL(neighbors.size(), baselineNeighbors.size());
-  BOOST_REQUIRE_EQUAL(distances.size(), baselineDistances.size());
+  REQUIRE(neighbors.size() == baselineNeighbors.size());
+  REQUIRE(distances.size() == baselineDistances.size());
 
   // Sort the results before comparing.
   vector<vector<pair<double, size_t>>> sorted;
@@ -1142,11 +1142,12 @@ BOOST_AUTO_TEST_CASE(TrainTreeTest)
 
   for (size_t i = 0; i < sorted.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(sorted[i].size(), baselineSorted[i].size());
+    REQUIRE(sorted[i].size() == baselineSorted[i].size());
     for (size_t j = 0; j < sorted[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(sorted[i][j].second, baselineSorted[i][j].second);
-      BOOST_REQUIRE_CLOSE(sorted[i][j].first, baselineSorted[i][j].first, 1e-5);
+      REQUIRE(sorted[i][j].second == baselineSorted[i][j].second);
+      REQUIRE(sorted[i][j].first ==
+          Approx(baselineSorted[i][j].first).epsilon(1e-7));
     }
   }
 }
@@ -1154,20 +1155,20 @@ BOOST_AUTO_TEST_CASE(TrainTreeTest)
 /**
  * Test that training with a tree throws an exception when in naive mode.
  */
-BOOST_AUTO_TEST_CASE(NaiveTrainTreeTest)
+TEST_CASE("NaiveTrainTreeTest", "[RangeSearchTest]")
 {
   RangeSearch<> empty(true);
 
   arma::mat dataset = arma::randu<arma::mat>(5, 100);
   RangeSearch<>::Tree tree(dataset);
 
-  BOOST_REQUIRE_THROW(empty.Train(&tree), std::invalid_argument);
+  REQUIRE_THROWS_AS(empty.Train(&tree), std::invalid_argument);
 }
 
 /**
  * Test that the move constructor works.
  */
-BOOST_AUTO_TEST_CASE(MoveConstructorMatrixTest)
+TEST_CASE("MoveConstructorMatrixTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(3, 100);
   arma::mat copy(dataset);
@@ -1175,9 +1176,9 @@ BOOST_AUTO_TEST_CASE(MoveConstructorMatrixTest)
   RangeSearch<> movers(std::move(copy));
   RangeSearch<> rs(dataset);
 
-  BOOST_REQUIRE_EQUAL(copy.n_elem, 0);
-  BOOST_REQUIRE_EQUAL(movers.ReferenceSet().n_rows, 3);
-  BOOST_REQUIRE_EQUAL(movers.ReferenceSet().n_cols, 100);
+  REQUIRE(copy.n_elem == 0);
+  REQUIRE(movers.ReferenceSet().n_rows == 3);
+  REQUIRE(movers.ReferenceSet().n_cols == 100);
 
   vector<vector<size_t>> moveNeighbors, neighbors;
   vector<vector<double>> moveDistances, distances;
@@ -1185,8 +1186,8 @@ BOOST_AUTO_TEST_CASE(MoveConstructorMatrixTest)
   movers.Search(math::Range(0.5, 0.7), moveNeighbors, moveDistances);
   rs.Search(math::Range(0.5, 0.7), neighbors, distances);
 
-  BOOST_REQUIRE_EQUAL(neighbors.size(), moveNeighbors.size());
-  BOOST_REQUIRE_EQUAL(distances.size(), moveDistances.size());
+  REQUIRE(neighbors.size() == moveNeighbors.size());
+  REQUIRE(distances.size() == moveDistances.size());
 
   // Sort the results before comparing.
   vector<vector<pair<double, size_t>>> sorted;
@@ -1196,11 +1197,12 @@ BOOST_AUTO_TEST_CASE(MoveConstructorMatrixTest)
 
   for (size_t i = 0; i < sorted.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(sorted[i].size(), moveSorted[i].size());
+    REQUIRE(sorted[i].size() == moveSorted[i].size());
     for (size_t j = 0; j < sorted[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(sorted[i][j].second, moveSorted[i][j].second);
-      BOOST_REQUIRE_CLOSE(sorted[i][j].first, moveSorted[i][j].first, 1e-5);
+      REQUIRE(sorted[i][j].second == moveSorted[i][j].second);
+      REQUIRE(sorted[i][j].first ==
+          Approx(moveSorted[i][j].first).epsilon(1e-7));
     }
   }
 }
@@ -1208,7 +1210,7 @@ BOOST_AUTO_TEST_CASE(MoveConstructorMatrixTest)
 /**
  * Test that the std::move() Train() function works.
  */
-BOOST_AUTO_TEST_CASE(MoveTrainTest)
+TEST_CASE("MoveTrainTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(3, 100);
   arma::mat copy(dataset);
@@ -1217,9 +1219,9 @@ BOOST_AUTO_TEST_CASE(MoveTrainTest)
   movers.Train(std::move(copy));
   RangeSearch<> rs(dataset);
 
-  BOOST_REQUIRE_EQUAL(copy.n_elem, 0);
-  BOOST_REQUIRE_EQUAL(movers.ReferenceSet().n_rows, 3);
-  BOOST_REQUIRE_EQUAL(movers.ReferenceSet().n_cols, 100);
+  REQUIRE(copy.n_elem == 0);
+  REQUIRE(movers.ReferenceSet().n_rows == 3);
+  REQUIRE(movers.ReferenceSet().n_cols == 100);
 
   vector<vector<size_t>> moveNeighbors, neighbors;
   vector<vector<double>> moveDistances, distances;
@@ -1227,8 +1229,8 @@ BOOST_AUTO_TEST_CASE(MoveTrainTest)
   movers.Search(math::Range(0.5, 0.7), moveNeighbors, moveDistances);
   rs.Search(math::Range(0.5, 0.7), neighbors, distances);
 
-  BOOST_REQUIRE_EQUAL(neighbors.size(), moveNeighbors.size());
-  BOOST_REQUIRE_EQUAL(distances.size(), moveDistances.size());
+  REQUIRE(neighbors.size() == moveNeighbors.size());
+  REQUIRE(distances.size() == moveDistances.size());
 
   // Sort the results before comparing.
   vector<vector<pair<double, size_t>>> sorted;
@@ -1238,16 +1240,17 @@ BOOST_AUTO_TEST_CASE(MoveTrainTest)
 
   for (size_t i = 0; i < sorted.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(sorted[i].size(), moveSorted[i].size());
+    REQUIRE(sorted[i].size() == moveSorted[i].size());
     for (size_t j = 0; j < sorted[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(sorted[i][j].second, moveSorted[i][j].second);
-      BOOST_REQUIRE_CLOSE(sorted[i][j].first, moveSorted[i][j].first, 1e-5);
+      REQUIRE(sorted[i][j].second == moveSorted[i][j].second);
+      REQUIRE(sorted[i][j].first ==
+          Approx(moveSorted[i][j].first).epsilon(1e-7));
     }
   }
 }
 
-BOOST_AUTO_TEST_CASE(RSModelTest)
+TEST_CASE("RSModelTest", "[RangeSearchTest]")
 {
   // Ensure that we can build an RSModel and get correct results.
   arma::mat queryData = arma::randu<arma::mat>(10, 50);
@@ -1284,7 +1287,7 @@ BOOST_AUTO_TEST_CASE(RSModelTest)
   models[26] = RSModel(RSModel::TreeTypes::OCTREE, true);
   models[27] = RSModel(RSModel::TreeTypes::OCTREE, false);
 
-  for (size_t j = 0; j < 2; ++j)
+  for (size_t j = 0; j < 3; ++j)
   {
     // Get a baseline.
     RangeSearch<> rs(referenceData);
@@ -1314,27 +1317,27 @@ BOOST_AUTO_TEST_CASE(RSModelTest)
       models[i].Search(std::move(queryCopy), math::Range(0.25, 0.75), neighbors,
           distances);
 
-      BOOST_REQUIRE_EQUAL(neighbors.size(), baselineNeighbors.size());
-      BOOST_REQUIRE_EQUAL(distances.size(), baselineDistances.size());
+      REQUIRE(neighbors.size() == baselineNeighbors.size());
+      REQUIRE(distances.size() == baselineDistances.size());
 
       vector<vector<pair<double, size_t>>> sorted;
       SortResults(neighbors, distances, sorted);
 
       for (size_t k = 0; k < sorted.size(); ++k)
       {
-        BOOST_REQUIRE_EQUAL(sorted[k].size(), baselineSorted[k].size());
+        REQUIRE(sorted[k].size() == baselineSorted[k].size());
         for (size_t l = 0; l < sorted[k].size(); ++l)
         {
-          BOOST_REQUIRE_EQUAL(sorted[k][l].second, baselineSorted[k][l].second);
-          BOOST_REQUIRE_CLOSE(sorted[k][l].first, baselineSorted[k][l].first,
-              1e-5);
+          REQUIRE(sorted[k][l].second == baselineSorted[k][l].second);
+          REQUIRE(sorted[k][l].first ==
+              Approx(baselineSorted[k][l].first).epsilon(1e-7));
         }
       }
     }
   }
 }
 
-BOOST_AUTO_TEST_CASE(RSModelMonochromaticTest)
+TEST_CASE("RSModelMonochromaticTest", "[RangeSearchTest]")
 {
   // Ensure that we can build an RSModel and get correct results.
   arma::mat referenceData = arma::randu<arma::mat>(10, 200);
@@ -1370,7 +1373,7 @@ BOOST_AUTO_TEST_CASE(RSModelMonochromaticTest)
   models[26] = RSModel(RSModel::TreeTypes::OCTREE, true);
   models[27] = RSModel(RSModel::TreeTypes::OCTREE, false);
 
-  for (size_t j = 0; j < 2; ++j)
+  for (size_t j = 0; j < 3; ++j)
   {
     // Get a baseline.
     RangeSearch<> rs(referenceData);
@@ -1397,20 +1400,20 @@ BOOST_AUTO_TEST_CASE(RSModelMonochromaticTest)
 
       models[i].Search(math::Range(0.25, 0.5), neighbors, distances);
 
-      BOOST_REQUIRE_EQUAL(neighbors.size(), baselineNeighbors.size());
-      BOOST_REQUIRE_EQUAL(distances.size(), baselineDistances.size());
+      REQUIRE(neighbors.size() == baselineNeighbors.size());
+      REQUIRE(distances.size() == baselineDistances.size());
 
       vector<vector<pair<double, size_t>>> sorted;
       SortResults(neighbors, distances, sorted);
 
       for (size_t k = 0; k < sorted.size(); ++k)
       {
-        BOOST_REQUIRE_EQUAL(sorted[k].size(), baselineSorted[k].size());
+        REQUIRE(sorted[k].size() == baselineSorted[k].size());
         for (size_t l = 0; l < sorted[k].size(); ++l)
         {
-          BOOST_REQUIRE_EQUAL(sorted[k][l].second, baselineSorted[k][l].second);
-          BOOST_REQUIRE_CLOSE(sorted[k][l].first, baselineSorted[k][l].first,
-              1e-5);
+          REQUIRE(sorted[k][l].second == baselineSorted[k][l].second);
+          REQUIRE(sorted[k][l].first ==
+              Approx(baselineSorted[k][l].first).epsilon(1e-7));
         }
       }
     }
@@ -1421,7 +1424,7 @@ BOOST_AUTO_TEST_CASE(RSModelMonochromaticTest)
  * Make sure that the neighborPtr matrix isn't accidentally deleted.
  * See issue #478.
  */
-BOOST_AUTO_TEST_CASE(NeighborPtrDeleteTest)
+TEST_CASE("NeighborPtrDeleteTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 100);
 
@@ -1438,14 +1441,14 @@ BOOST_AUTO_TEST_CASE(NeighborPtrDeleteTest)
 
   // These will (hopefully) fail is either the neighbors or the distances matrix
   // has been accidentally deleted.
-  BOOST_REQUIRE_EQUAL(neighbors.size(), 50);
-  BOOST_REQUIRE_EQUAL(distances.size(), 50);
+  REQUIRE(neighbors.size() == 50);
+  REQUIRE(distances.size() == 50);
 }
 
 /**
  * Test copy constructor and copy operator.
  */
-BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorTest)
+TEST_CASE("RangeSearchCopyConstructorAndOperatorTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 500);
   RangeSearch<> rs(std::move(dataset));
@@ -1463,26 +1466,26 @@ BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorTest)
   rs3.Search(math::Range(0.2, 0.3), neighbors3, distances3);
 
   // Check results.
-  BOOST_REQUIRE_EQUAL(distances.size(), distances2.size());
-  BOOST_REQUIRE_EQUAL(distances.size(), distances3.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors2.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors3.size());
+  REQUIRE(distances.size() == distances2.size());
+  REQUIRE(distances.size() == distances3.size());
+  REQUIRE(neighbors.size() == neighbors2.size());
+  REQUIRE(neighbors.size() == neighbors3.size());
 
   for (size_t i = 0; i < neighbors.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances2[i].size());
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances3[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors2[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors3[i].size());
+    REQUIRE(distances[i].size() == distances2[i].size());
+    REQUIRE(distances[i].size() == distances3[i].size());
+    REQUIRE(neighbors[i].size() == neighbors2[i].size());
+    REQUIRE(neighbors[i].size() == neighbors3[i].size());
 
     for (size_t j = 0; j < neighbors[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors2[i][j]);
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors3[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors2[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors3[i][j]);
 
       // Distances will always be between 0.2 and 0.3.
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances2[i][j], 1e-5);
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances3[i][j], 1e-5);
+      REQUIRE(distances[i][j] == Approx(distances2[i][j]).epsilon(1e-7));
+      REQUIRE(distances[i][j] == Approx(distances3[i][j]).epsilon(1e-7));
     }
   }
 }
@@ -1490,7 +1493,7 @@ BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorTest)
 /**
  * Test move constructor.
  */
-BOOST_AUTO_TEST_CASE(MoveConstructorTest)
+TEST_CASE("RangeSearchMoveConstructorTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 500);
   RangeSearch<>* rs = new RangeSearch<>(std::move(dataset));
@@ -1508,20 +1511,20 @@ BOOST_AUTO_TEST_CASE(MoveConstructorTest)
   rs2.Search(math::Range(0.2, 0.3), neighbors2, distances2);
 
   // Check results.
-  BOOST_REQUIRE_EQUAL(distances.size(), distances2.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors2.size());
+  REQUIRE(distances.size() == distances2.size());
+  REQUIRE(neighbors.size() == neighbors2.size());
 
   for (size_t i = 0; i < neighbors.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances2[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors2[i].size());
+    REQUIRE(distances[i].size() == distances2[i].size());
+    REQUIRE(neighbors[i].size() == neighbors2[i].size());
 
     for (size_t j = 0; j < neighbors[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors2[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors2[i][j]);
 
       // Distances will always be between 0.2 and 0.3.
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances2[i][j], 1e-5);
+      REQUIRE(distances[i][j] == Approx(distances2[i][j]).epsilon(1e-7));
     }
   }
 }
@@ -1529,7 +1532,7 @@ BOOST_AUTO_TEST_CASE(MoveConstructorTest)
 /**
  * Test move operator.
  */
-BOOST_AUTO_TEST_CASE(MoveOperatorTest)
+TEST_CASE("RangeSearchMoveOperatorTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 500);
   RangeSearch<>* rs = new RangeSearch<>(std::move(dataset));
@@ -1547,20 +1550,20 @@ BOOST_AUTO_TEST_CASE(MoveOperatorTest)
   rs2.Search(math::Range(0.2, 0.3), neighbors2, distances2);
 
   // Check results.
-  BOOST_REQUIRE_EQUAL(distances.size(), distances2.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors2.size());
+  REQUIRE(distances.size() == distances2.size());
+  REQUIRE(neighbors.size() == neighbors2.size());
 
   for (size_t i = 0; i < neighbors.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances2[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors2[i].size());
+    REQUIRE(distances[i].size() == distances2[i].size());
+    REQUIRE(neighbors[i].size() == neighbors2[i].size());
 
     for (size_t j = 0; j < neighbors[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors2[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors2[i][j]);
 
       // Distances will always be between 0.2 and 0.3.
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances2[i][j], 1e-5);
+      REQUIRE(distances[i][j] == Approx(distances2[i][j]).epsilon(1e-7));
     }
   }
 }
@@ -1569,7 +1572,7 @@ BOOST_AUTO_TEST_CASE(MoveOperatorTest)
  * Test copy constructor and copy operator in naive mode (so there are no
  * trees).
  */
-BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorNaiveTest)
+TEST_CASE("CopyConstructorAndOperatorNaiveTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 500);
   RangeSearch<> rs(std::move(dataset), true);
@@ -1578,8 +1581,8 @@ BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorNaiveTest)
   RangeSearch<> rs2(rs);
   RangeSearch<> rs3 = rs;
 
-  BOOST_REQUIRE_EQUAL(rs2.Naive(), true);
-  BOOST_REQUIRE_EQUAL(rs3.Naive(), true);
+  REQUIRE(rs2.Naive() == true);
+  REQUIRE(rs3.Naive() == true);
 
   // Get results.
   vector<vector<double>> distances, distances2, distances3;
@@ -1590,26 +1593,26 @@ BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorNaiveTest)
   rs3.Search(math::Range(0.2, 0.3), neighbors3, distances3);
 
   // Check results.
-  BOOST_REQUIRE_EQUAL(distances.size(), distances2.size());
-  BOOST_REQUIRE_EQUAL(distances.size(), distances3.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors2.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors3.size());
+  REQUIRE(distances.size() == distances2.size());
+  REQUIRE(distances.size() == distances3.size());
+  REQUIRE(neighbors.size() == neighbors2.size());
+  REQUIRE(neighbors.size() == neighbors3.size());
 
   for (size_t i = 0; i < neighbors.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances2[i].size());
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances3[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors2[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors3[i].size());
+    REQUIRE(distances[i].size() == distances2[i].size());
+    REQUIRE(distances[i].size() == distances3[i].size());
+    REQUIRE(neighbors[i].size() == neighbors2[i].size());
+    REQUIRE(neighbors[i].size() == neighbors3[i].size());
 
     for (size_t j = 0; j < neighbors[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors2[i][j]);
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors3[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors2[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors3[i][j]);
 
       // Distances will always be between 0.2 and 0.3.
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances2[i][j], 1e-5);
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances3[i][j], 1e-5);
+      REQUIRE(distances[i][j] == Approx(distances2[i][j]).epsilon(1e-7));
+      REQUIRE(distances[i][j] == Approx(distances3[i][j]).epsilon(1e-7));
     }
   }
 }
@@ -1617,7 +1620,7 @@ BOOST_AUTO_TEST_CASE(CopyConstructorAndOperatorNaiveTest)
 /**
  * Test move constructor.
  */
-BOOST_AUTO_TEST_CASE(MoveConstructorNaiveTest)
+TEST_CASE("MoveConstructorNaiveTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 500);
   RangeSearch<>* rs = new RangeSearch<>(std::move(dataset), true);
@@ -1630,27 +1633,27 @@ BOOST_AUTO_TEST_CASE(MoveConstructorNaiveTest)
 
   RangeSearch<> rs2(std::move(*rs));
 
-  BOOST_REQUIRE_EQUAL(rs2.Naive(), true);
+  REQUIRE(rs2.Naive() == true);
 
   delete rs;
 
   rs2.Search(math::Range(0.2, 0.3), neighbors2, distances2);
 
   // Check results.
-  BOOST_REQUIRE_EQUAL(distances.size(), distances2.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors2.size());
+  REQUIRE(distances.size() == distances2.size());
+  REQUIRE(neighbors.size() == neighbors2.size());
 
   for (size_t i = 0; i < neighbors.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances2[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors2[i].size());
+    REQUIRE(distances[i].size() == distances2[i].size());
+    REQUIRE(neighbors[i].size() == neighbors2[i].size());
 
     for (size_t j = 0; j < neighbors[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors2[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors2[i][j]);
 
       // Distances will always be between 0.2 and 0.3.
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances2[i][j], 1e-5);
+      REQUIRE(distances[i][j] == Approx(distances2[i][j]).epsilon(1e-7));
     }
   }
 }
@@ -1658,7 +1661,7 @@ BOOST_AUTO_TEST_CASE(MoveConstructorNaiveTest)
 /**
  * Test move operator.
  */
-BOOST_AUTO_TEST_CASE(MoveOperatorNaiveTest)
+TEST_CASE("MoveOperatorNaiveTest", "[RangeSearchTest]")
 {
   arma::mat dataset = arma::randu<arma::mat>(5, 500);
   RangeSearch<>* rs = new RangeSearch<>(std::move(dataset), true);
@@ -1671,29 +1674,27 @@ BOOST_AUTO_TEST_CASE(MoveOperatorNaiveTest)
 
   RangeSearch<> rs2 = std::move(*rs);
 
-  BOOST_REQUIRE_EQUAL(rs2.Naive(), true);
+  REQUIRE(rs2.Naive() == true);
 
   delete rs;
 
   rs2.Search(math::Range(0.2, 0.3), neighbors2, distances2);
 
   // Check results.
-  BOOST_REQUIRE_EQUAL(distances.size(), distances2.size());
-  BOOST_REQUIRE_EQUAL(neighbors.size(), neighbors2.size());
+  REQUIRE(distances.size() == distances2.size());
+  REQUIRE(neighbors.size() == neighbors2.size());
 
   for (size_t i = 0; i < neighbors.size(); ++i)
   {
-    BOOST_REQUIRE_EQUAL(distances[i].size(), distances2[i].size());
-    BOOST_REQUIRE_EQUAL(neighbors[i].size(), neighbors2[i].size());
+    REQUIRE(distances[i].size() == distances2[i].size());
+    REQUIRE(neighbors[i].size() == neighbors2[i].size());
 
     for (size_t j = 0; j < neighbors[i].size(); ++j)
     {
-      BOOST_REQUIRE_EQUAL(neighbors[i][j], neighbors2[i][j]);
+      REQUIRE(neighbors[i][j] == neighbors2[i][j]);
 
       // Distances will always be between 0.2 and 0.3.
-      BOOST_REQUIRE_CLOSE(distances[i][j], distances2[i][j], 1e-5);
+      REQUIRE(distances[i][j] == Approx(distances2[i][j]).epsilon(1e-7));
     }
   }
 }
-
-BOOST_AUTO_TEST_SUITE_END();