X-Git-Url: https://git.sthu.org/?a=blobdiff_plain;f=tests%2Fsimplicialcomplex.h;h=91d1c55532b2c6e1080efea3fd558fa3adb45aef;hb=HEAD;hp=fa829e1f31dfa08ed02f9641ff7369feaee3a0e1;hpb=267194caeb2fe56530b11c440fefd01c344e5482;p=libstick.git

diff --git a/tests/simplicialcomplex.h b/tests/simplicialcomplex.h
index fa829e1..91d1c55 100644
--- a/tests/simplicialcomplex.h
+++ b/tests/simplicialcomplex.h
@@ -4,34 +4,37 @@
 #include <cpptest.h>
 #include <cpptest-suite.h>
 
-#include <libstick-0.1/simplicialcomplex.h>
+#include <libstick/simplicialfunction.h>
 
 using namespace libstick;
 
 
-class SimplicialComplexTestSuite: public Test::Suite {
+class simplicial_complex_TestSuite: public Test::Suite {
 
     private:
-        typedef SimplicialComplex<2, uint32_t, double> scomplex;
-        typedef scomplex::SimplexOrder::BoundaryMatrix bm;
+        typedef simplicial_function<3, uint32_t, double> sfunction;
+        typedef sfunction::scomplex scomplex;
+        typedef scomplex::simplex_order::boundary_matrix bm;
 
         bool setupcalled;
-        scomplex c1, c2, c3;
-        scomplex::SimplexOrder o1, o2, o3, o3b;
+        scomplex c;
+        sfunction f1, f2, f3;
+        scomplex::simplex_order o1, o3b;
 
     public:
-        SimplicialComplexTestSuite() :
+        simplicial_complex_TestSuite() :
             setupcalled(false),
-            o1(c1),
-            o2(c2),
-            o3(c3),
-            o3b(c3)
+            f1(c),
+            f2(c),
+            f3(c),
+            o1(c),
+            o3b(c)
             {
-            TEST_ADD(SimplicialComplexTestSuite::test_isComplex);
-            TEST_ADD(SimplicialComplexTestSuite::test_isMonotoneComplex);
-            TEST_ADD(SimplicialComplexTestSuite::test_isOrderFiltration);
-            TEST_ADD(SimplicialComplexTestSuite::test_isOrderMonotone);
-            TEST_ADD(SimplicialComplexTestSuite::test_boundaryMatrix);
+            TEST_ADD(simplicial_complex_TestSuite::test_is_complex);
+            TEST_ADD(simplicial_complex_TestSuite::test_is_function_monotone);
+            TEST_ADD(simplicial_complex_TestSuite::test_is_order_filtration);
+            TEST_ADD(simplicial_complex_TestSuite::test_is_order_monotone);
+            TEST_ADD(simplicial_complex_TestSuite::test_boundary_matrix);
         }
 
     protected:
@@ -40,128 +43,102 @@ class SimplicialComplexTestSuite: public Test::Suite {
                 return;
             setupcalled = true;
 
-            const unsigned num = 11;
-            scomplex::Simplex ss[num] = {
-                // dimension, faces, value...
-                {0, {0, 0, 0}, 0},
-                {0, {0, 0, 0}, 1},
-                {0, {0, 0, 0}, 2},
-                {0, {0, 0, 0}, 3},
-                {1, {0, 1, 0}, 4},
-                {1, {1, 2, 0}, 5},
-                {1, {2, 3, 0}, 6},
-                {1, {3, 0, 0}, 7},
-                {1, {0, 2, 0}, 8},
-                {2, {6, 7, 8}, 9},
-                {2, {4, 5, 8}, 10}
+            typedef sfunction::valuedsimplex vsimpl;
+
+            sfunction::valuedsimplex ss[] = {
+                // {dimension, faces}, value
+                {{0, {}}, 1},
+                {{0, {}}, 2},
+                {{0, {}}, 3},
+                {{0, {}}, 4},
+                {{1, {1, 2}}, 5},
+                {{1, {2, 3}}, 6},
+                {{1, {3, 4}}, 7},
+                {{1, {4, 1}}, 8},
+                {{1, {1, 3}}, 9},
+                {{2, {7, 8, 9}}, 10},
+                {{2, {5, 6, 9}}, 11}
             };
+            const size_t cntss = sizeof(ss)/sizeof(sfunction::valuedsimplex);
+            f1.add_simplices(ss, cntss);
 
-            //  This is o1        This is o2         This is o3(b)
+            //  This is f1        This is f2         This is f3
             //  (value = index)   (values)           (values)
             //
-            //  0  ----4---- 1    0  ----4---- 1     0  ----4---- 1
-            //  |\           |    |\           |     |\           |
-            //  |  \     10  |    |  \     10  |     |  \     12  |
-            //  |    \       |    |    \       |     |    \       |
-            //  |      \     |    |      \     |     |      \     |
-            //  7       8    5    7       8    11    7       8    11
-            //  |        \   |    |        \   |     |        \   |
-            //  |   9     \  |    |   9     \  |     |   9     \  |
-            //  |          \ |    |          \ |     |          \ |
-            //  |           \|    |           \|     |           \|
-            //  3  ----6---- 2    3  ----6---- 2     3  ----6---- 2
-
-            // Build the complex
-            for (unsigned i=0; i<num; ++i)
-                c1.addSimplex(ss[i]);
-
-            c2 = c1;
-            c2.simplices[5].value = 11;
-
-            c3 = c2;
-            c3.simplices[10].value = 12;
-
+            //  1 ----5---- 2    1 ----5---- 2     1 ----5---- 2
+            //  |\          |    |\          |     |\          |
+            //  | \     11  |    | \     11  |     | \     13  |
+            //  |   \       |    |   \       |     |   \       |
+            //  |     \     |    |     \     |     |     \     |
+            //  8      9    6    8      9    12    8      9    12
+            //  |       \   |    |       \   |     |       \   |
+            //  |  10    \  |    |  10    \  |     |  10    \  |
+            //  |         \ |    |         \ |     |         \ |
+            //  |          \|    |          \|     |          \|
+            //  4 ----7---- 3    4 ----7---- 3     4 ----7---- 3
+
+            // Copy and change the function values
+            f2.set_values(f1.get_values());
+            f2.set_value(6, 12);
+
+            f3.set_values(f2.get_values());
+            f3.set_value(11, 13);
+
+            // Get two orders, the one is a monotone filtration
             o1.reset();
-            o2.reset();
-            o3.reset();
             o3b.reset();
-            o3b.makeMonotoneFiltration();
+            f3.make_order_monotonefiltration(o3b);
         }
 
         virtual void tear_down() {
         }
 
-        void test_isComplex() {
-            TEST_ASSERT(c1.isComplex());
-            TEST_ASSERT(c2.isComplex());
-            TEST_ASSERT(c3.isComplex());
+        void test_is_complex() {
+            TEST_ASSERT(c.is_complex());
         }
 
-        void test_isMonotoneComplex() {
-            TEST_ASSERT(c1.isMonotone());
-            TEST_ASSERT(!c2.isMonotone());
-            TEST_ASSERT(c3.isMonotone());
+        void test_is_function_monotone() {
+            TEST_ASSERT(f1.is_monotone());
+            TEST_ASSERT(!f2.is_monotone());
+            TEST_ASSERT(f3.is_monotone());
         }
 
-        void test_isOrderFiltration() {
-            TEST_ASSERT(o1.isFiltration());
-            TEST_ASSERT(o2.isFiltration());
-            TEST_ASSERT(o3.isFiltration());
-            TEST_ASSERT(o3b.isFiltration());
+        void test_is_order_filtration() {
+            TEST_ASSERT(o1.is_filtration());
+            TEST_ASSERT(o3b.is_filtration());
         }
 
-        void test_isOrderMonotone() {
-            TEST_ASSERT(o1.isMonotone());
-            TEST_ASSERT(!o2.isMonotone());
-            TEST_ASSERT(!o3.isMonotone());
-            TEST_ASSERT(o3b.isMonotone());
+        void test_is_order_monotone() {
+            TEST_ASSERT(f1.is_order_monotonefiltration(o1));
+            TEST_ASSERT(!f2.is_order_monotonefiltration(o1));
+            TEST_ASSERT(!f3.is_order_monotonefiltration(o1));
+            TEST_ASSERT(f3.is_order_monotonefiltration(o3b));
         }
 
-        void test_boundaryMatrix() {
-            bm mat1 = o1.getBoundaryMatrix();
-            bm mat1e(c1.size());
-            mat1e.set(0, 4, true);
-            mat1e.set(1, 4, true);
-            mat1e.set(1, 5, true);
-            mat1e.set(2, 5, true);
-            mat1e.set(2, 6, true);
-            mat1e.set(3, 6, true);
-            mat1e.set(3, 7, true);
-            mat1e.set(0, 7, true);
-            mat1e.set(0, 8, true);
-            mat1e.set(2, 8, true);
-            mat1e.set(6, 9, true);
-            mat1e.set(7, 9, true);
-            mat1e.set(8, 9, true);
-            mat1e.set(4, 10, true);
-            mat1e.set(5, 10, true);
-            mat1e.set(8, 10, true);
+        void test_boundary_matrix() {
+            bm mat1 = o1.get_boundary_matrix();
+            bm mat1e(c.size());
+            uint32_t mat1e_coords[][2] = {
+                    {0, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 5}, {2, 5}, {2, 6}, {3, 6}, {3, 7}, {4, 7}, {1, 8}, {4, 8},
+                    {1, 9}, {3, 9}, {7, 10}, {8, 10}, {9, 10}, {5, 11}, {6, 11}, {9, 11}
+            };
+            mat1e.set_all(mat1e_coords, sizeof(mat1e_coords)/(2*sizeof(uint32_t)), true);
             TEST_ASSERT(mat1 == mat1e);
 
-            bm mat3b = o3b.getBoundaryMatrix();
-            bm mat3be(c1.size());
-            mat3be.set(0, 4, true);
-            mat3be.set(1, 4, true);
-            mat3be.set(2, 5, true);
-            mat3be.set(3, 5, true);
-            mat3be.set(3, 6, true);
-            mat3be.set(0, 6, true);
-            mat3be.set(0, 7, true);
-            mat3be.set(2, 7, true);
-            mat3be.set(5, 8, true);
-            mat3be.set(6, 8, true);
-            mat3be.set(7, 8, true);
-            mat3be.set(1, 9, true);
-            mat3be.set(2, 9, true);
-            mat3be.set(4, 10, true);
-            mat3be.set(7, 10, true);
-            mat3be.set(9, 10, true);
+
+            bm mat3b = o3b.get_boundary_matrix();
+            bm mat3be(c.size());
+            uint32_t mat3be_coords[][2] = {
+                    {0, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 5}, {2, 5}, {3, 6}, {4, 6}, {1, 7}, {4, 7}, {1, 8}, {3, 8},
+                    {6, 9}, {7, 9}, {8, 9}, {2, 10}, {3, 10}, {5, 11}, {8, 11}, {10, 11}
+            };
+            mat3be.set_all(mat3be_coords, sizeof(mat3be_coords)/(2*sizeof(uint32_t)), true);
+            TEST_ASSERT(mat3b == mat3be);
 
             //std::cout << mat3b << std::endl << std::endl;
+            //std::cout << mat3be << std::endl << std::endl;
             //std::cout << ((bm::colbase) mat3b) << std::endl << std::endl;
             //std::cout << ((bm::rowbase) mat3b) << std::endl << std::endl;
-
-            TEST_ASSERT(mat3b == mat3be);
         }
 };