X-Git-Url: https://git.sthu.org/?p=libstick.git;a=blobdiff_plain;f=include%2Flibstick-0.1%2Fsimplicialcomplex.h;h=1183a92d699dfa896853e8148abb988f3ca06ed4;hp=988c090f56fb2378ad43044418b1fc7e0b6f0b98;hb=2dbba971939606ec3cc2bbd07978ff61e9566d01;hpb=4b8265e5bcfd2332a3333c4129352e10c2d59c2f

diff --git a/include/libstick-0.1/simplicialcomplex.h b/include/libstick-0.1/simplicialcomplex.h
index 988c090..1183a92 100644
--- a/include/libstick-0.1/simplicialcomplex.h
+++ b/include/libstick-0.1/simplicialcomplex.h
@@ -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;
@@ -116,7 +116,7 @@ class simplicial_complex {
                 }
 
                 /** Get i-th simplex in the simplex order. */
-                const Simplex& get_simplex(index_type i) const {
+                const simplex& get_simplex(index_type i) const {
                     assert(i < size());
                     return c.simplices[order.at(i)];
                 }
@@ -195,7 +195,7 @@ 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());
         }
 
         /** Return number of simplices. */
@@ -207,7 +207,7 @@ class simplicial_complex {
          * 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));
+            return add_simplex(simplex::create(dim, faces, value));
         }
 
         /** Add a simplex to the complex of at least dimension 1. The dimension
@@ -219,7 +219,7 @@ class simplicial_complex {
 
             // Get max value of its faces
             VT value = simplices[faces[0]].value;
-            for (size_t i=0; i < Simplex::face_count_bydim(dim); ++i)
+            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);
@@ -228,7 +228,7 @@ 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. Returns the
          * index of the added simplex. */
-        index_type add_simplex(Simplex s) {
+        index_type add_simplex(simplex s) {
             // Check requirements for faces
             for (unsigned i=0; i < s.face_count(); ++i) {
                 // Faces are already in complex.
@@ -246,7 +246,7 @@ class simplicial_complex {
         }
 
         /** Add an array of simplices */
-        void add_simplices(Simplex* sarray, size_t count) {
+        void add_simplices(simplex* sarray, size_t count) {
             for (unsigned i=0; i < count; ++i)
                 add_simplex(sarray[i]);
         }
@@ -256,13 +256,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;
                 }
@@ -276,7 +276,7 @@ class simplicial_complex {
         bool is_monotone() const {
             assert(is_complex());
 
-            typename std::vector<Simplex>::const_iterator it = ++simplices.begin();
+            typename std::vector<simplex>::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)
@@ -297,8 +297,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;
@@ -311,7 +311,7 @@ class simplicial_complex {
 
     public:
         /** A list of simplices */
-        std::vector<Simplex> simplices;
+        std::vector<simplex> simplices;
 };
 
 }