diff options
Diffstat (limited to 'src/Skeleton_blocker/test')
| -rw-r--r-- | src/Skeleton_blocker/test/CMakeLists.txt | 7 | ||||
| -rw-r--r-- | src/Skeleton_blocker/test/TestSimplifiable.cpp | 281 | ||||
| -rw-r--r-- | src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp | 773 |
3 files changed, 1061 insertions, 0 deletions
diff --git a/src/Skeleton_blocker/test/CMakeLists.txt b/src/Skeleton_blocker/test/CMakeLists.txt new file mode 100644 index 00000000..d66dcf64 --- /dev/null +++ b/src/Skeleton_blocker/test/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 2.6) +project(GUDHIskbl) + +add_executable ( TestSkeletonBlockerComplex TestSkeletonBlockerComplex.cpp ) +add_executable ( TestSimplifiable TestSimplifiable.cpp ) + + diff --git a/src/Skeleton_blocker/test/TestSimplifiable.cpp b/src/Skeleton_blocker/test/TestSimplifiable.cpp new file mode 100644 index 00000000..9f802463 --- /dev/null +++ b/src/Skeleton_blocker/test/TestSimplifiable.cpp @@ -0,0 +1,281 @@ +/* + * TestSimplifiable.cxx + * + * Created on: Feb 4, 2014 + * Author: dsalinas + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string> +#include <fstream> +#include <sstream> +#include "gudhi/Test.h" +//#include "Skeleton_blocker/Simplex.h" +#include "gudhi/Skeleton_blocker_complex.h" +#include "gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h" +#include "gudhi/Skeleton_blocker_simplifiable_complex.h" +#include "gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h" + + +using namespace std; + +using namespace Gudhi; + +using namespace skbl; + +template<typename ComplexType> class Skeleton_blocker_sub_complex; +typedef Skeleton_blocker_simplifiable_complex<Skeleton_blocker_simple_traits> Complex; +typedef Complex::Vertex_handle Vertex_handle; +typedef Complex::Root_vertex_handle Root_vertex_handle; +typedef Skeleton_blocker_simplex<Vertex_handle> Simplex_handle; +// true iff v \in complex +bool assert_vertex(Complex &complex,Vertex_handle v){ + Simplex_handle simplex(v); + bool test = complex.contains(simplex); + assert(test); + return test; +} + +// true iff the blocker (a,b,c) is in complex +bool assert_blocker(Complex &complex,Root_vertex_handle a,Root_vertex_handle b,Root_vertex_handle c){ + + return complex.contains_blocker(Simplex_handle(*complex.get_address(a),*complex.get_address(b),*complex.get_address(c))); + //return complex.contains_blocker((a),(b),(c)); +} + +void build_complete(int n,Complex& complex){ + complex.clear(); + for(int i=0;i<n;i++) + complex.add_vertex(); + for(int i=0;i<n;i++) + for(int j=0;j<i;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); +} + +bool test_contraction1(){ + enum { a, b, x, y, z, n }; + Complex complex(n); + build_complete(n,complex); + complex.remove_edge(Vertex_handle(b),Vertex_handle(z)); + complex.add_blocker(Vertex_handle(a),Vertex_handle(x),Vertex_handle(y)); + complex.add_blocker(Vertex_handle(b),Vertex_handle(x),Vertex_handle(y)); + + // Print result + cerr << "complex before complex"<< complex.to_string()<<endl; + + cerr <<endl<<endl; + complex.contract_edge(Vertex_handle(a),Vertex_handle(b)); + // Print result + cerr << "ContractEdge(0,1)\n"; + PRINT(complex.to_string()); + + // verification + for (int i=0;i<5;i++) + if (i!=1) assert_vertex(complex,Vertex_handle(i)); + bool test1 = !complex.contains_edge(Vertex_handle(a),Vertex_handle(b)); + bool test2 = assert_blocker(complex,Root_vertex_handle(a),Root_vertex_handle(x),Root_vertex_handle(y)); + bool test3 = complex.num_edges()==6; + bool test4 = complex.num_blockers()==1; + Simplex_handle sigma; + sigma.add_vertex(Vertex_handle(a)); + sigma.add_vertex(Vertex_handle(x)); + sigma.add_vertex(Vertex_handle(y)); + sigma.add_vertex(Vertex_handle(z)); + bool test5 = !(complex.contains(sigma)); + return test1&&test2&&test3&&test4&&test5; +} + + +bool test_contraction2(){ + enum { a, b, x, y, z, n }; + Complex complex(n); + build_complete(n,complex); + complex.remove_edge(Vertex_handle(b),Vertex_handle(x)); + Simplex_handle blocker; + blocker.add_vertex(Vertex_handle(a)); + blocker.add_vertex(Vertex_handle(y)); + blocker.add_vertex(Vertex_handle(z)); + + complex.add_blocker(blocker); + + // Print result + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; + complex.contract_edge(Vertex_handle(a),Vertex_handle(b)); + + cerr << "complex.ContractEdge(a,b)"<< complex.to_string(); + + cerr <<endl<<endl; + + // there should be one blocker (a,c,d,e) in the complex + bool test ; + test = complex.contains_blocker(Simplex_handle(a,x,y,z)); + test = test && complex.num_blockers()==1; + return test; +} + +bool test_link_condition1(){ + + Complex complex(0); + // Build the complexes + build_complete(4,complex); + complex.add_blocker(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)); + + + // Print result + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; + + bool weak_link_condition = complex.link_condition(Vertex_handle(1),Vertex_handle(2),true); + + bool strong_link_condition = complex.link_condition(Vertex_handle(1),Vertex_handle(2),false); + + return weak_link_condition && !strong_link_condition; +} + + + + +bool test_collapse1(){ + // xxx implement remove_star(simplex) before + + Complex complex(5); + build_complete(4,complex); + complex.add_vertex(); + complex.add_edge(2,4); + complex.add_edge(3,4); + // Print result + cerr << "initial complex :\n"<< complex.to_string(); + cerr <<endl<<endl; + + Simplex_handle simplex_123(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)); + complex.remove_star(simplex_123); + cerr << "complex.remove_star(1,2,3):\n"<< complex.to_string(); + cerr <<endl<<endl; + + // verification + bool blocker123_here = complex.contains_blocker(simplex_123); + cerr <<"----> Ocomplex \n"; + return blocker123_here; +} + +bool test_collapse2(){ + Complex complex(5); + build_complete(4,complex); + complex.add_vertex(); + complex.add_edge(Vertex_handle(1),Vertex_handle(4)); + complex.add_edge(Vertex_handle(2),Vertex_handle(4)); + complex.add_edge(Vertex_handle(3),Vertex_handle(4)); + complex.add_blocker(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3),Vertex_handle(4)); + // Print result + cerr << "initial complex :\n"<< complex.to_string(); + cerr <<endl<<endl; + + Simplex_handle sigma(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)); + complex.remove_star(sigma); + cerr << "complex.remove_star(1,2,3):\n"<< complex.to_string(); + cerr <<endl<<endl; + + // verification + bool blocker_removed = !complex.contains_blocker(Simplex_handle(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3),Vertex_handle(4))); + bool blocker123_here = complex.contains_blocker(sigma); + return blocker_removed && blocker123_here; +} + +bool test_collapse3(){ + Complex complex(5); + build_complete(4,complex); + complex.add_vertex(); + complex.add_edge(Vertex_handle(1),Vertex_handle(4)); + complex.add_edge(Vertex_handle(2),Vertex_handle(4)); + complex.add_edge(Vertex_handle(3),Vertex_handle(4)); + complex.add_blocker(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3),Vertex_handle(4)); + // Print result + cerr << "initial complex:\n"<< complex.to_string(); + cerr <<endl<<endl; + + complex.remove_star(Vertex_handle(2)); + cerr << "complex after remove star of 2:\n"<< complex.to_string(); + + bool blocker134_here = complex.contains_blocker(Simplex_handle(Vertex_handle(1),Vertex_handle(3),Vertex_handle(4))); + bool blocker1234_here = complex.contains_blocker(Simplex_handle(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3),Vertex_handle(4))); + // verification + // assert_blocker(complex,1,2,3); + // assert(!complex.ContainsBlocker(new AddressSimplex(1,2,3,4))); + cerr <<"----> Ocomplex \n"; + return blocker134_here && !blocker1234_here; +} + + + +bool test_remove_popable_blockers(){ + Complex complex; + build_complete(4,complex); + complex.add_vertex(); + complex.add_edge(Vertex_handle(3),Vertex_handle(4)); + complex.add_edge(Vertex_handle(2),Vertex_handle(4)); + Simplex_handle sigma1=Simplex_handle(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)); + Simplex_handle sigma2=Simplex_handle(Vertex_handle(2),Vertex_handle(3),Vertex_handle(4)); + + complex.add_blocker(sigma1); + complex.add_blocker(sigma2); + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; + cerr << "complex.RemovePopableBlockers();"<<endl; + complex.remove_popable_blockers(); + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; + + bool test1 = (complex.num_blockers()==1); + + + // test 2 + complex.clear(); + build_complete(4,complex); + complex.add_vertex(); + complex.add_vertex(); + complex.add_edge(Vertex_handle(3),Vertex_handle(4)); + complex.add_edge(Vertex_handle(2),Vertex_handle(4)); + complex.add_edge(Vertex_handle(2),Vertex_handle(5)); + complex.add_edge(Vertex_handle(3),Vertex_handle(5)); + complex.add_edge(Vertex_handle(4),Vertex_handle(5)); + sigma1=Simplex_handle(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)); + sigma2=Simplex_handle(Vertex_handle(2),Vertex_handle(3),Vertex_handle(4)); + + complex.add_blocker(sigma1); + complex.add_blocker(sigma2); + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; cerr << "complex.RemovePopableBlockers();"<<endl; + complex.remove_popable_blockers(); + cerr << "complex complex"<< complex.to_string(); + + cerr <<endl<<endl; + bool test2 = (complex.num_blockers()==0); + return test1&&test2; +} + + + +int main (int argc, char *argv[]) +{ + Tests tests_simplifiable_complex; + tests_simplifiable_complex.add("Test contraction 1",test_contraction1); + tests_simplifiable_complex.add("Test contraction 2",test_contraction2); + tests_simplifiable_complex.add("Test Link condition 1",test_link_condition1); + tests_simplifiable_complex.add("Test remove popable blockers",test_remove_popable_blockers); + + + tests_simplifiable_complex.add("Test collapse 1",test_collapse1); + tests_simplifiable_complex.add("Test collapse 2",test_collapse2); + tests_simplifiable_complex.add("Test collapse 3",test_collapse3); + + + tests_simplifiable_complex.run(); + + if(tests_simplifiable_complex.run()) + return EXIT_SUCCESS; + else + return EXIT_FAILURE; +} diff --git a/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp b/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp new file mode 100644 index 00000000..c89f84e2 --- /dev/null +++ b/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp @@ -0,0 +1,773 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string> +#include <fstream> +#include <sstream> +#include "gudhi/Utils.h" +#include "gudhi/Test.h" +//#include "Skeleton_blocker/Simplex.h" +#include "gudhi/Skeleton_blocker_complex.h" +#include "gudhi/Skeleton_blocker_link_complex.h" +#include "gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h" +#include "gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h" +//#include "Simple_vertex.h" +//#include "Simple_edge.h" + +using namespace std; + +using namespace Gudhi; + +using namespace skbl; + + +typedef Skeleton_blocker_complex<Skeleton_blocker_simple_traits> Complex; +typedef Complex::Vertex_handle Vertex_handle; +typedef Complex::Root_vertex_handle Root_vertex_handle; +typedef Complex::Simplex_handle Simplex_handle; +typedef Complex::Root_simplex_handle Root_simplex_handle; +typedef Simplex_handle::Simplex_vertex_const_iterator Simplex_vertex_const_iterator; +typedef Complex::Edge_handle Edge_handle; + +// true iff v \in complex +bool assert_vertex(Complex &complex,Vertex_handle v){ + //assert(complex.contains(v)); + return complex.contains(v); +} + +bool assert_simplex(Complex &complex,Root_vertex_handle a,Root_vertex_handle b,Root_vertex_handle c){ + return true; + // AddressSimplex simplex((a),(b),(c)); + // return complex.contains(&simplex); +} + +// true iff the blocker (a,b,c) is in complex +bool assert_blocker(Complex &complex,Root_vertex_handle a,Root_vertex_handle b,Root_vertex_handle c){ + return true; + //return complex.contains_blocker((a),(b),(c)); +} + +// true iff the blocker (a,b,c,d) is in complex +bool assert_blocker(Complex &complex,Root_vertex_handle a,Root_vertex_handle b,Root_vertex_handle c,Root_vertex_handle d){ + return true; + //Simplex blocker (a,b,c,d); + //return complex.contains_blocker(&blocker); +} + + +void build_complete(int n,Complex& complex){ + complex.clear(); + for(int i=0;i<n;i++) + complex.add_vertex(); + +// for(int i=n-1;i>=0;i--) +// for(int j=i-1;j>=0;j--) +// complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + + for(int i=0;i<n;i++) + for(int j=0;j<i;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); +} + + +bool test_simplex(){ +// PRINT("test simplex"); + Simplex_handle simplex(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)); + for (auto i = simplex.begin() ; i != simplex.end() ; ++i){ + PRINT(*i); + auto j = i; + for (++j ; + j != simplex.end() ; + ++j){ + PRINT(*j); + } + } + return simplex.dimension()==3; +} + + +bool test_iterator_vertices1(){ + int n = 10; + Complex complex(10); + cerr << "complex.num_vertices():"<<complex.num_vertices()<<endl; + int num_vertex_seen = 0; + for(auto vi :complex.vertex_range()){ + cerr << "vertex:"<<vi<<endl; + ++num_vertex_seen; + } + return num_vertex_seen == n; +} + +bool test_iterator_vertices2(){ + int n = 10; + Complex complex(10); + build_complete(10,complex); + cerr << "complex.num_vertices():"<<complex.num_vertices()<<endl; + cerr << "complex.num_edges():"<<complex.num_edges()<<endl; + int num_vertex_seen = 0; + for(auto vi :complex.vertex_range(Vertex_handle(2))){ + cerr << "vertex:"<<vi<<endl; + ++num_vertex_seen; + } + std::cerr<<"num_vertex_seen:"<<num_vertex_seen<<std::endl; + return num_vertex_seen == (n-1); +} + + + +bool test_iterator_edge(){ + const int n = 10; + Complex complex(n); + for(int i=0;i<n;i++) + for(int j=0;j<i;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + complex.remove_edge(Vertex_handle(2),Vertex_handle(3)); + complex.remove_edge(Vertex_handle(3),Vertex_handle(5)); + cerr << "complex.num_edges():"<<complex.num_edges()<<endl; + int num_edges_seen = 0; + for(auto edge : complex.edge_range()){ + cerr << "edge :"<<complex[edge]<<endl; + ++num_edges_seen; + } + + return num_edges_seen == n*(n-1)/2-2; +} + +bool test_iterator_edge2(){ + const int n = 10; + Complex complex(n); + for(int i=0;i<n;i++) + for(int j=0;j<i;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + complex.remove_edge(Vertex_handle(2),Vertex_handle(3)); + complex.remove_edge(Vertex_handle(3),Vertex_handle(5)); + cerr << "complex.num_edges():"<<complex.num_edges()<<endl; + int num_neigbors_seen = 0; + for(auto neighbor : complex.vertex_range(Vertex_handle(2))){ + cerr << "neighbor"<<neighbor<<endl; + ++num_neigbors_seen; + } + return num_neigbors_seen==8; +} + + + +bool test_iterator_edge3(){ + const int n = 10; + Complex complex(n); + for(int i=0;i<n;i++) + for(int j=0;j<i;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + complex.remove_edge(Vertex_handle(2),Vertex_handle(3)); + complex.remove_edge(Vertex_handle(3),Vertex_handle(5)); + cerr << "complex.num_edges():"<<complex.num_edges()<<endl; + int num_neigbors_seen = 0; + for(auto edge : complex.edge_range(Vertex_handle(2))){ + std::cerr << edge<< std::endl; + ++num_neigbors_seen; + } + return num_neigbors_seen==8; +} + + + +bool test_iterator_triangles(){ + const int n = 7; + Complex complex(n); + //create a "ring" around '0' + for(int i=1;i<n;i++) + complex.add_edge(Vertex_handle(0),Vertex_handle(i)); + for(int i=1;i<n-1;i++) + complex.add_edge(Vertex_handle(i),Vertex_handle(i+1)); + complex.add_edge(Vertex_handle(1),Vertex_handle(6)); + + PRINT(complex.to_string()); + + int num_triangles_seen=0; + //for (auto t : complex.triangle_range(5)){ + TEST("triangles around 5 (should be 2 of them):"); + for (auto t : complex.triangle_range(5)){ + PRINT(t); + ++num_triangles_seen; + } + bool test = (num_triangles_seen==2); + + num_triangles_seen=0; + TEST("triangles around 0 (should be 6 of them):"); + for (auto t : complex.triangle_range(0)){ + PRINT(t); + ++num_triangles_seen; + } + test = test&&(num_triangles_seen==6); + + // we now add another triangle + complex.add_vertex(); + complex.add_edge(Vertex_handle(4),Vertex_handle(7)); + complex.add_edge(Vertex_handle(3),Vertex_handle(7)); + complex.add_blocker(Vertex_handle(0),Vertex_handle(1),Vertex_handle(6)); + num_triangles_seen=0; + + TEST("triangles (should be 6 of them):"); + num_triangles_seen=0; + for (auto t : complex.triangle_range()){ + PRINT(t); + ++num_triangles_seen; + } + test = test&&(num_triangles_seen==6); + PRINT(num_triangles_seen); + + return test; +} + + +//#include "combinatorics/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h" + +bool test_iterator_simplices(){ + Complex complex(6); + complex.add_edge(Vertex_handle(0),Vertex_handle(1)); + complex.add_edge(Vertex_handle(1),Vertex_handle(2)); + complex.add_edge(Vertex_handle(2),Vertex_handle(0)); + complex.add_edge(Vertex_handle(1),Vertex_handle(3)); + complex.add_edge(Vertex_handle(2),Vertex_handle(3)); + complex.add_edge(Vertex_handle(2),Vertex_handle(5)); + complex.add_edge(Vertex_handle(3),Vertex_handle(5)); + complex.add_edge(Vertex_handle(2),Vertex_handle(4)); + complex.add_edge(Vertex_handle(4),Vertex_handle(5)); + complex.add_edge(Vertex_handle(3),Vertex_handle(4)); + + complex.add_blocker(Vertex_handle(2),Vertex_handle(3),Vertex_handle(4),Vertex_handle(5)); + + bool correct_number_simplices = true; + + std::map<Vertex_handle,unsigned> expected_num_simplices; + + expected_num_simplices[Vertex_handle(0)] = 4; + expected_num_simplices[Vertex_handle(1)] = 6; + expected_num_simplices[Vertex_handle(2)] = 11; + expected_num_simplices[Vertex_handle(3)] = 9; + expected_num_simplices[Vertex_handle(4)] = 7; + expected_num_simplices[Vertex_handle(5)] = 7; + + for(auto pair : expected_num_simplices){ + unsigned num_simplices_around = 0; + for(const auto& simplex : complex.simplex_range(pair.first)){ + simplex.dimension(); + DBGVALUE(simplex); + ++num_simplices_around; + } + + correct_number_simplices = correct_number_simplices && (num_simplices_around == pair.second); + + DBGMSG("current vertex:",pair.first); + DBGMSG("expected_num_simplices:",pair.second); + DBGMSG("found:",num_simplices_around); + } + return correct_number_simplices; +} + + + +bool test_iterator_simplices2(){ + Complex complex(2); + complex.add_edge(Vertex_handle(0),Vertex_handle(1)); + + for(const auto& s:complex.triangle_range()){ + s.dimension(); + return false; // there are no triangles + } + + unsigned num_simplices = 0 ; + + + DBGVALUE(complex.to_string()); + + for(const auto& simplex : complex.simplex_range(Vertex_handle(0))){ + simplex.dimension(); + DBGVALUE(simplex); + } + + + for(const auto& simplex : complex.simplex_range()){ + DBGVALUE(simplex); + simplex.dimension(); + ++num_simplices; + } + bool correct_number_simplices = (num_simplices == 3); + return correct_number_simplices; +} + + +bool test_iterator_simplices3(){ + Complex complex(3); + complex.add_edge(Vertex_handle(0),Vertex_handle(1)); + complex.add_edge(Vertex_handle(1),Vertex_handle(2)); + complex.add_edge(Vertex_handle(2),Vertex_handle(0)); + complex.add_blocker(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)); + + unsigned num_simplices = 0 ; + + for(const auto& simplex : complex.simplex_range(Vertex_handle(0))){ + simplex.dimension(); + DBGVALUE(simplex); + } + + + for(const auto& simplex : complex.simplex_range()){ + DBGVALUE(simplex); + simplex.dimension(); + ++num_simplices; + } + bool correct_number_simplices = (num_simplices == 6); + return correct_number_simplices; +} + +bool test_iterator_simplices4(){ + Complex empty_complex; + for(auto v : empty_complex.vertex_range()){ + v; + } + for(auto e : empty_complex.edge_range()){ + empty_complex[e]; + } + for(auto t : empty_complex.triangle_range()){ + t.dimension(); + } + for(auto s : empty_complex.simplex_range()){ + s.dimension(); + } + return true; +} + + + + + +template<typename Map> +auto blocker_range(Map map) -> decltype( map | boost::adaptors::map_values){ + return map| boost::adaptors::map_values ; +} + + +bool test_iterator_blockers(){ + Complex complex; + Simplex_handle alpha; + Simplex_handle vertex_set_expected; + // Build the complexes + for (int i=0;i<20;i++){ + complex.add_vertex(); + } + for (int i=10;i<15;i++){ + for (int j=i+1;j<15;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + } + + complex.add_blocker(Simplex_handle(Vertex_handle(10),Vertex_handle(11),Vertex_handle(12))); + complex.add_blocker(Simplex_handle(Vertex_handle(2),Vertex_handle(1),Vertex_handle(10))); + complex.add_blocker(Simplex_handle(Vertex_handle(10),Vertex_handle(9),Vertex_handle(15))); + complex.add_blocker(Simplex_handle(Vertex_handle(1),Vertex_handle(9),Vertex_handle(8))); + + // Print result + int num_blockers=0; + for(auto blockers : complex.blocker_range(Vertex_handle(10))){ + TESTVALUE(*blockers) ; + num_blockers++; + } + bool test = (num_blockers==3); + + num_blockers=0; + for (auto blockers : complex.blocker_range()){ + TESTVALUE(*blockers) ; + num_blockers++; + } + test = test && (num_blockers==4) ; + + return test; +} + + +bool test_link0(){ + + enum { a, b, c, d, n }; + Complex complex(n); + complex.add_edge(Vertex_handle(b),Vertex_handle(c));complex.add_edge(Vertex_handle(c),Vertex_handle(d)); + Simplex_handle alpha = Simplex_handle(Vertex_handle(c)); + Skeleton_blocker_link_complex<Complex> L(complex,alpha); + PRINT(L.num_vertices()); + PRINT(L.to_string()); + + bool test1 = L.contains_vertex(*L.get_address(Root_vertex_handle(b))); + bool test2 = L.contains_vertex(*L.get_address(Root_vertex_handle(d))); + bool test3 = L.num_edges()==0; + bool test4 = L.num_blockers()==0; + return test1&&test2&&test3&&test4; + +} + +bool test_link1(){ + Complex complex; + + + // Build the complexes + for (int i=0;i<20;i++){ + complex.add_vertex(); + } + for (int i=10;i<15;i++){ + for (int j=i+1;j<15;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + } + Simplex_handle alpha(Vertex_handle(12),Vertex_handle(14)); + Skeleton_blocker_link_complex<Complex> L(complex,alpha); + // Complexes built + + // verification + bool test1 = L.contains_vertex(*L.get_address(Root_vertex_handle(10))); + bool test2 = L.contains_vertex(*L.get_address(Root_vertex_handle(11))); + bool test3 = L.contains_vertex(*L.get_address(Root_vertex_handle(13))); + bool test4 = L.num_edges()==3; + bool test5 = L.num_blockers()==0; + Root_simplex_handle simplex; + simplex.add_vertex(Root_vertex_handle(10)); + simplex.add_vertex(Root_vertex_handle(11)); + simplex.add_vertex(Root_vertex_handle(13)); + bool test6(L.get_simplex_address(simplex)); + bool test7 = L.contains(*(L.get_simplex_address(simplex))); + cerr <<"----> Ocomplex \n"; + return test1&&test2&&test3&&test4&&test5&&test6&&test7 ; + +} + + +bool test_link2(){ + Complex complex; + + Simplex_handle alpha; + Simplex_handle vertex_set_expected; + // Build the complexes + for (int i=0;i<20;i++){ + complex.add_vertex(); + } + for (int i=10;i<15;i++){ + for (int j=i+1;j<15;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + } + complex.add_blocker(Vertex_handle(10),Vertex_handle(11),Vertex_handle(13)); + alpha = Simplex_handle(Vertex_handle(12),Vertex_handle(14)); + Skeleton_blocker_link_complex<Complex> L(complex,alpha); + // Complexes built + + // Print result + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; + cerr << "L= Link_complex("<<alpha<<") : \n"<<L.to_string(); + + // verification + bool test1 = L.contains_vertex(*L.get_address(Root_vertex_handle(10))); + bool test2 = L.contains_vertex(*L.get_address(Root_vertex_handle(11))); + bool test3 = L.contains_vertex(*L.get_address(Root_vertex_handle(13))); + bool test4 = L.num_edges()==3; + bool test5 = L.num_blockers()==1; + Root_simplex_handle simplex; + simplex.add_vertex(Root_vertex_handle(10)); + simplex.add_vertex(Root_vertex_handle(11)); + simplex.add_vertex(Root_vertex_handle(13)); + bool test6 = L.contains_blocker(*(L.get_simplex_address(simplex))); + cerr <<"----> Ocomplex \n"; + return test1&&test2&&test3&&test4&&test5&&test6 ; +} + +bool test_link3(){ + Complex complex; + + Simplex_handle alpha; + Simplex_handle vertex_set_expected; + // Build the complexes + for (int i=0;i<20;i++){ + complex.add_vertex(); + } + for (int i=10;i<15;i++){ + for (int j=i+1;j<15;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + } + complex.add_blocker(Vertex_handle(10),Vertex_handle(11),Vertex_handle(12)); + alpha = Simplex_handle(Vertex_handle(12),Vertex_handle(14)); + Skeleton_blocker_link_complex<Complex> L(complex,alpha); + // Complexes built + + // Print result + cerr << "complex complex"<< complex.to_string(); + cerr <<endl<<endl; + cerr << "L= Link_complex("<<alpha<<") : \n"<<L.to_string(); + + // verification + bool test = assert_vertex(L,*L.get_address(Root_vertex_handle(10))); + test = test&& assert_vertex(L,*L.get_address(Root_vertex_handle(11))); + test = test&& assert_vertex(L,*L.get_address(Root_vertex_handle(13))); + test = test&& L.num_edges()==2; + test = test&&L.contains_edge(*L.get_address(Root_vertex_handle(10)),*L.get_address(Root_vertex_handle(13))); + test=test&&L.contains_edge(*L.get_address(Root_vertex_handle(13)),*L.get_address(Root_vertex_handle(11))); + test=test&&L.num_blockers()==0; + return test; +} + +bool test_link4(){ + Complex complex; + + // Build the complexes + for (int i=0;i<20;i++){ + complex.add_vertex(); + } + for (int i=10;i<15;i++){ + for (int j=i+1;j<15;j++) + complex.add_edge(Vertex_handle(i),Vertex_handle(j)); + } + complex.add_blocker(Vertex_handle(10),Vertex_handle(11),Vertex_handle(12),Vertex_handle(13)); + Simplex_handle alpha(Vertex_handle(12),Vertex_handle(14)); + Skeleton_blocker_link_complex<Complex> L(complex,alpha); + // Complexes built + + // verification + bool test1 = L.contains_vertex(*L.get_address(Root_vertex_handle(10))); + bool test2 = L.contains_vertex(*L.get_address(Root_vertex_handle(11))); + bool test3 = L.contains_vertex(*L.get_address(Root_vertex_handle(13))); + bool test4 = L.num_edges()==3; + bool test5 = L.num_blockers()==1; + Root_simplex_handle simplex; + simplex.add_vertex(Root_vertex_handle(10)); + simplex.add_vertex(Root_vertex_handle(11)); + simplex.add_vertex(Root_vertex_handle(13)); + bool test6 = L.contains_blocker(*(L.get_simplex_address(simplex))); + cerr <<"----> Ocomplex \n"; + return test1&&test2&&test3&&test4&&test5&&test6 ; + +} + +bool test_link5(){ + Complex complex(0,new Print_complex_visitor<Vertex_handle>()); + // Build the complexes + build_complete(4,complex); + complex.add_blocker(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)); + + Simplex_handle alpha(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)); + + + Skeleton_blocker_link_complex<Complex> L(complex,alpha); // Complexes built + + // Print result + PRINT(complex.to_string()); + cerr <<endl<<endl; + PRINT(L.to_string()); + + // verification + return L.num_vertices()==0; +} + +bool test_link6(){ + Complex complex(0,new Print_complex_visitor<Vertex_handle>()); + // Build the complexes + build_complete(4,complex); + complex.add_blocker(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)); + + Simplex_handle alpha(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)); + + Skeleton_blocker_link_complex<Complex> link_blocker_alpha; + + build_link_of_blocker(complex,alpha,link_blocker_alpha); + + // Print result + PRINT(complex.to_string()); + cerr <<endl<<endl; + PRINT(link_blocker_alpha.to_string()); + + // verification + return link_blocker_alpha.num_vertices()==1; +} + + +bool test_link7(){ + Complex complex(0,new Print_complex_visitor<Vertex_handle>()); + // Build the complexes + build_complete(6,complex); + complex.add_vertex(); + complex.add_vertex(); + for(int i = 3; i<6; ++i){ + complex.add_edge(Vertex_handle(i),Vertex_handle(6)); + complex.add_edge(Vertex_handle(i),Vertex_handle(7)); + } + complex.add_edge(Vertex_handle(6),Vertex_handle(7)); + complex.add_blocker(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)); + complex.add_blocker(Vertex_handle(3),Vertex_handle(4),Vertex_handle(5)); + + Simplex_handle alpha(Vertex_handle(3),Vertex_handle(4),Vertex_handle(5)); + + Skeleton_blocker_link_complex<Complex> link_blocker_alpha; + + build_link_of_blocker(complex,alpha,link_blocker_alpha); + + //the result should be the edge {6,7} plus the blocker {0,1,2} + + // Print result + PRINT(complex.to_string()); + cerr <<endl<<endl; + DBGVALUE(link_blocker_alpha.to_string()); + + Skeleton_blocker_link_complex<Complex> link_blocker_alpha_cpy = link_blocker_alpha; + + DBGVALUE(link_blocker_alpha_cpy.to_string()); + + bool equal_complexes = + (link_blocker_alpha.num_vertices() == link_blocker_alpha_cpy.num_vertices()) + &&(link_blocker_alpha.num_blockers() == link_blocker_alpha_cpy.num_blockers()) + &&(link_blocker_alpha.num_edges() == link_blocker_alpha_cpy.num_edges()) + ; + DBGVALUE((link_blocker_alpha.num_blockers() == link_blocker_alpha_cpy.num_blockers())); + DBGVALUE((link_blocker_alpha.num_blockers() )); + DBGVALUE(( link_blocker_alpha_cpy.num_blockers())); + + DBGVALUE(equal_complexes); + + // verification + return link_blocker_alpha.num_vertices()==5 && link_blocker_alpha.num_edges()==4 && link_blocker_alpha.num_blockers()==1 && equal_complexes; +} + + + + + + + + +template<typename SimplexHandle> +void add_triangle_edges(int a,int b,int c,list<SimplexHandle>& simplices){ + typedef SimplexHandle Simplex_handle; + typedef typename SimplexHandle::Vertex_handle Vertex_handle; + + simplices.push_back(Simplex_handle(Vertex_handle(a),Vertex_handle(b) )); + simplices.push_back(Simplex_handle(Vertex_handle(b),Vertex_handle(c) )); + simplices.push_back(Simplex_handle(Vertex_handle(c),Vertex_handle(a) )); +} + +template<typename SimplexHandle> +void add_triangle(int a,int b,int c,list<SimplexHandle>& simplices){ + typedef SimplexHandle Simplex_handle; + typedef typename SimplexHandle::Vertex_handle Vertex_handle; + simplices.push_back(Simplex_handle(Vertex_handle(a),Vertex_handle(b),Vertex_handle(c))); +} + +bool test_constructor(){ + list <Simplex_handle> simplices; + + simplices.push_back(Simplex_handle(Vertex_handle(0))); + simplices.push_back(Simplex_handle(Vertex_handle(1))); + simplices.push_back(Simplex_handle(Vertex_handle(2))); + simplices.push_back(Simplex_handle(Vertex_handle(3))); + simplices.push_back(Simplex_handle(Vertex_handle(4))); + simplices.push_back(Simplex_handle(Vertex_handle(5))); + + simplices.push_back(Simplex_handle(Vertex_handle(3),Vertex_handle(5) )); + + add_triangle_edges(0,1,5,simplices); + add_triangle_edges(1,2,3,simplices); + add_triangle_edges(2,3,4,simplices); + add_triangle_edges(1,3,4,simplices); + add_triangle_edges(1,2,4,simplices); + + + add_triangle(0,1,5,simplices); + add_triangle(1,2,3,simplices); + add_triangle(2,3,4,simplices); + add_triangle(1,3,4,simplices); + add_triangle(1,2,4,simplices); + + + Complex complex(simplices); + + PRINT(complex.to_string()); + + return ( complex.num_vertices()==6&&complex.num_edges()==10&& complex.num_blockers()==2); +} + + +list<Simplex_handle> subfaces(Simplex_handle top_face){ + list<Simplex_handle> res; + if(top_face.dimension()==-1) return res; + if(top_face.dimension()==0) { + res.push_back(top_face); + return res; + } + else{ + Vertex_handle first_vertex = top_face.first_vertex(); + top_face.remove_vertex(first_vertex); + res = subfaces(top_face); + list<Simplex_handle> copy = res; + for(auto& simplex : copy){ + simplex.add_vertex(first_vertex); + } + res.push_back(Simplex_handle(first_vertex)); + res.splice(res.end(),copy); + return res; + } +} + + +bool test_constructor2(){ + Simplex_handle simplex; + for(int i =0 ; i < 5;++i) + simplex.add_vertex(i); + + list <Simplex_handle> simplices(subfaces(simplex)); + simplices.remove(simplex); + + Complex complex(simplices); + + PRINT(complex.to_string()); + + for(auto b : complex.const_blocker_range()){ + cout << "b:"<<b<<endl; + } + + return ( complex.num_vertices()==5&&complex.num_edges()==10&& complex.num_blockers()==1); +} + + + + +int main (int argc, char *argv[]) +{ + Tests tests_complex; + tests_complex.add("test simplex",test_simplex); + tests_complex.add("test_link0",test_link0); + tests_complex.add("test_link1",test_link1); + tests_complex.add("test_link2",test_link2); + tests_complex.add("test_link3",test_link3); + tests_complex.add("test_link4",test_link4); + tests_complex.add("test_link5",test_link5); + tests_complex.add("test_link6",test_link6); + tests_complex.add("test_link7",test_link7); + + tests_complex.add("test iterator vertices 1",test_iterator_vertices1); + tests_complex.add("test iterator vertices 2",test_iterator_vertices2); + tests_complex.add("test iterator edges",test_iterator_edge); + tests_complex.add("test iterator edges 2",test_iterator_edge2); + tests_complex.add("test iterator edges 3",test_iterator_edge3); + + tests_complex.add("test iterator simplices",test_iterator_simplices); + tests_complex.add("test iterator simplices2",test_iterator_simplices2); + tests_complex.add("test iterator simplices3",test_iterator_simplices3); + tests_complex.add("test iterator simplices4",test_iterator_simplices4); + + + tests_complex.add("test iterator blockers",test_iterator_blockers); + tests_complex.add("test_iterator_triangles",test_iterator_triangles); + + tests_complex.add("test_constructor_list_simplices",test_constructor); + tests_complex.add("test_constructor_list_simplices2",test_constructor2); + + if(tests_complex.run()){ + return EXIT_SUCCESS; + } + else{ + return EXIT_FAILURE; + } + + // test_iterator_simplices(); +} + |