diff --git a/GridContainer/tests/src/GridContainer_test.cpp b/GridContainer/tests/src/GridContainer_test.cpp

index 9ca75c0..f4c3814 100644

--- a/GridContainer/tests/src/GridContainer_test.cpp

+++ b/GridContainer/tests/src/GridContainer_test.cpp

@@ -1,22 +1,22 @@

 /*

- * Copyright (C) 2012-2020 Euclid Science Ground Segment    

- *  

+ * Copyright (C) 2012-2020 Euclid Science Ground Segment

+ *

  * This library is free software; you can redistribute it and/or modify it under

- * the terms of the GNU Lesser General Public License as published by the Free 

- * Software Foundation; either version 3.0 of the License, or (at your option)  

- * any later version.  

- *  

- * This library is distributed in the hope that it will be useful, but WITHOUT 

+ * the terms of the GNU Lesser General Public License as published by the Free

+ * Software Foundation; either version 3.0 of the License, or (at your option)

+ * any later version.

+ *

+ * This library is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

- * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more  

- * details.  

- *  

- * You should have received a copy of the GNU Lesser General Public License 

+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more

+ * details.

+ *

+ * You should have received a copy of the GNU Lesser General Public License

  * along with this library; if not, write to the Free Software Foundation, Inc.,

- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  */

- 

- /** 

+

+ /**

  * @file GridContainer_test.cpp

  * @date July 4, 2014

  * @author Nikolaos Apostolakos

@@ -25,8 +25,11 @@

 #include <vector>

 #include <boost/test/unit_test.hpp>

 #include <boost/test/test_tools.hpp>

+#include <ElementsKernel/Real.h>

 #include "GridContainer/GridContainer.h"

+using Elements::isEqual;

+

 struct GridContainer_Fixture {

   typedef Euclid::GridContainer::GridContainer<std::vector<double>, int, int, int, int> GridContainerType;

   typedef Euclid::GridContainer::GridAxis<int> IntAxis;

@@ -45,13 +48,13 @@ BOOST_AUTO_TEST_SUITE (GridContainer_test)

 //-----------------------------------------------------------------------------

 // Test construction with GridAxis objects

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(GridAxisConstructor, GridContainer_Fixture) {

-  

+

   // When

   GridContainerType result_grid {axis1, axis2, axis3, axis4};

   auto& result_axes_tuple = result_grid.getAxesTuple();

-  

+

   // Then

   BOOST_CHECK_EQUAL(result_grid.size(), total_size);

   for (auto& value : result_grid) {

@@ -73,19 +76,19 @@ BOOST_FIXTURE_TEST_CASE(GridAxisConstructor, GridContainer_Fixture) {

   BOOST_CHECK_EQUAL_COLLECTIONS(

       std::get<3>(result_axes_tuple).begin(), std::get<3>(result_axes_tuple).end(),

       axis4.begin(), axis4.end());

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test construction with GridAxis tuple

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(GridAxisTupleonstructor, GridContainer_Fixture) {

-  

+

   // When

   GridContainerType result_grid {axes_tuple};

   auto& result_axes_tuple = result_grid.getAxesTuple();

-  

+

   // Then

   BOOST_CHECK_EQUAL(result_grid.size(), total_size);

   for (auto& value : result_grid) {

@@ -107,137 +110,137 @@ BOOST_FIXTURE_TEST_CASE(GridAxisTupleonstructor, GridContainer_Fixture) {

   BOOST_CHECK_EQUAL_COLLECTIONS(

       std::get<3>(result_axes_tuple).begin(), std::get<3>(result_axes_tuple).end(),

       axis4.begin(), axis4.end());

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the rank method

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(rank, GridContainer_Fixture) {

-  

+

   // When

   GridContainerType grid {axes_tuple};

-  

+

   // Then

   BOOST_CHECK_EQUAL(grid.axisNumber(), 4u);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the getAxis method

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(getAxis, GridContainer_Fixture) {

-  

+

   // When

   GridContainerType grid {axes_tuple};

-  

+

   // Then

   BOOST_CHECK_EQUAL(grid.getAxis<0>().name(), axis1.name());

   BOOST_CHECK_EQUAL(grid.getAxis<1>().name(), axis2.name());

   BOOST_CHECK_EQUAL(grid.getAxis<2>().name(), axis3.name());

   BOOST_CHECK_EQUAL(grid.getAxis<3>().name(), axis4.name());

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the size method

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(size, GridContainer_Fixture) {

-  

+

   // When

   GridContainerType grid {axes_tuple};

-  

+

   // Then

   BOOST_CHECK_EQUAL(grid.size(), total_size);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the parenthesis operator

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(parenthesisOperator, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   double custom_value = 0;

   for (auto& cell : grid) {

     custom_value += 0.1;

     cell = custom_value;

   }

-  

+

   // Then

   double expected_value {0};

-  for (size_t coord4=0; coord4

-    for (size_t coord3=0; coord3

-      for (size_t coord2=0; coord2

-        for (size_t coord1=0; coord1

+  for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

+    for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

+      for (size_t coord2 = 0; coord2 < axis2.size(); ++coord2) {

+        for (size_t coord1 = 0; coord1 < axis1.size(); ++coord1) {

           expected_value += 0.1;

-          BOOST_CHECK_EQUAL(grid(coord1, coord2, coord3, coord4), expected_value);

-          BOOST_CHECK_EQUAL(const_grid(coord1, coord2, coord3, coord4), expected_value);

+          BOOST_CHECK_CLOSE(grid(coord1, coord2, coord3, coord4), expected_value, 1e-6);

+          BOOST_CHECK_CLOSE(const_grid(coord1, coord2, coord3, coord4), expected_value, 1e-6);

         }

       }

     }

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the at method

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(at, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   double custom_value = 0;

   for (auto& cell : grid) {

     custom_value += 0.1;

     cell = custom_value;

   }

-  

+

   // Then

   double expected_value {0};

-  for (size_t coord4=0; coord4

-    for (size_t coord3=0; coord3

-      for (size_t coord2=0; coord2

-        for (size_t coord1=0; coord1

+  for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

+    for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

+      for (size_t coord2 = 0; coord2 < axis2.size(); ++coord2) {

+        for (size_t coord1 = 0; coord1 < axis1.size(); ++coord1) {

           expected_value += 0.1;

-          BOOST_CHECK_EQUAL(grid.at(coord1, coord2, coord3, coord4), expected_value);

-          BOOST_CHECK_EQUAL(const_grid.at(coord1, coord2, coord3, coord4), expected_value);

+          BOOST_CHECK_CLOSE(grid.at(coord1, coord2, coord3, coord4), expected_value, 1e-6);

+          BOOST_CHECK_CLOSE(const_grid.at(coord1, coord2, coord3, coord4), expected_value, 1e-6);

         }

       }

     }

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the at method throws for out of bound

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(atOutOfBound, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   double custom_value = 0;

   for (auto& cell : grid) {

     custom_value += 0.1;

     cell = custom_value;

   }

-  

+

   // Then

   BOOST_CHECK_THROW(grid.at(axis1.size(), 0, 0, 0), Elements::Exception);

   BOOST_CHECK_THROW(grid.at(0, axis2.size(), 0, 0), Elements::Exception);

@@ -247,54 +250,54 @@ BOOST_FIXTURE_TEST_CASE(atOutOfBound, GridContainer_Fixture) {

   BOOST_CHECK_THROW(const_grid.at(0, axis2.size(), 0, 0), Elements::Exception);

   BOOST_CHECK_THROW(const_grid.at(0, 0, axis3.size(), 0), Elements::Exception);

   BOOST_CHECK_THROW(const_grid.at(0, 0, 0, axis4.size()), Elements::Exception);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the iterator

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(iterator, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   double custom_value = 0;

   for (auto& cell : grid) {

     custom_value += 0.1;

     cell = custom_value;

   }

-  

+

   // Then

   double expected_value {0};

   for (auto& result_value : grid) {

     expected_value += 0.1;

-    BOOST_CHECK_EQUAL(result_value, expected_value);

+    BOOST_CHECK_CLOSE(result_value, expected_value, 1e-6);

   }

   expected_value = 0;

   for (auto& result_value : const_grid) {

     expected_value += 0.1;

-    BOOST_CHECK_EQUAL(result_value, expected_value);

+    BOOST_CHECK_CLOSE(result_value, expected_value, 1e-6);

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the iterators axisIndex

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(iteratorAxisIndex, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   auto iterator = grid.begin();

   auto const_iterator = const_grid.begin();

-  

+

   // Then

   for (size_t coord4=0; coord4

     for (size_t coord3=0; coord3

@@ -322,23 +325,23 @@ BOOST_FIXTURE_TEST_CASE(iteratorAxisIndex, GridContainer_Fixture) {

       }

     }

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test the iterators axisValue

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(iteratorAxisValue, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   auto iterator = grid.begin();

   auto const_iterator = const_grid.begin();

-  

+

   // Then

   for (size_t coord4=0; coord4

     for (size_t coord3=0; coord3

@@ -366,27 +369,27 @@ BOOST_FIXTURE_TEST_CASE(iteratorAxisValue, GridContainer_Fixture) {

       }

     }

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing iterator by index

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorByIndex, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByIndex<0>(fixed_index);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByIndex<0>(fixed_index);

-    

+

     // Then

     for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

       for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

@@ -410,17 +413,17 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByIndex, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByIndex<1>(fixed_index);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByIndex<1>(fixed_index);

-    

+

     // Then

     for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

       for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

@@ -444,17 +447,17 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByIndex, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByIndex<2>(fixed_index);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByIndex<2>(fixed_index);

-    

+

     // Then

     for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

       for (size_t coord2 = 0; coord2 < axis2.size(); ++coord2) {

@@ -478,17 +481,17 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByIndex, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByIndex<3>(fixed_index);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByIndex<3>(fixed_index);

-    

+

     // Then

     for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

       for (size_t coord2 = 0; coord2 < axis2.size(); ++coord2) {

@@ -512,25 +515,25 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByIndex, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing iterator index out of bound exception

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorByIndexOutOfBound, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   auto iterator = grid.begin();

   auto const_iterator = const_grid.begin();

-  

+

   // Then

   BOOST_CHECK_THROW(iterator.fixAxisByIndex<0>(axis1.size()), Elements::Exception);

   BOOST_CHECK_THROW(iterator.fixAxisByIndex<1>(axis2.size()), Elements::Exception);

@@ -540,25 +543,25 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByIndexOutOfBound, GridContainer_Fixture) {

   BOOST_CHECK_THROW(const_iterator.fixAxisByIndex<1>(axis2.size()), Elements::Exception);

   BOOST_CHECK_THROW(const_iterator.fixAxisByIndex<2>(axis3.size()), Elements::Exception);

   BOOST_CHECK_THROW(const_iterator.fixAxisByIndex<3>(axis4.size()), Elements::Exception);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing iterator by index twice for same axis throws exception

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorByIndexTwiceForSameAxis, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   auto iterator = grid.begin().fixAxisByIndex<0>(0).fixAxisByIndex<1>(0)

                               .fixAxisByIndex<2>(0).fixAxisByIndex<3>(0);

   auto const_iterator = const_grid.begin().fixAxisByIndex<0>(0).fixAxisByIndex<1>(0)

                                           .fixAxisByIndex<2>(0).fixAxisByIndex<3>(0);

-  

+

   // Then

   iterator.fixAxisByIndex<0>(0);

   iterator.fixAxisByIndex<1>(0);

@@ -568,27 +571,27 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByIndexTwiceForSameAxis, GridContainer_Fixtur

   const_iterator.fixAxisByIndex<1>(0);

   BOOST_CHECK_THROW(const_iterator.fixAxisByIndex<2>(1), Elements::Exception);

   BOOST_CHECK_THROW(const_iterator.fixAxisByIndex<3>(1), Elements::Exception);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing iterator by value

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorByValue, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByValue<0>(axis1[fixed_index]);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByValue<0>(axis1[fixed_index]);

-    

+

     // Then

     for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

       for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

@@ -612,17 +615,17 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByValue, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByValue<1>(axis2[fixed_index]);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByValue<1>(axis2[fixed_index]);

-    

+

     // Then

     for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

       for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

@@ -646,17 +649,17 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByValue, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByValue<2>(axis3[fixed_index]);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByValue<2>(axis3[fixed_index]);

-    

+

     // Then

     for (size_t coord4 = 0; coord4 < axis4.size(); ++coord4) {

       for (size_t coord2 = 0; coord2 < axis2.size(); ++coord2) {

@@ -680,17 +683,17 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByValue, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

   for (size_t fixed_index=0; fixed_index

-    

+

     // When

     auto iterator = grid.begin();

     iterator.fixAxisByValue<3>(axis4[fixed_index]);

     auto const_iterator = const_grid.begin();

     const_iterator.fixAxisByValue<3>(axis4[fixed_index]);

-    

+

     // Then

     for (size_t coord3 = 0; coord3 < axis3.size(); ++coord3) {

       for (size_t coord2 = 0; coord2 < axis2.size(); ++coord2) {

@@ -714,25 +717,25 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByValue, GridContainer_Fixture) {

         }

       }

     }

-    

+

   }

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing iterator value not found exception

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorByValueNotFound, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   auto iterator = grid.begin();

   auto const_iterator = const_grid.begin();

-  

+

   // Then

   BOOST_CHECK_THROW(iterator.fixAxisByValue<0>(axis1.size()+1), Elements::Exception);

   BOOST_CHECK_THROW(iterator.fixAxisByValue<1>(axis2.size()+1), Elements::Exception);

@@ -742,25 +745,25 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByValueNotFound, GridContainer_Fixture) {

   BOOST_CHECK_THROW(const_iterator.fixAxisByValue<1>(axis2.size()+1), Elements::Exception);

   BOOST_CHECK_THROW(const_iterator.fixAxisByValue<2>(axis3.size()+1), Elements::Exception);

   BOOST_CHECK_THROW(const_iterator.fixAxisByValue<3>(axis4.size()+1), Elements::Exception);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing iterator by value twice for same axis throws exception

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorByValueTwiceForSameAxis, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid {axes_tuple};

   const GridContainerType& const_grid = grid;

-  

+

   // When

   auto iterator = grid.begin().fixAxisByValue<0>(1).fixAxisByValue<1>(1)

                               .fixAxisByValue<2>(1).fixAxisByValue<3>(1);

   auto const_iterator = const_grid.begin().fixAxisByValue<0>(1).fixAxisByValue<1>(1)

                                           .fixAxisByValue<2>(1).fixAxisByValue<3>(1);

-  

+

   // Then

   iterator.fixAxisByValue<0>(1);

   iterator.fixAxisByValue<1>(1);

@@ -770,43 +773,43 @@ BOOST_FIXTURE_TEST_CASE(fixIteratorByValueTwiceForSameAxis, GridContainer_Fixtur

   const_iterator.fixAxisByValue<1>(1);

   BOOST_CHECK_THROW(const_iterator.fixAxisByValue<2>(2), Elements::Exception);

   BOOST_CHECK_THROW(const_iterator.fixAxisByValue<3>(2), Elements::Exception);

-  

+

 }

 //-----------------------------------------------------------------------------

 // Test fixing all exes of iterator by other iterator

 //-----------------------------------------------------------------------------

-    

+

 BOOST_FIXTURE_TEST_CASE(fixIteratorAllAxes, GridContainer_Fixture) {

-  

+

   // Given

   GridContainerType grid1 {axes_tuple};

   auto iter1 = grid1.begin();

   GridContainerType grid2 {axes_tuple};

   auto iter2 = grid2.begin();

-  

+

   // When

   iter1.fixAxisByIndex<0>(3).fixAxisByIndex<1>(2).fixAxisByIndex<2>(1).fixAxisByIndex<3>(0);

   iter2.fixAllAxes(iter1);