elem/Simplex.hpp

#ifndef __SIMPLEX_HPP__
#define __SIMPLEX_HPP__

#include <algorithm>
#include <boost/array.hpp>

namespace DAPTA { // Define namespace DAPTA


template <typename V, int N>
class Simplex {
   public:
      typedef V*         VertexHandle;  
      
      static const int num_vertices = N;
      
      // No default constructor as the simplex must be setup with vertices as they need to be ordered
      Simplex(boost::array<VertexHandle,num_vertices> _vertices) : vertices(_vertices) { ; }
      ~Simplex() {;}

      bool operator<(const Simplex<V,N>& f2) const {
         return (this->OrderedVertices() < f2.OrderedVertices());
      }
      
      bool operator==(const Simplex<V,N>& f2) const {
         return (this->OrderedVertices() == f2.OrderedVertices());
      }
      
      const Simplex<V,N> operator!() const {
         Simplex<V,N> ret = *this;
         
         boost::array<VertexHandle,num_vertices> rev_vertices;
         std::reverse_copy(vertices.begin(), vertices.end(), rev_vertices.begin());
         
         ret.vertices = rev_vertices;
         
         return ret;
      }
      
      void sort() {
         int lowest=0;
         for(int i=1; i<num_vertices; i++)
            if(vertices.at(i) < vertices.at(lowest))
               lowest = i;
         
         if(lowest != 0) {
            boost::array<VertexHandle,num_vertices> ordered_vertices;
            for(int i=0; i<num_vertices; i++) {
               ordered_vertices.at(i) = vertices.at((i+lowest)%num_vertices);
            }
            vertices = ordered_vertices;
         }
      }
      
      boost::array<VertexHandle,num_vertices> OrderedVertices() const {
         if(N < 3) return vertices;
         else {
            boost::array<VertexHandle,num_vertices> ordered_vertices = vertices;
            
            int lowest=0;
            for(int i=1; i<num_vertices; i++)
               if(vertices.at(i) < vertices.at(lowest))
                  lowest = i;
            
            if(lowest != 0) {
               for(int i=0; i<num_vertices; i++) {
                  ordered_vertices.at(i) = vertices.at((i+lowest)%num_vertices);
               }
            }
            
            return ordered_vertices;
         }
      }
      
      boost::array<VertexHandle,num_vertices> vertices;
   private:
};

} // namespace DAPTA

#include "Simplex.cpp"

#endif

---