X-Git-Url: https://git.sthu.org/?a=blobdiff_plain;f=include%2Flibstick-0.1%2Fsimplicialcomplex.h;h=482e12d3edbcd13b46fe3f0f9eb2feee48562273;hb=8bd91d327a3ab6dee59f09556c5e93f3144bf2dd;hp=47a88c64907cb29054cb6d22d78c49df9e0bb08b;hpb=88ea14f1e9079c9b8c4af7aff01a3fe960e9472b;p=libstick.git diff --git a/include/libstick-0.1/simplicialcomplex.h b/include/libstick-0.1/simplicialcomplex.h index 47a88c6..482e12d 100644 --- a/include/libstick-0.1/simplicialcomplex.h +++ b/include/libstick-0.1/simplicialcomplex.h @@ -10,7 +10,7 @@ #include -#include +#include "booleanmatrix.h" namespace libstick { @@ -23,7 +23,7 @@ namespace libstick { * Each 0-dimensional simplex automatically has this simplex as its face. * Consequently, the innner class simplex_order gives the extended boundary * matrix. */ -template +template class simplicial_complex { public: @@ -36,7 +36,7 @@ class simplicial_complex { typedef VT value_type; /** A simplex of the complex. */ - struct Simplex { + struct simplex { /** Dimension of the simplex. */ int dim; /** The indices of the faces of the simplex. */ @@ -47,10 +47,10 @@ class simplicial_complex { /** Create a new simplex with dimension 'dim', (dim+1)-faces and * its value. If simpley is 0-dimensional, its face is * automatically set to one (-1)-dimensional simplex. */ - static Simplex create(int dim, index_type* faces, value_type value) { + static simplex create(int dim, index_type* faces, value_type value) { assert(0 <= dim && dim <= MAXDIM); - Simplex s; + simplex s; s.dim = dim; s.value = value; @@ -63,8 +63,8 @@ class simplicial_complex { } /** Create a (-1)-dimensional simplex. It has the lowest possible value. */ - static Simplex create_minusonedim_simplex() { - Simplex s; + static simplex create_minusonedim_simplex() { + simplex s; s.dim = -1; s.faces[0] = 0; @@ -92,7 +92,7 @@ class simplicial_complex { class simplex_order { public: - typedef boolean_colrowmatrix boundary_matrix; + typedef boolean_colmatrix boundary_matrix; /** Create a standard order of the complex c, i.e., the identity permutation. */ simplex_order(const simplcompltype &c) : @@ -116,7 +116,7 @@ class simplicial_complex { } /** Get i-th simplex in the simplex order. */ - const Simplex& get_simplex(size_t i) const { + const simplex& get_simplex(index_type i) const { assert(i < size()); return c.simplices[order.at(i)]; } @@ -195,7 +195,12 @@ class simplicial_complex { public: simplicial_complex() { // Add the one minus-one dimensional simplex - add_simplex(Simplex::create_minusonedim_simplex()); + add_simplex(simplex::create_minusonedim_simplex()); + } + + /** Remove all simplices except the dummy simplex */ + void clear() { + simplices.resize(1); } /** Return number of simplices. */ @@ -204,14 +209,31 @@ class simplicial_complex { } /** Add a simplex to the complex. The dimension of the faces must be - * dim-1, and they must already be part of the complex. */ - void add_simplex(int dim, index_type* faces, value_type value) { - add_simplex(Simplex::create(dim, faces, value)); + * dim-1, and they must already be part of the complex. Returns the + * index of the added simplex. */ + index_type add_simplex(int dim, index_type* faces, value_type value) { + return add_simplex(simplex::create(dim, faces, value)); + } + + /** Add a simplex to the complex of at least dimension 1. The dimension + * of the faces must be dim-1, and they must already be part of the + * complex. The value of the simplex is set to the maximum value of its + * faces. Returns the index of the added simplex. */ + index_type add_simplex(int dim, index_type* faces) { + assert(dim >= 1); + + // Get max value of its faces + VT value = simplices[faces[0]].value; + for (size_t i=0; i < simplex::face_count_bydim(dim); ++i) + value = std::max(value, simplices[faces[i]].value); + + return add_simplex(dim, faces, value); } /** Add a simplex to the complex. The dimension of the faces must be - * dim-1, and they must already be part of the complex. */ - void add_simplex(Simplex s) { + * dim-1, and they must already be part of the complex. Returns the + * index of the added simplex. */ + index_type add_simplex(simplex s) { // Check requirements for faces for (unsigned i=0; i < s.face_count(); ++i) { // Faces are already in complex. @@ -220,7 +242,18 @@ class simplicial_complex { assert(simplices[s.faces[i]].dim == s.dim-1); } + // index_type must be large enough + assert(simplices.size() < std::numeric_limits::max()); + + index_type idx = simplices.size(); simplices.push_back(s); + return idx; + } + + /** Add an array of simplices */ + void add_simplices(simplex* sarray, size_t count) { + for (unsigned i=0; i < count; ++i) + add_simplex(sarray[i]); } /** Return true iff for each simplex i with dimension dim it holds that @@ -228,13 +261,13 @@ class simplicial_complex { bool is_complex() const { for (unsigned i=0; i < size(); ++i) { - const Simplex &s = simplices[i]; + const simplex &s = simplices[i]; for (unsigned f=0; f < s.face_count(); ++f) { if (s.faces[f] >= size()) return false; - const Simplex &face = simplices[s.faces[f]]; + const simplex &face = simplices[s.faces[f]]; if (face.dim != s.dim-1) return false; } @@ -248,7 +281,7 @@ class simplicial_complex { bool is_monotone() const { assert(is_complex()); - typename std::vector::const_iterator it = ++simplices.begin(); + typename std::vector::const_iterator it = ++simplices.begin(); for (; it != simplices.end(); ++it) for (unsigned f=0; f < it->face_count(); ++f) if (simplices[it->faces[f]].value > it->value) @@ -269,8 +302,8 @@ class simplicial_complex { } bool operator()(index_type i, index_type j) { - const Simplex& si = c.simplices[i]; - const Simplex& sj = c.simplices[j]; + const simplex& si = c.simplices[i]; + const simplex& sj = c.simplices[j]; if (si.value < sj.value) return true; @@ -283,7 +316,7 @@ class simplicial_complex { public: /** A list of simplices */ - std::vector simplices; + std::vector simplices; }; }