PseudoSphereArrangement.h

//-----------------------------------------------------------------------------
//
// Module:       PseudoSphereArrangement.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Pseudo-sphere arrangement.
//
// Note:         1) Pseudo-sphere arrangement is represented by covectors.
//               2) Only the positive vectors are used to represent cells,
//                  edges, vertices and etc. And all the getNumXxx() methods
//                  count only the positive ones.
//
// Todo:         1) Currently the set of edges are computed by assuming the
//                  underlying OM is uniform. Change it for general OM's.
//               2) Change the argument of constructor to "const Circuit &".
//
// Change log:
//   09-06-24    Created.
//
//-----------------------------------------------------------------------------

#ifndef OMC_PSEUDO_SPHERE_ARRANGEMENT_H
#define OMC_PSEUDO_SPHERE_ARRANGEMENT_H

#include "Vectors.h"
#include <iostream>
#include <set>

namespace omc 
{
  class PseudoSphereArrangement {
  public:
    PseudoSphereArrangement (Circuits &);               // constructor

    ~PseudoSphereArrangement () {};                     // destructor

    size_t getRank () const;            // get the rank of the underlying OM
    size_t getNumSpheres () const;      // get the # of pseudospheres
    size_t getNumCells () const;        // get the # of cells
    size_t getNumFacets () const;       // get the # of facets
    size_t getNumEdges () const;        // get the # of edges
    size_t getNumVertices () const;     // get the # of vertices

    // Iterators.
    typedef std::set<SignedSet>::iterator cell_iterator;
    cell_iterator cell_begin ();
    cell_iterator cell_end ();

    typedef std::set<SignedSet>::reverse_iterator reverse_cell_iterator;
    reverse_cell_iterator cell_rbegin ();
    reverse_cell_iterator cell_rend ();

    typedef std::set<SignedSet>::iterator facet_iterator;
    cell_iterator facet_begin ();
    cell_iterator facet_end ();

    typedef std::set<SignedSet>::reverse_iterator reverse_facet_iterator;
    reverse_cell_iterator facet_rbegin ();
    reverse_cell_iterator facet_rend ();

    typedef std::set<SignedSet>::iterator edge_iterator;
    edge_iterator edge_begin ();
    edge_iterator edge_end ();

    typedef std::set<SignedSet>::reverse_iterator reverse_edge_iterator;
    reverse_edge_iterator edge_rbegin ();
    reverse_edge_iterator edge_rend ();

    typedef std::set<SignedSet>::iterator vertex_iterator;
    vertex_iterator vertex_begin ();
    vertex_iterator vertex_end ();

    typedef std::set<SignedSet>::reverse_iterator reverse_vertex_iterator;
    reverse_vertex_iterator vertex_rbegin ();
    reverse_vertex_iterator vertex_rend ();

  protected:
    Vectors m_covectors;               // the vectors of the underlying OM

    std::set <SignedSet> m_Cell;     // set of vectors representing cells
    std::set <SignedSet> m_Facet;    // set of vectors representing facets
    std::set <SignedSet> m_Edge;     // set of vectors representing edges
    std::set <SignedSet> m_Vertex;   // set of vectors representing vertices

  }; // class PseudoSphereArrangement

  // Output stream overloading.
  std::ostream & operator<< (std::ostream &, PseudoSphereArrangement &);


  inline size_t PseudoSphereArrangement::getRank () const {
    return m_covectors.getRank ();
  }

  inline size_t PseudoSphereArrangement::getNumSpheres () const {
    return m_covectors.getNumElements ();
  }

  inline size_t PseudoSphereArrangement::getNumCells () const {
    return m_Cell.size ();
  }

  inline size_t PseudoSphereArrangement::getNumFacets () const {
    return m_Facet.size ();
  }

  inline size_t PseudoSphereArrangement::getNumEdges () const {
    return m_Edge.size ();
  }

  inline size_t PseudoSphereArrangement::getNumVertices () const {
    return m_Vertex.size ();
  }

  inline PseudoSphereArrangement::cell_iterator 
  PseudoSphereArrangement::cell_begin ()
  {
    return m_Cell.begin ();
  }

  inline PseudoSphereArrangement::cell_iterator 
  PseudoSphereArrangement::cell_end () 
  {
    return m_Cell.end ();
  }

  inline PseudoSphereArrangement::reverse_cell_iterator 
  PseudoSphereArrangement::cell_rbegin ()
  {
    return m_Cell.rbegin ();
  }

  inline PseudoSphereArrangement::reverse_cell_iterator 
  PseudoSphereArrangement::cell_rend () 
  {
    return m_Cell.rend ();
  }

  inline PseudoSphereArrangement::facet_iterator 
  PseudoSphereArrangement::facet_begin ()
  {
    return m_Facet.begin ();
  }

  inline PseudoSphereArrangement::facet_iterator 
  PseudoSphereArrangement::facet_end () 
  {
    return m_Facet.end ();
  }

  inline PseudoSphereArrangement::reverse_facet_iterator 
  PseudoSphereArrangement::facet_rbegin ()
  {
    return m_Facet.rbegin ();
  }

  inline PseudoSphereArrangement::reverse_facet_iterator 
  PseudoSphereArrangement::facet_rend () 
  {
    return m_Facet.rend ();
  }

  inline PseudoSphereArrangement::edge_iterator 
  PseudoSphereArrangement::edge_begin ()
  {
    return m_Edge.begin ();
  }

  inline PseudoSphereArrangement::edge_iterator 
  PseudoSphereArrangement::edge_end () 
  {
    return m_Edge.end ();
  }
  
  inline PseudoSphereArrangement::reverse_edge_iterator 
  PseudoSphereArrangement::edge_rbegin ()
  {
    return m_Edge.rbegin ();
  }

  inline PseudoSphereArrangement::reverse_edge_iterator 
  PseudoSphereArrangement::edge_rend () 
  {
    return m_Edge.rend ();
  }
  
  inline PseudoSphereArrangement::vertex_iterator 
  PseudoSphereArrangement::vertex_begin ()
  {
    return m_Vertex.begin ();
  }

  inline PseudoSphereArrangement::vertex_iterator 
  PseudoSphereArrangement::vertex_end () 
  {
    return m_Vertex.end ();
  }

  inline PseudoSphereArrangement::reverse_vertex_iterator 
  PseudoSphereArrangement::vertex_rbegin ()
  {
    return m_Vertex.rbegin ();
  }

  inline PseudoSphereArrangement::reverse_vertex_iterator 
  PseudoSphereArrangement::vertex_rend () 
  {
    return m_Vertex.rend ();
  }

}; // namespace omc

#endif // OMC_PSEUDO_SPHERE_ARRANGEMENT_H

---