Added tests for periodic boubnadry oconditions bitmap.

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

Former-commit-id: 49f059cdf9e0c8e20ff727564da13be14ebc2c04

1 files changed, 259 insertions, 11 deletions

diff --git a/src/Bitmap_cubical_complex/test/Bitmap_test.cpp b/src/Bitmap_cubical_complex/test/Bitmap_test.cpp
index 183b856a..4235761f 100644
--- a/src/Bitmap_cubical_complex/test/Bitmap_test.cpp
+++ b/src/Bitmap_cubical_complex/test/Bitmap_test.cpp
@@ -35,7 +35,7 @@ BOOST_AUTO_TEST_CASE(check_dimension) {
   dimensions.push_back(3);
   dimensions.push_back(3);
 
-  Bitmap_cubical_complex<double> increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
   BOOST_CHECK(increasing.dimension() == 2);
 }
 
@@ -88,18 +88,18 @@ BOOST_AUTO_TEST_CASE(topDimensionalCellsIterator_test) {
   dimensions.push_back(3);
   dimensions.push_back(3);
 
-  Bitmap_cubical_complex<double> increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
-  Bitmap_cubical_complex<double> hole(dimensions, oneDimensionalCycle);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > hole(dimensions, oneDimensionalCycle);
 
 
   int i = 0;
-  for (Bitmap_cubical_complex<double>::Top_dimensional_cells_iterator 
+  for (Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> >::Top_dimensional_cells_iterator
        it = increasing.top_dimensional_cells_begin(); it != increasing.top_dimensional_cells_end(); ++it) {
     BOOST_CHECK(*it == expectedFiltrationValues2[i]);
     ++i;
   }
   i = 0;
-  for (Bitmap_cubical_complex<double>::Top_dimensional_cells_iterator 
+  for (Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> >::Top_dimensional_cells_iterator
        it = hole.top_dimensional_cells_begin(); it != hole.top_dimensional_cells_end(); ++it) {
     BOOST_CHECK(*it == expectedFiltrationValues1[i]);
     ++i;
@@ -309,7 +309,7 @@ BOOST_AUTO_TEST_CASE(compute_boundary_test_1) {
   dimensions.push_back(3);
   dimensions.push_back(3);
 
-  Bitmap_cubical_complex<double> increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
   for (size_t i = 0; i != increasing.size_of_bitmap(); ++i) {
     std::vector< size_t > bd = increasing.get_boundary_of_a_cell(i);
     for (size_t j = 0; j != bd.size(); ++j) {
@@ -334,7 +334,7 @@ BOOST_AUTO_TEST_CASE(compute_boundary_test_2) {
   dimensions.push_back(3);
   dimensions.push_back(3);
 
-  Bitmap_cubical_complex<double> increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
 
 
   std::vector<double> coboundaryElements;
@@ -449,7 +449,7 @@ BOOST_AUTO_TEST_CASE(compute_boundary_test_3) {
   dimensions.push_back(3);
   dimensions.push_back(3);
 
-  Bitmap_cubical_complex<double> increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
 
   std::vector<unsigned> dim;
   dim.push_back(0);
@@ -523,7 +523,7 @@ BOOST_AUTO_TEST_CASE(Filtration_simplex_iterator_test) {
   dimensions.push_back(3);
   dimensions.push_back(3);
 
-  Bitmap_cubical_complex<double> increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> > increasing(dimensions, increasingFiltrationOfTopDimensionalCells);
 
   std::vector< unsigned > dim;
   dim.push_back(0);
@@ -628,11 +628,259 @@ BOOST_AUTO_TEST_CASE(Filtration_simplex_iterator_test) {
   fil.push_back(9);
 
 
-  Bitmap_cubical_complex<double>::Filtration_simplex_range range = increasing.filtration_simplex_range();
+  Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> >::Filtration_simplex_range range = increasing.filtration_simplex_range();
   size_t position = 0;
-  for (Bitmap_cubical_complex<double>::Filtration_simplex_iterator it = range.begin(); it != range.end(); ++it) {
+  for (Bitmap_cubical_complex< Bitmap_cubical_complex_base<double> >::Filtration_simplex_iterator it = range.begin(); it != range.end(); ++it) {
     BOOST_CHECK(increasing.dimension(*it) == dim[position]);
     BOOST_CHECK(increasing.filtration(*it) == fil[position]);
     ++position;
   }
 }
+

+

+

+BOOST_AUTO_TEST_CASE(boudary_operator_2d_bitmap_with_periodic_bcond) {
+  std::vector< double > filtration;
+  filtration.push_back(0);
+  filtration.push_back(0);
+  filtration.push_back(0);
+  filtration.push_back(0);
+
+
+  std::vector<unsigned> dimensions;
+  dimensions.push_back(2);
+  dimensions.push_back(2);

+

+  std::vector<bool> periodic_directions;
+  periodic_directions.push_back(true);
+  periodic_directions.push_back(true);
+
+  Bitmap_cubical_complex< Bitmap_cubical_complex_periodic_boundary_conditions_base<double> > cmplx(dimensions, filtration,periodic_directions);
+  BOOST_CHECK(cmplx.dimension() == 2);

+

+

+  std::vector<double> boundary0;
+  std::vector<double> boundary1;

+  boundary1.push_back(0);

+  boundary1.push_back(2);

+  std::vector<double> boundary2;

+  std::vector<double> boundary3;

+  boundary3.push_back(2);

+  boundary3.push_back(0);

+  std::vector<double> boundary4;

+  boundary4.push_back(0);

+  boundary4.push_back(8);

+  std::vector<double> boundary5;

+  boundary5.push_back(1);

+  boundary5.push_back(9);

+  boundary5.push_back(4);

+  boundary5.push_back(6);

+  std::vector<double> boundary6;

+  boundary6.push_back(2);

+  boundary6.push_back(10);

+  std::vector<double> boundary7;

+  boundary7.push_back(3);

+  boundary7.push_back(11);

+  boundary7.push_back(6);

+  boundary7.push_back(4);

+  std::vector<double> boundary8;

+  std::vector<double> boundary9;

+  boundary9.push_back(8);

+  boundary9.push_back(10);

+  std::vector<double> boundary10;

+  std::vector<double> boundary11;

+  boundary11.push_back(10);

+  boundary11.push_back(8);

+  std::vector<double> boundary12;

+  boundary12.push_back(8);

+  boundary12.push_back(0);

+  std::vector<double> boundary13;

+  boundary13.push_back(9);

+  boundary13.push_back(1);

+  boundary13.push_back(12);

+  boundary13.push_back(14);

+  std::vector<double> boundary14;

+  boundary14.push_back(10);

+  boundary14.push_back(2);

+  std::vector<double> boundary15;

+  boundary15.push_back(11);

+  boundary15.push_back(3);

+  boundary15.push_back(14);

+  boundary15.push_back(12);

+

+  std::vector< std::vector<double> > boundaries;

+  boundaries.push_back( boundary0 );

+  boundaries.push_back( boundary1 );

+  boundaries.push_back( boundary2 );

+  boundaries.push_back( boundary3 );

+  boundaries.push_back( boundary4 );

+  boundaries.push_back( boundary5 );

+  boundaries.push_back( boundary6 );

+  boundaries.push_back( boundary7 );

+  boundaries.push_back( boundary8 );

+  boundaries.push_back( boundary9 );

+  boundaries.push_back( boundary10 );

+  boundaries.push_back( boundary11 );

+  boundaries.push_back( boundary12 );

+  boundaries.push_back( boundary13 );

+  boundaries.push_back( boundary14 );

+  boundaries.push_back( boundary15 );

+

+  for (size_t i = 0; i != cmplx.size_of_bitmap(); ++i) {
+    std::vector< size_t > bd = cmplx.get_boundary_of_a_cell(i);
+    for (size_t j = 0; j != bd.size(); ++j) {
+      BOOST_CHECK(boundaries[i][j] == bd[j]);
+    }
+  }
+}
+

+

+

+

+

+

+BOOST_AUTO_TEST_CASE(coboudary_operator_2d_bitmap_with_periodic_bcond) {
+  std::vector< double > filtration;
+  filtration.push_back(0);
+  filtration.push_back(0);
+  filtration.push_back(0);
+  filtration.push_back(0);
+
+
+  std::vector<unsigned> dimensions;
+  dimensions.push_back(2);
+  dimensions.push_back(2);

+

+  std::vector<bool> periodic_directions;
+  periodic_directions.push_back(true);
+  periodic_directions.push_back(true);
+
+  Bitmap_cubical_complex< Bitmap_cubical_complex_periodic_boundary_conditions_base<double> > cmplx(dimensions, filtration,periodic_directions);
+  BOOST_CHECK(cmplx.dimension() == 2);

+

+

+  std::vector<double> coboundary0;

+  coboundary0.push_back(4);

+  coboundary0.push_back(12);

+  coboundary0.push_back(1);

+  coboundary0.push_back(3);

+  std::vector<double> coboundary1;

+  coboundary1.push_back(5);

+  coboundary1.push_back(13);

+  std::vector<double> coboundary2;

+  coboundary2.push_back(6);

+  coboundary2.push_back(14);

+  coboundary2.push_back(1);

+  coboundary2.push_back(3);

+  std::vector<double> coboundary3;

+  coboundary3.push_back(7);

+  coboundary3.push_back(15);

+  std::vector<double> coboundary4;

+  coboundary4.push_back(5);

+  coboundary4.push_back(7);

+  std::vector<double> coboundary5;

+  std::vector<double> coboundary6;

+  coboundary6.push_back(5);

+  coboundary6.push_back(7);

+  std::vector<double> coboundary7;

+  std::vector<double> coboundary8;

+  coboundary8.push_back(4);

+  coboundary8.push_back(12);

+  coboundary8.push_back(9);

+  coboundary8.push_back(11);

+  std::vector<double> coboundary9;

+  coboundary9.push_back(5);

+  coboundary9.push_back(13);

+  std::vector<double> coboundary10;

+  coboundary10.push_back(6);

+  coboundary10.push_back(14);

+  coboundary10.push_back(9);

+  coboundary10.push_back(11);

+  std::vector<double> coboundary11;

+  coboundary11.push_back(7);

+  coboundary11.push_back(15);

+  std::vector<double> coboundary12;

+  coboundary12.push_back(13);

+  coboundary12.push_back(15);

+  std::vector<double> coboundary13;

+  std::vector<double> coboundary14;

+  coboundary14.push_back(13);

+  coboundary14.push_back(15);

+  std::vector<double> coboundary15;
+

+  std::vector< std::vector<double> > coboundaries;

+  coboundaries.push_back( coboundary0 );

+  coboundaries.push_back( coboundary1 );

+  coboundaries.push_back( coboundary2 );

+  coboundaries.push_back( coboundary3 );

+  coboundaries.push_back( coboundary4 );

+  coboundaries.push_back( coboundary5 );

+  coboundaries.push_back( coboundary6 );

+  coboundaries.push_back( coboundary7 );

+  coboundaries.push_back( coboundary8 );

+  coboundaries.push_back( coboundary9 );

+  coboundaries.push_back( coboundary10 );

+  coboundaries.push_back( coboundary11 );

+  coboundaries.push_back( coboundary12 );

+  coboundaries.push_back( coboundary13 );

+  coboundaries.push_back( coboundary14 );

+  coboundaries.push_back( coboundary15 );

+

+  for (size_t i = 0; i != cmplx.size_of_bitmap(); ++i) {
+    std::vector< size_t > cbd = cmplx.get_coboundary_of_a_cell(i);
+    for (size_t j = 0; j != cbd.size(); ++j) {
+      BOOST_CHECK(coboundaries[i][j] == cbd[j]);
+    }
+  }
+}

+

+

+

+

+

+

+

+BOOST_AUTO_TEST_CASE(bitmap_2d_with_periodic_bcond_filtration) {
+  std::vector< double > filtrationOrg;
+  filtrationOrg.push_back(0);
+  filtrationOrg.push_back(1);
+  filtrationOrg.push_back(2);
+  filtrationOrg.push_back(3);
+
+
+  std::vector<unsigned> dimensions;
+  dimensions.push_back(2);
+  dimensions.push_back(2);

+

+  std::vector<bool> periodic_directions;
+  periodic_directions.push_back(true);
+  periodic_directions.push_back(true);
+
+  Bitmap_cubical_complex< Bitmap_cubical_complex_periodic_boundary_conditions_base<double> > cmplx(dimensions, filtrationOrg,periodic_directions);
+  BOOST_CHECK(cmplx.dimension() == 2);

+

+

+  std::vector<double> filtration;

+  filtration.push_back(0);//0

+  filtration.push_back(0);//1

+  filtration.push_back(0);//2

+  filtration.push_back(1);//3

+  filtration.push_back(0);//4

+  filtration.push_back(0);//5

+  filtration.push_back(0);//6

+  filtration.push_back(1);//7

+  filtration.push_back(0);//8

+  filtration.push_back(0);//9

+  filtration.push_back(0);//10

+  filtration.push_back(1);//11

+  filtration.push_back(2);//12

+  filtration.push_back(2);//13

+  filtration.push_back(2);//14

+  filtration.push_back(3);//15

+

+

+  for (size_t i = 0; i != cmplx.size_of_bitmap(); ++i)

+  {
+      BOOST_CHECK( filtration[i] == cmplx.get_cell_data(i) );
+  }
+}