Merge of branch persistence_representation_integration_cmake_improvement

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/trunk@3117 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: 673143bd16e06d990aeb104a506cfd71f91a8717

7 files changed, 234 insertions, 286 deletions

diff --git a/src/Persistence_representations/test/persistence_heat_maps_test.cpp b/src/Persistence_representations/test/persistence_heat_maps_test.cpp
index 1f1502f5..4da13b86 100644
--- a/src/Persistence_representations/test/persistence_heat_maps_test.cpp
+++ b/src/Persistence_representations/test/persistence_heat_maps_test.cpp
@@ -25,12 +25,15 @@
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_heat_maps.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+double epsilon = 0.0005;
+
 BOOST_AUTO_TEST_CASE(check_construction_of_heat_maps) {
   std::vector<std::vector<double> > filter = create_Gaussian_filter(100, 1);
   Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
@@ -139,28 +142,15 @@ BOOST_AUTO_TEST_CASE(check_distance_for_heat_maps) {
   Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
   Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
 
-  // cerr << p.distance( p ) << endl;
-  // cerr << p.distance( q ) << endl;
-  // cerr << p.distance( r ) << endl;
-  // cerr << q.distance( p ) << endl;
-  // cerr << q.distance( q ) << endl;
-  // cerr << q.distance( r ) << endl;
-  // cerr << r.distance( p ) << endl;
-  // cerr << r.distance( q ) << endl;
-  // cerr << r.distance( r ) << endl;
-  // 0         624.183   415.815
-  // 624.183   0         528.06Z
-  // 415.815   528.066   0
-
-  BOOST_CHECK(fabs(p.distance(p) - 0) < 0.0005);
-  BOOST_CHECK(fabs(p.distance(q) - 624.183) < 0.0005);
-  BOOST_CHECK(fabs(p.distance(r) - 415.815) < 0.0005);
-  BOOST_CHECK(fabs(q.distance(p) - 624.183) < 0.0005);
-  BOOST_CHECK(fabs(q.distance(q) - 0) < 0.0005);
-  BOOST_CHECK(fabs(q.distance(r) - 528.066) < 0.0005);
-  BOOST_CHECK(fabs(r.distance(p) - 415.815) < 0.0005);
-  BOOST_CHECK(fabs(r.distance(q) - 528.066) < 0.0005);
-  BOOST_CHECK(fabs(r.distance(r) - 0) < 0.0005);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(p), 0.,      epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q), 624.183, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(r), 415.815, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.distance(p), 624.183, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.distance(q), 0.,      epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.distance(r), 528.066, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.distance(p), 415.815, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.distance(q), 528.066, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.distance(r), 0.,      epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_projections_to_R_for_heat_maps) {
@@ -169,13 +159,9 @@ BOOST_AUTO_TEST_CASE(check_projections_to_R_for_heat_maps) {
   Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
   Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
 
-  // cerr << p.project_to_R(0) << endl;
-  // cerr << q.project_to_R(0) << endl;
-  // cerr << r.project_to_R(0) << endl;
-
-  BOOST_CHECK(fabs(p.project_to_R(0) - 44.3308) < 0.0005);
-  BOOST_CHECK(fabs(q.project_to_R(0) - 650.568) < 0.0005);
-  BOOST_CHECK(fabs(r.project_to_R(0) - 429.287) < 0.0005);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.project_to_R(0), 44.3308, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.project_to_R(0), 650.568, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.project_to_R(0), 429.287, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_scalar_products_for_heat_maps) {
@@ -184,25 +170,15 @@ BOOST_AUTO_TEST_CASE(check_scalar_products_for_heat_maps) {
   Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
   Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
 
-  // cerr << p.compute_scalar_product( p ) << endl;
-  // cerr << p.compute_scalar_product( q ) << endl;
-  // cerr << p.compute_scalar_product( r ) << endl;
-  // cerr << q.compute_scalar_product( p ) << endl;
-  // cerr << q.compute_scalar_product( q ) << endl;
-  // cerr << q.compute_scalar_product( r ) << endl;
-  // cerr << r.compute_scalar_product( p ) << endl;
-  // cerr << r.compute_scalar_product( q ) << endl;
-  // cerr << r.compute_scalar_product( r ) << endl;
-
-  BOOST_CHECK(fabs(p.compute_scalar_product(p) - 0.0345687) < 0.0005);
-  BOOST_CHECK(fabs(p.compute_scalar_product(q) - 0.0509357) < 0.0005);
-  BOOST_CHECK(fabs(p.compute_scalar_product(r) - 0.0375608) < 0.0005);
-  BOOST_CHECK(fabs(q.compute_scalar_product(p) - 0.0509357) < 0.0005);
-  BOOST_CHECK(fabs(q.compute_scalar_product(q) - 1.31293) < 0.0005);
-  BOOST_CHECK(fabs(q.compute_scalar_product(r) - 0.536799) < 0.0005);
-  BOOST_CHECK(fabs(r.compute_scalar_product(p) - 0.0375608) < 0.0005);
-  BOOST_CHECK(fabs(r.compute_scalar_product(q) - 0.536799) < 0.0005);
-  BOOST_CHECK(fabs(r.compute_scalar_product(r) - 0.672907) < 0.0005);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(p), 0.0345687, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(q), 0.0509357, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(r), 0.0375608, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.compute_scalar_product(p), 0.0509357, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.compute_scalar_product(q), 1.31293  , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.compute_scalar_product(r), 0.536799 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.compute_scalar_product(p), 0.0375608, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.compute_scalar_product(q), 0.536799 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.compute_scalar_product(r), 0.672907 , epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_arythmetic_operations_for_heat_maps) {
diff --git a/src/Persistence_representations/test/persistence_intervals_test.cpp b/src/Persistence_representations/test/persistence_intervals_test.cpp
index 545330c4..c8f67966 100644
--- a/src/Persistence_representations/test/persistence_intervals_test.cpp
+++ b/src/Persistence_representations/test/persistence_intervals_test.cpp
@@ -25,25 +25,20 @@
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include "gudhi/Persistence_intervals.h"
+#include <gudhi/common_persistence_representations.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-double epsilon = 0.0000005;
-
-// cout << "Left most end of the interval : " << min_max_.first << std::endl;
-// cout << "Right most end of the interval : " << min_max_.second << std::endl;
 BOOST_AUTO_TEST_CASE(check_min_max_function) {
-	std::cerr << "First test \n";
   Persistence_intervals p("data/file_with_diagram");
   std::pair<double, double> min_max_ = p.get_x_range();
 
-  // cout << min_max_.first << " " << min_max_.second << std::endl;getchar();
-
-  BOOST_CHECK(fabs(min_max_.first - 0.0290362) <= epsilon);
-  BOOST_CHECK(fabs(min_max_.second - 0.994537) <= epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(min_max_.first, 0.0290362, Gudhi::Persistence_representations::epsi);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(min_max_.second, 0.994537, Gudhi::Persistence_representations::epsi);
 }
 
 BOOST_AUTO_TEST_CASE(check_length_of_dominant_intervals) {
@@ -61,7 +56,8 @@ BOOST_AUTO_TEST_CASE(check_length_of_dominant_intervals) {
   dominant_intervals_length.push_back(0.700468);
   dominant_intervals_length.push_back(0.622177);
   for (size_t i = 0; i != dominant_ten_intervals_length.size(); ++i) {
-    BOOST_CHECK(fabs(dominant_ten_intervals_length[i] - dominant_intervals_length[i]) <= epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(dominant_ten_intervals_length[i], dominant_intervals_length[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 BOOST_AUTO_TEST_CASE(check_dominant_intervals) {
@@ -81,8 +77,10 @@ BOOST_AUTO_TEST_CASE(check_dominant_intervals) {
   templ.push_back(std::pair<double, double>(0.267421, 0.889597));
 
   for (size_t i = 0; i != ten_dominant_intervals.size(); ++i) {
-    BOOST_CHECK(fabs(ten_dominant_intervals[i].first - templ[i].first) <= epsilon);
-    BOOST_CHECK(fabs(ten_dominant_intervals[i].second - templ[i].second) <= epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(ten_dominant_intervals[i].first, templ[i].first,
+                                    Gudhi::Persistence_representations::epsi);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(ten_dominant_intervals[i].second, templ[i].second,
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 
@@ -102,7 +100,7 @@ BOOST_AUTO_TEST_CASE(check_histogram_of_lengths) {
   template_histogram.push_back(1);
   template_histogram.push_back(1);
   for (size_t i = 0; i != histogram.size(); ++i) {
-    BOOST_CHECK(fabs(histogram[i] - template_histogram[i]) <= epsilon);
+    BOOST_CHECK(histogram[i] == template_histogram[i]);
   }
 }
 
@@ -123,7 +121,7 @@ BOOST_AUTO_TEST_CASE(check_cumulative_histograms_of_lengths) {
   template_cumulative_histogram.push_back(45);
 
   for (size_t i = 0; i != cumulative_histogram.size(); ++i) {
-    BOOST_CHECK(fabs(cumulative_histogram[i] - template_cumulative_histogram[i]) <= epsilon);
+    BOOST_CHECK(cumulative_histogram[i] == template_cumulative_histogram[i]);
   }
 }
 BOOST_AUTO_TEST_CASE(check_characteristic_function_of_diagram) {
@@ -143,15 +141,8 @@ BOOST_AUTO_TEST_CASE(check_characteristic_function_of_diagram) {
   template_char_funct_diag.push_back(0.0676303);
 
   for (size_t i = 0; i != char_funct_diag.size(); ++i) {
-    // cout << char_funct_diag[i] << std::endl;
-    if (fabs(char_funct_diag[i] - template_char_funct_diag[i]) >= 0.0001) {
-      std::cout << "Boost test fail  check_characteristic_function_of_diagram : " << std::endl;
-      std::cerr << char_funct_diag[i] << " " << template_char_funct_diag[i] << std::endl;
-      std::cerr << fabs(char_funct_diag[i] - template_char_funct_diag[i]) << std::endl;
-      std::cerr << 0.0001 << std::endl;
-      //getchar();
-    }
-    BOOST_CHECK(fabs(char_funct_diag[i] - template_char_funct_diag[i]) <= 0.0001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(char_funct_diag[i], template_char_funct_diag[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 
@@ -174,110 +165,110 @@ BOOST_AUTO_TEST_CASE(check_cumulative_characteristic_function_of_diagram) {
   template_char_funct_diag_cumul.push_back(9.48386);
 
   for (size_t i = 0; i != cumul_char_funct_diag.size(); ++i) {
-    // cout << cumul_char_funct_diag[i] << std::endl;
-    BOOST_CHECK(fabs(cumul_char_funct_diag[i] - template_char_funct_diag_cumul[i]) <= 0.0001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(cumul_char_funct_diag[i], template_char_funct_diag_cumul[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 
 BOOST_AUTO_TEST_CASE(check_compute_persistent_betti_numbers) {
   Persistence_intervals p("data/file_with_diagram");
-  std::vector<std::pair<double, double> > pbns;
-  pbns.push_back(std::pair<double, double>(0.0290362, 1));
-  pbns.push_back(std::pair<double, double>(0.0307676, 2));
-  pbns.push_back(std::pair<double, double>(0.0366312, 3));
-  pbns.push_back(std::pair<double, double>(0.0544614, 4));
-  pbns.push_back(std::pair<double, double>(0.0920033, 5));
-  pbns.push_back(std::pair<double, double>(0.104599, 6));
-  pbns.push_back(std::pair<double, double>(0.114718, 7));
-  pbns.push_back(std::pair<double, double>(0.117379, 8));
-  pbns.push_back(std::pair<double, double>(0.123493, 9));
-  pbns.push_back(std::pair<double, double>(0.133638, 10));
-  pbns.push_back(std::pair<double, double>(0.137798, 9));
-  pbns.push_back(std::pair<double, double>(0.149798, 10));
-  pbns.push_back(std::pair<double, double>(0.155421, 11));
-  pbns.push_back(std::pair<double, double>(0.158443, 12));
-  pbns.push_back(std::pair<double, double>(0.176956, 13));
-  pbns.push_back(std::pair<double, double>(0.183234, 12));
-  pbns.push_back(std::pair<double, double>(0.191069, 13));
-  pbns.push_back(std::pair<double, double>(0.191333, 14));
-  pbns.push_back(std::pair<double, double>(0.191836, 15));
-  pbns.push_back(std::pair<double, double>(0.192675, 16));
-  pbns.push_back(std::pair<double, double>(0.208564, 17));
-  pbns.push_back(std::pair<double, double>(0.218425, 18));
-  pbns.push_back(std::pair<double, double>(0.219902, 17));
-  pbns.push_back(std::pair<double, double>(0.23233, 16));
-  pbns.push_back(std::pair<double, double>(0.234558, 17));
-  pbns.push_back(std::pair<double, double>(0.237166, 16));
-  pbns.push_back(std::pair<double, double>(0.247352, 17));
-  pbns.push_back(std::pair<double, double>(0.267421, 18));
-  pbns.push_back(std::pair<double, double>(0.268093, 19));
-  pbns.push_back(std::pair<double, double>(0.278734, 18));
-  pbns.push_back(std::pair<double, double>(0.284722, 19));
-  pbns.push_back(std::pair<double, double>(0.284998, 20));
-  pbns.push_back(std::pair<double, double>(0.294069, 21));
-  pbns.push_back(std::pair<double, double>(0.306293, 22));
-  pbns.push_back(std::pair<double, double>(0.322361, 21));
-  pbns.push_back(std::pair<double, double>(0.323152, 22));
-  pbns.push_back(std::pair<double, double>(0.371021, 23));
-  pbns.push_back(std::pair<double, double>(0.372395, 24));
-  pbns.push_back(std::pair<double, double>(0.387744, 25));
-  pbns.push_back(std::pair<double, double>(0.435537, 26));
-  pbns.push_back(std::pair<double, double>(0.462911, 25));
-  pbns.push_back(std::pair<double, double>(0.483569, 26));
-  pbns.push_back(std::pair<double, double>(0.489209, 25));
-  pbns.push_back(std::pair<double, double>(0.517115, 24));
-  pbns.push_back(std::pair<double, double>(0.522197, 23));
-  pbns.push_back(std::pair<double, double>(0.532665, 22));
-  pbns.push_back(std::pair<double, double>(0.545262, 23));
-  pbns.push_back(std::pair<double, double>(0.587227, 22));
-  pbns.push_back(std::pair<double, double>(0.593036, 23));
-  pbns.push_back(std::pair<double, double>(0.602647, 24));
-  pbns.push_back(std::pair<double, double>(0.605044, 25));
-  pbns.push_back(std::pair<double, double>(0.621962, 24));
-  pbns.push_back(std::pair<double, double>(0.629449, 23));
-  pbns.push_back(std::pair<double, double>(0.636719, 22));
-  pbns.push_back(std::pair<double, double>(0.64957, 21));
-  pbns.push_back(std::pair<double, double>(0.650781, 22));
-  pbns.push_back(std::pair<double, double>(0.654951, 23));
-  pbns.push_back(std::pair<double, double>(0.683489, 24));
-  pbns.push_back(std::pair<double, double>(0.687172, 23));
-  pbns.push_back(std::pair<double, double>(0.69703, 22));
-  pbns.push_back(std::pair<double, double>(0.701174, 21));
-  pbns.push_back(std::pair<double, double>(0.717623, 22));
-  pbns.push_back(std::pair<double, double>(0.722023, 21));
-  pbns.push_back(std::pair<double, double>(0.722298, 20));
-  pbns.push_back(std::pair<double, double>(0.725347, 19));
-  pbns.push_back(std::pair<double, double>(0.73071, 18));
-  pbns.push_back(std::pair<double, double>(0.758355, 17));
-  pbns.push_back(std::pair<double, double>(0.770913, 18));
-  pbns.push_back(std::pair<double, double>(0.790833, 17));
-  pbns.push_back(std::pair<double, double>(0.821211, 16));
-  pbns.push_back(std::pair<double, double>(0.849305, 17));
-  pbns.push_back(std::pair<double, double>(0.853669, 16));
-  pbns.push_back(std::pair<double, double>(0.866659, 15));
-  pbns.push_back(std::pair<double, double>(0.872896, 16));
-  pbns.push_back(std::pair<double, double>(0.889597, 15));
-  pbns.push_back(std::pair<double, double>(0.900231, 14));
-  pbns.push_back(std::pair<double, double>(0.903847, 13));
-  pbns.push_back(std::pair<double, double>(0.906299, 12));
-  pbns.push_back(std::pair<double, double>(0.910852, 11));
-  pbns.push_back(std::pair<double, double>(0.93453, 10));
-  pbns.push_back(std::pair<double, double>(0.944757, 9));
-  pbns.push_back(std::pair<double, double>(0.947812, 8));
-  pbns.push_back(std::pair<double, double>(0.959154, 7));
-  pbns.push_back(std::pair<double, double>(0.975654, 6));
-  pbns.push_back(std::pair<double, double>(0.976719, 5));
-  pbns.push_back(std::pair<double, double>(0.977343, 4));
-  pbns.push_back(std::pair<double, double>(0.980129, 3));
-  pbns.push_back(std::pair<double, double>(0.987842, 2));
-  pbns.push_back(std::pair<double, double>(0.990127, 1));
-  pbns.push_back(std::pair<double, double>(0.994537, 0));
+  std::vector<std::pair<double, size_t> > pbns;
+  pbns.push_back(std::pair<double, size_t>(0.0290362, 1));
+  pbns.push_back(std::pair<double, size_t>(0.0307676, 2));
+  pbns.push_back(std::pair<double, size_t>(0.0366312, 3));
+  pbns.push_back(std::pair<double, size_t>(0.0544614, 4));
+  pbns.push_back(std::pair<double, size_t>(0.0920033, 5));
+  pbns.push_back(std::pair<double, size_t>(0.104599, 6));
+  pbns.push_back(std::pair<double, size_t>(0.114718, 7));
+  pbns.push_back(std::pair<double, size_t>(0.117379, 8));
+  pbns.push_back(std::pair<double, size_t>(0.123493, 9));
+  pbns.push_back(std::pair<double, size_t>(0.133638, 10));
+  pbns.push_back(std::pair<double, size_t>(0.137798, 9));
+  pbns.push_back(std::pair<double, size_t>(0.149798, 10));
+  pbns.push_back(std::pair<double, size_t>(0.155421, 11));
+  pbns.push_back(std::pair<double, size_t>(0.158443, 12));
+  pbns.push_back(std::pair<double, size_t>(0.176956, 13));
+  pbns.push_back(std::pair<double, size_t>(0.183234, 12));
+  pbns.push_back(std::pair<double, size_t>(0.191069, 13));
+  pbns.push_back(std::pair<double, size_t>(0.191333, 14));
+  pbns.push_back(std::pair<double, size_t>(0.191836, 15));
+  pbns.push_back(std::pair<double, size_t>(0.192675, 16));
+  pbns.push_back(std::pair<double, size_t>(0.208564, 17));
+  pbns.push_back(std::pair<double, size_t>(0.218425, 18));
+  pbns.push_back(std::pair<double, size_t>(0.219902, 17));
+  pbns.push_back(std::pair<double, size_t>(0.23233, 16));
+  pbns.push_back(std::pair<double, size_t>(0.234558, 17));
+  pbns.push_back(std::pair<double, size_t>(0.237166, 16));
+  pbns.push_back(std::pair<double, size_t>(0.247352, 17));
+  pbns.push_back(std::pair<double, size_t>(0.267421, 18));
+  pbns.push_back(std::pair<double, size_t>(0.268093, 19));
+  pbns.push_back(std::pair<double, size_t>(0.278734, 18));
+  pbns.push_back(std::pair<double, size_t>(0.284722, 19));
+  pbns.push_back(std::pair<double, size_t>(0.284998, 20));
+  pbns.push_back(std::pair<double, size_t>(0.294069, 21));
+  pbns.push_back(std::pair<double, size_t>(0.306293, 22));
+  pbns.push_back(std::pair<double, size_t>(0.322361, 21));
+  pbns.push_back(std::pair<double, size_t>(0.323152, 22));
+  pbns.push_back(std::pair<double, size_t>(0.371021, 23));
+  pbns.push_back(std::pair<double, size_t>(0.372395, 24));
+  pbns.push_back(std::pair<double, size_t>(0.387744, 25));
+  pbns.push_back(std::pair<double, size_t>(0.435537, 26));
+  pbns.push_back(std::pair<double, size_t>(0.462911, 25));
+  pbns.push_back(std::pair<double, size_t>(0.483569, 26));
+  pbns.push_back(std::pair<double, size_t>(0.489209, 25));
+  pbns.push_back(std::pair<double, size_t>(0.517115, 24));
+  pbns.push_back(std::pair<double, size_t>(0.522197, 23));
+  pbns.push_back(std::pair<double, size_t>(0.532665, 22));
+  pbns.push_back(std::pair<double, size_t>(0.545262, 23));
+  pbns.push_back(std::pair<double, size_t>(0.587227, 22));
+  pbns.push_back(std::pair<double, size_t>(0.593036, 23));
+  pbns.push_back(std::pair<double, size_t>(0.602647, 24));
+  pbns.push_back(std::pair<double, size_t>(0.605044, 25));
+  pbns.push_back(std::pair<double, size_t>(0.621962, 24));
+  pbns.push_back(std::pair<double, size_t>(0.629449, 23));
+  pbns.push_back(std::pair<double, size_t>(0.636719, 22));
+  pbns.push_back(std::pair<double, size_t>(0.64957, 21));
+  pbns.push_back(std::pair<double, size_t>(0.650781, 22));
+  pbns.push_back(std::pair<double, size_t>(0.654951, 23));
+  pbns.push_back(std::pair<double, size_t>(0.683489, 24));
+  pbns.push_back(std::pair<double, size_t>(0.687172, 23));
+  pbns.push_back(std::pair<double, size_t>(0.69703, 22));
+  pbns.push_back(std::pair<double, size_t>(0.701174, 21));
+  pbns.push_back(std::pair<double, size_t>(0.717623, 22));
+  pbns.push_back(std::pair<double, size_t>(0.722023, 21));
+  pbns.push_back(std::pair<double, size_t>(0.722298, 20));
+  pbns.push_back(std::pair<double, size_t>(0.725347, 19));
+  pbns.push_back(std::pair<double, size_t>(0.73071, 18));
+  pbns.push_back(std::pair<double, size_t>(0.758355, 17));
+  pbns.push_back(std::pair<double, size_t>(0.770913, 18));
+  pbns.push_back(std::pair<double, size_t>(0.790833, 17));
+  pbns.push_back(std::pair<double, size_t>(0.821211, 16));
+  pbns.push_back(std::pair<double, size_t>(0.849305, 17));
+  pbns.push_back(std::pair<double, size_t>(0.853669, 16));
+  pbns.push_back(std::pair<double, size_t>(0.866659, 15));
+  pbns.push_back(std::pair<double, size_t>(0.872896, 16));
+  pbns.push_back(std::pair<double, size_t>(0.889597, 15));
+  pbns.push_back(std::pair<double, size_t>(0.900231, 14));
+  pbns.push_back(std::pair<double, size_t>(0.903847, 13));
+  pbns.push_back(std::pair<double, size_t>(0.906299, 12));
+  pbns.push_back(std::pair<double, size_t>(0.910852, 11));
+  pbns.push_back(std::pair<double, size_t>(0.93453, 10));
+  pbns.push_back(std::pair<double, size_t>(0.944757, 9));
+  pbns.push_back(std::pair<double, size_t>(0.947812, 8));
+  pbns.push_back(std::pair<double, size_t>(0.959154, 7));
+  pbns.push_back(std::pair<double, size_t>(0.975654, 6));
+  pbns.push_back(std::pair<double, size_t>(0.976719, 5));
+  pbns.push_back(std::pair<double, size_t>(0.977343, 4));
+  pbns.push_back(std::pair<double, size_t>(0.980129, 3));
+  pbns.push_back(std::pair<double, size_t>(0.987842, 2));
+  pbns.push_back(std::pair<double, size_t>(0.990127, 1));
+  pbns.push_back(std::pair<double, size_t>(0.994537, 0));
 
   std::vector<std::pair<double, size_t> > pbns_new = p.compute_persistent_betti_numbers();
   for (size_t i = 0; i != pbns.size(); ++i) {
-    // cout << pbns_new[i].first << "," << pbns_new[i].second << std::endl;
-    BOOST_CHECK(fabs(pbns[i].first - pbns_new[i].first) <= epsilon);
-    BOOST_CHECK(fabs(pbns[i].second - pbns_new[i].second) <= epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(pbns[i].first, pbns_new[i].first,
+                                    Gudhi::Persistence_representations::epsi);
+    BOOST_CHECK(pbns[i].second == pbns_new[i].second);
   }
 }
 
@@ -297,7 +288,7 @@ BOOST_AUTO_TEST_CASE(check_k_n_n) {
   knn_template.push_back(0.786945);
 
   for (size_t i = 0; i != knn.size(); ++i) {
-    // cout << knn[i] << std::endl;
-    BOOST_CHECK(fabs(knn[i] - knn_template[i]) <= 0.000005);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(knn[i], knn_template[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
diff --git a/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp b/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
index 7b70eee3..631e4d70 100644
--- a/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
+++ b/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
@@ -24,8 +24,9 @@
 #define BOOST_TEST_MODULE "Persistence_intervals_with_distances_test"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
-#include "gudhi/Persistence_intervals_with_distances.h"
-#include "gudhi/common_persistence_representations.h"
+#include <gudhi/Persistence_intervals_with_distances.h>
+#include <gudhi/common_persistence_representations.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
@@ -38,9 +39,7 @@ BOOST_AUTO_TEST_CASE(check_bottleneck_distances_computation) {
 
   double dist = p.distance(q);
 
-  // std::cout << "dist : " << dist << std::endl;
-
-  BOOST_CHECK(almost_equal(dist, 0.389043));
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(dist, 0.389043, Gudhi::Persistence_representations::epsi);
 }
 
 BOOST_AUTO_TEST_CASE(check_default_parameters_in_distance) {
@@ -51,11 +50,7 @@ BOOST_AUTO_TEST_CASE(check_default_parameters_in_distance) {
   double max_parameter_distance = p.distance(q, std::numeric_limits<double>::max());
   double inf_parameter_distance = p.distance(q, std::numeric_limits<double>::infinity());
 
-  // std::cout << "default_parameter_distance : " << default_parameter_distance << std::endl;
-  // std::cout << "max_parameter_distance : " << max_parameter_distance << std::endl;
-  // std::cout << "inf_parameter_distance : " << inf_parameter_distance << std::endl;
-
-  BOOST_CHECK(default_parameter_distance == max_parameter_distance);
-  BOOST_CHECK(inf_parameter_distance == max_parameter_distance);
-  BOOST_CHECK(inf_parameter_distance == max_parameter_distance);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(default_parameter_distance, max_parameter_distance);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(inf_parameter_distance, max_parameter_distance);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(inf_parameter_distance, max_parameter_distance);
 }
diff --git a/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp b/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
index 6b1608fe..8e2808d0 100644
--- a/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
+++ b/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
@@ -25,12 +25,15 @@
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_landscape_on_grid.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+double epsilon = 0.0005;
+
 BOOST_AUTO_TEST_CASE(check_construction_of_landscape) {
   Persistence_landscape_on_grid l("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
   l.print_to_file("landscape_from_file_with_diagram_1");
@@ -53,16 +56,14 @@ BOOST_AUTO_TEST_CASE(check_construction_of_landscape_using_only_ten_levels) {
     std::vector<double> v2 = g.vectorize(level);
     BOOST_CHECK(v1.size() == v2.size());
     for (size_t i = 0; i != v1.size(); ++i) {
-      BOOST_CHECK(v1[i] == v2[i]);
+      GUDHI_TEST_FLOAT_EQUALITY_CHECK(v1[i], v2[i]);
     }
   }
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_integrals) {
   Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
-  double integral = p.compute_integral_of_landscape();
-  // cerr << "integral : " << integral << endl;getchar();
-  BOOST_CHECK(fabs(integral - 27.343) <= 0.00005);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(), 27.343, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) {
@@ -92,9 +93,8 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly)
   integrals_fir_different_levels.push_back(0.202633);
 
   for (size_t level = 0; level != integrals_fir_different_levels.size(); ++level) {
-    double integral = p.compute_integral_of_landscape(level);
-    // cerr << integral << endl;
-    BOOST_CHECK(fabs(integral - integrals_fir_different_levels[level]) <= 0.00005);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(level), integrals_fir_different_levels[level],
+                                    epsilon);
   }
 }
 
@@ -109,9 +109,8 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) {
   integrals_fir_different_powers.push_back(0.23011);
 
   for (size_t power = 0; power != 5; ++power) {
-    double integral = p.compute_integral_of_landscape(power);
-    // cerr << integral << endl;
-    BOOST_CHECK(fabs(integral - integrals_fir_different_powers[power]) <= 0.00001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(power), integrals_fir_different_powers[power],
+                                    epsilon);
   }
 }
 
@@ -145,8 +144,8 @@ BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) {
   double x = 0.0012321;
   double dx = 0.05212;
   for (size_t i = 0; i != 10; ++i) {
-    BOOST_CHECK(almost_equal(p.compute_value_at_a_given_point(0, x), results_level_0[i]));
-    BOOST_CHECK(almost_equal(p.compute_value_at_a_given_point(10, x), results_level_10[i]));
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(0, x), results_level_0[i], epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(10, x), results_level_10[i], epsilon);
     x += dx;
   }
 }
@@ -179,22 +178,14 @@ BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) {
   Persistence_landscape_on_grid second("data/file_with_diagram_2", 0., 1., 100);
   Persistence_landscape_on_grid sum = p + second;
 
-  // cerr << p.compute_maximum() << endl;
-  // cerr <<  p.compute_norm_of_landscape(1) << endl;
-  // cerr << p.compute_norm_of_landscape(2) << endl;
-  // cerr <<  p.compute_norm_of_landscape(3) << endl;
-  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,1) << endl;
-  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,2) << endl;
-  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,std::numeric_limits<double>::max())  << endl;
-
-  BOOST_CHECK(fabs(p.compute_maximum() - 0.46) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(1) - 27.3373) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(2) - 1.84143) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(3) - 0.927067) <= 0.00001);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, 1) - 16.8519) <= 0.00005);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, 2) - 1.44542) <= 0.00001);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, std::numeric_limits<double>::max()) - 0.45) <=
-              0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_maximum(), 0.46, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(1), 27.3373 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(2), 1.84143 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(3), 0.927067, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes_on_grid(p, sum, 1), 16.8519, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes_on_grid(p, sum, 2), 1.44542, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes_on_grid(p, sum, std::numeric_limits<double>::max()),
+                                  0.45, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
@@ -209,7 +200,7 @@ BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
   double dist_numeric_limit_max = p.distance(q, std::numeric_limits<double>::max());
   double dist_infinity = p.distance(q, std::numeric_limits<double>::infinity());
 
-  BOOST_CHECK(dist_numeric_limit_max == dist_infinity);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(dist_numeric_limit_max, dist_infinity);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
@@ -226,16 +217,15 @@ BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
 BOOST_AUTO_TEST_CASE(check_computations_of_distances) {
   Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 10000);
   Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 10000);
-  BOOST_CHECK(fabs(p.distance(q) - 25.5779) <= 0.00005);
-  BOOST_CHECK(fabs(p.distance(q, 2) - 2.04891) <= 0.00001);
-  BOOST_CHECK(fabs(p.distance(q, std::numeric_limits<double>::max()) - 0.359) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q), 25.5779, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q, 2), 2.04891, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q, std::numeric_limits<double>::max()), 0.359, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product) {
   Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 10000);
   Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 10000);
-  // std::cerr << p.compute_scalar_product( q ) << std::endl;
-  BOOST_CHECK(almost_equal(p.compute_scalar_product(q), 0.754367));
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(q), 0.754367, epsilon);
 }
 
 // Below I am storing the code used to generate tests for that functionality.
diff --git a/src/Persistence_representations/test/persistence_lanscapes_test.cpp b/src/Persistence_representations/test/persistence_lanscapes_test.cpp
index 81adb6fa..e7267bec 100644
--- a/src/Persistence_representations/test/persistence_lanscapes_test.cpp
+++ b/src/Persistence_representations/test/persistence_lanscapes_test.cpp
@@ -25,6 +25,7 @@
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_landscape.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 #include <limits>
@@ -32,7 +33,7 @@
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-double epsilon = 0.0000005;
+double epsilon = 0.0005;
 
 BOOST_AUTO_TEST_CASE(check_construction_of_landscape) {	
   std::vector<std::pair<double, double> > diag =
@@ -57,9 +58,7 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals) {
   std::vector<std::pair<double, double> > diag =
       read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
   Persistence_landscape p(diag);
-  double integral = p.compute_integral_of_landscape();
-  // cerr << integral  << " " << 2.34992 << endl;
-  BOOST_CHECK(fabs(integral - 2.34992) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(), 2.34992, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) {
@@ -67,37 +66,37 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly)
       read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
   Persistence_landscape p(diag);
 
-  std::vector<double> integrals_fir_different_levels;
-  integrals_fir_different_levels.push_back(0.216432);
-  integrals_fir_different_levels.push_back(0.204763);
-  integrals_fir_different_levels.push_back(0.188793);
-  integrals_fir_different_levels.push_back(0.178856);
-  integrals_fir_different_levels.push_back(0.163142);
-  integrals_fir_different_levels.push_back(0.155015);
-  integrals_fir_different_levels.push_back(0.143046);
-  integrals_fir_different_levels.push_back(0.133765);
-  integrals_fir_different_levels.push_back(0.123531);
-  integrals_fir_different_levels.push_back(0.117393);
-  integrals_fir_different_levels.push_back(0.111269);
-  integrals_fir_different_levels.push_back(0.104283);
-  integrals_fir_different_levels.push_back(0.0941308);
-  integrals_fir_different_levels.push_back(0.0811208);
-  integrals_fir_different_levels.push_back(0.0679001);
-  integrals_fir_different_levels.push_back(0.0580801);
-  integrals_fir_different_levels.push_back(0.0489647);
-  integrals_fir_different_levels.push_back(0.0407936);
-  integrals_fir_different_levels.push_back(0.0342599);
-  integrals_fir_different_levels.push_back(0.02896);
-  integrals_fir_different_levels.push_back(0.0239881);
-  integrals_fir_different_levels.push_back(0.0171792);
-  integrals_fir_different_levels.push_back(0.0071511);
-  integrals_fir_different_levels.push_back(0.00462067);
-  integrals_fir_different_levels.push_back(0.00229033);
-  integrals_fir_different_levels.push_back(0.000195296);
+  std::vector<double> integrals_for_different_levels;
+  integrals_for_different_levels.push_back(0.216432);
+  integrals_for_different_levels.push_back(0.204763);
+  integrals_for_different_levels.push_back(0.188793);
+  integrals_for_different_levels.push_back(0.178856);
+  integrals_for_different_levels.push_back(0.163142);
+  integrals_for_different_levels.push_back(0.155015);
+  integrals_for_different_levels.push_back(0.143046);
+  integrals_for_different_levels.push_back(0.133765);
+  integrals_for_different_levels.push_back(0.123531);
+  integrals_for_different_levels.push_back(0.117393);
+  integrals_for_different_levels.push_back(0.111269);
+  integrals_for_different_levels.push_back(0.104283);
+  integrals_for_different_levels.push_back(0.0941308);
+  integrals_for_different_levels.push_back(0.0811208);
+  integrals_for_different_levels.push_back(0.0679001);
+  integrals_for_different_levels.push_back(0.0580801);
+  integrals_for_different_levels.push_back(0.0489647);
+  integrals_for_different_levels.push_back(0.0407936);
+  integrals_for_different_levels.push_back(0.0342599);
+  integrals_for_different_levels.push_back(0.02896);
+  integrals_for_different_levels.push_back(0.0239881);
+  integrals_for_different_levels.push_back(0.0171792);
+  integrals_for_different_levels.push_back(0.0071511);
+  integrals_for_different_levels.push_back(0.00462067);
+  integrals_for_different_levels.push_back(0.00229033);
+  integrals_for_different_levels.push_back(0.000195296);
 
   for (size_t level = 0; level != p.size(); ++level) {
-    double integral = p.compute_integral_of_a_level_of_a_landscape(level);
-    BOOST_CHECK(fabs(integral - integrals_fir_different_levels[level]) <= 0.00001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_a_level_of_a_landscape(level),
+                                    integrals_for_different_levels[level], epsilon);
   }
 }
 
@@ -106,16 +105,16 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) {
       read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
   Persistence_landscape p(diag);
 
-  std::vector<double> integrals_fir_different_powers;
-  integrals_fir_different_powers.push_back(17.1692);
-  integrals_fir_different_powers.push_back(2.34992);
-  integrals_fir_different_powers.push_back(0.49857);
-  integrals_fir_different_powers.push_back(0.126405);
-  integrals_fir_different_powers.push_back(0.0355235);
+  std::vector<double> integrals_for_different_powers;
+  integrals_for_different_powers.push_back(17.1692);
+  integrals_for_different_powers.push_back(2.34992);
+  integrals_for_different_powers.push_back(0.49857);
+  integrals_for_different_powers.push_back(0.126405);
+  integrals_for_different_powers.push_back(0.0355235);
 
   for (size_t power = 0; power != 5; ++power) {
-    double integral = p.compute_integral_of_landscape((double)power);
-    BOOST_CHECK(fabs(integral - integrals_fir_different_powers[power]) <= 0.00005);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape((double)power),
+                                    integrals_for_different_powers[power], epsilon);
   }
 }
 
@@ -124,18 +123,18 @@ BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) {
       read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
   Persistence_landscape p(diag);
 
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.0)) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.1) - 0.0692324) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.2) - 0.163369) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.3) - 0.217115) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.0)) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.1) - 0.0633688) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.2) - 0.122361) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.3) - 0.195401) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.0)) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.1) - 0.0455386) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.2) - 0.0954012) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.3) - 0.185282) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(1, 0.0), 0.       , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(1, 0.1), 0.0692324, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(1, 0.2), 0.163369 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(1, 0.3), 0.217115 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(2, 0.0), 0.       , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(2, 0.1), 0.0633688, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(2, 0.2), 0.122361 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(2, 0.3), 0.195401 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(3, 0.0), 0.       , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(3, 0.1), 0.0455386, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(3, 0.2), 0.0954012, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(3, 0.3), 0.185282 , epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_sum_differences_and_multiplications) {
@@ -171,13 +170,14 @@ BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) {
   second.load_landscape_from_file("data/file_with_landscape_from_file_with_diagram_1");
   Persistence_landscape sum = p + second;
 
-  BOOST_CHECK(fabs(p.compute_maximum() - 0.431313) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(1) - 2.34992) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(2) - 0.706095) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(3) - 0.501867) <= 0.00001);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes(p, sum, 1) - 27.9323) <= 0.00005);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes(p, sum, 2) - 2.35199) <= 0.00001);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes(p, sum, std::numeric_limits<double>::max()) - 0.464478) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_maximum()           , 0.431313, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(1), 2.34992 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(2), 0.706095, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(3), 0.501867, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes(p, sum, 1), 27.9323, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes(p, sum, 2), 2.35199, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes(p, sum, std::numeric_limits<double>::max()),
+                                  0.464478, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
@@ -192,7 +192,7 @@ BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
   double dist_numeric_limit_max = p.distance(q, std::numeric_limits<double>::max());
   double dist_infinity = p.distance(q, std::numeric_limits<double>::infinity());
 
-  BOOST_CHECK(dist_numeric_limit_max == dist_infinity);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(dist_numeric_limit_max, dist_infinity);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
@@ -217,13 +217,9 @@ BOOST_AUTO_TEST_CASE(check_computations_of_distances) {
   std::vector<std::pair<double, double> > diag2 =
       read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
   Persistence_landscape q(diag2);
-  std::cout << "p.distance(q) = " << p.distance(q) << std::endl;
-  BOOST_CHECK(fabs(p.distance(q) - 25.5824) <= 0.00005);
-  std::cout << "p.distance(q, 2) = " << p.distance(q, 2) << std::endl;
-  BOOST_CHECK(fabs(p.distance(q, 2) - 2.1264) <= 0.0001);
-  std::cout << "p.distance(q, std::numeric_limits<double>::max()) = " <<
-               p.distance(q, std::numeric_limits<double>::max()) << std::endl;
-  BOOST_CHECK(fabs(p.distance(q, std::numeric_limits<double>::max()) - 0.359068) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q), 25.5824, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q, 2), 2.1264, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q, std::numeric_limits<double>::max()), 0.359068, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product) {
@@ -233,7 +229,7 @@ BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product) {
   std::vector<std::pair<double, double> > diag2 =
       read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
   Persistence_landscape q(diag2);
-  BOOST_CHECK(fabs(p.compute_scalar_product(q) - 0.754498) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(q), 0.754498, epsilon);
 }
 
 
diff --git a/src/Persistence_representations/test/read_persistence_from_file_test.cpp b/src/Persistence_representations/test/read_persistence_from_file_test.cpp
index 76d7cdb0..afdc822c 100644
--- a/src/Persistence_representations/test/read_persistence_from_file_test.cpp
+++ b/src/Persistence_representations/test/read_persistence_from_file_test.cpp
@@ -21,7 +21,7 @@
  */
 
 #define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE "Persistence_representations"
+#define BOOST_TEST_MODULE "read_persistence_from_file_test"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/read_persistence_from_file.h>
 
diff --git a/src/Persistence_representations/test/vector_representation_test.cpp b/src/Persistence_representations/test/vector_representation_test.cpp
index 3f3e2abe..7e4ce3ee 100644
--- a/src/Persistence_representations/test/vector_representation_test.cpp
+++ b/src/Persistence_representations/test/vector_representation_test.cpp
@@ -26,7 +26,7 @@
 #include <iostream>
 
 #define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE "Persistence_representations"
+#define BOOST_TEST_MODULE "vector_representation_test"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include <vector>