#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:
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);
}
};