AffinePseudoSphereArrangement.h

//-----------------------------------------------------------------------------
//
// Module:       AffinePseudoSphereArrangement.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Affine pseudo-sphere arrangement.
//
// Note:         1) Only the bounded faces that are above the infinity equator
//                  are stored.
//
// Todo:         *) Which is more efficient in finding the vertices of a cell?
//                  a) Iterate the vertices and keep the ones that are
//                     conformal to the cell.
//                  b) Try all signed sets by setting (r-2) elements of the 
//                     cell to 0, keep the ones that are vertices.
//               *) Dump option for dimensions other than 3. It is much harder
//                  in dimensions beyond 3, because a polytope can not be 
//                  uniquely represented by its skeleton any more.
//
// Change log:
//   09-06-25    Created.
//
//-----------------------------------------------------------------------------

#ifndef OMC_AFFINE_PSEUDO_SPHERE_ARRANGEMENT_H
#define OMC_AFFINE_PSEUDO_SPHERE_ARRANGEMENT_H

#include "PseudoSphereArrangement.h"
#include "AffineObject.h"
#include "AffineCircuits.h"
#include "OMCGraph.h"
#include "Combination.h"
#include <iostream>
#include <set>
#include <map>

namespace omc 
{
  class AffinePseudoSphereArrangement 
    : public PseudoSphereArrangement, public AffineObject
  {
  public:
    AffinePseudoSphereArrangement (Circuits &, index_t);  // constructors
    AffinePseudoSphereArrangement (AffineCircuits &);

    ~AffinePseudoSphereArrangement () {};                 // destructor

    size_t getNumBoundedCells () const;        // get the # of bounded cells
    size_t getNumBoundedFacets () const;       // get the # of bounded facets
    size_t getNumExternalFacets () const;      // get the # of external facets
    size_t getNumBoundedEdges () const;        // get the # of bounded edges
    size_t getNumBoundedVertices () const;     // get the # of bounded vertices

    void setInfinityElement (index_t);         // set the infinity element

    double averageDiameter (bool dump=false);  // compute the average diameter

    // Iterators.
    typedef std::set<SignedSet>::iterator bounded_cell_iterator;
    bounded_cell_iterator bounded_cell_begin ();
    bounded_cell_iterator bounded_cell_end ();

    typedef std::set<SignedSet>::reverse_iterator 
      reverse_bounded_cell_iterator;
    reverse_bounded_cell_iterator bounded_cell_rbegin ();
    reverse_bounded_cell_iterator bounded_cell_rend ();

    typedef std::set<SignedSet>::iterator bounded_facet_iterator;
    bounded_facet_iterator bounded_facet_begin ();
    bounded_facet_iterator bounded_facet_end ();

    typedef std::set<SignedSet>::reverse_iterator 
      reverse_bounded_facet_iterator;
    reverse_bounded_facet_iterator bounded_facet_rbegin ();
    reverse_bounded_facet_iterator bounded_facet_rend ();

    typedef std::set<SignedSet>::iterator external_facet_iterator;
    external_facet_iterator external_facet_begin ();
    external_facet_iterator external_facet_end ();

    typedef std::set<SignedSet>::reverse_iterator 
      reverse_external_facet_iterator;
    reverse_external_facet_iterator external_facet_rbegin ();
    reverse_external_facet_iterator external_facet_rend ();

    typedef std::set<SignedSet>::iterator bounded_edge_iterator;
    bounded_edge_iterator bounded_edge_begin ();
    bounded_edge_iterator bounded_edge_end ();

    typedef std::set<SignedSet>::reverse_iterator 
      reverse_bounded_edge_iterator;
    reverse_bounded_edge_iterator bounded_edge_rbegin ();
    reverse_bounded_edge_iterator bounded_edge_rend ();

    typedef std::set<SignedSet>::iterator bounded_vertex_iterator;
    bounded_vertex_iterator bounded_vertex_begin ();
    bounded_vertex_iterator bounded_vertex_end ();

    typedef std::set<SignedSet>::reverse_iterator 
      reverse_bounded_vertex_iterator;
    reverse_bounded_vertex_iterator bounded_vertex_rbegin ();
    reverse_bounded_vertex_iterator bounded_vertex_rend ();

  protected:
    std::set <SignedSet> m_BoundedCell;   // set of covectors of bounded cells
    std::set <SignedSet> m_BoundedFacet;  // set of covectors of bounded facets
    std::set <SignedSet> m_ExternalFacet; // set of covectors of external facets
    std::set <SignedSet> m_BoundedEdge;   // set of covectors of bounded edges
    std::set <SignedSet> m_BoundedVertex; // set of covectors of bounded vertices
    
    void updateBoundedFaces ();           // update bounded faces

    std::map <std::string, int> m_CellCounter; // rough counter
    std::map <std::string, std::map<std::string,int> > m_ExtraCellCounter;   
                                          // finer counter

    void recordCellType (const OMCGraph &); // record cell info for dump
    void dumpCellTypes ();                  // dump cell info

  private:
    std::set <SignedSet> m_InfinityVertex;  // vectors of vertices at infinity

  }; // class AffinePseudoSphereArrangement
  
  // Output stream overloading.
  std::ostream & operator<< (std::ostream &, AffinePseudoSphereArrangement &);


  inline AffinePseudoSphereArrangement::AffinePseudoSphereArrangement 
    (Circuits & C, index_t i) 
    : PseudoSphereArrangement (C), AffineObject (i)
  {
    updateBoundedFaces ();
  }

  inline AffinePseudoSphereArrangement::AffinePseudoSphereArrangement 
    (AffineCircuits & C) 
    : PseudoSphereArrangement (C), AffineObject (C.getInfinityElement())
  {
    updateBoundedFaces ();
  }
    

  inline size_t AffinePseudoSphereArrangement::getNumBoundedCells () const {
    return m_BoundedCell.size ();
  }

  inline size_t AffinePseudoSphereArrangement::getNumBoundedFacets () const {
    return m_BoundedFacet.size ();
  }

  inline size_t AffinePseudoSphereArrangement::getNumExternalFacets () const {
    return m_ExternalFacet.size ();
  }

  inline size_t AffinePseudoSphereArrangement::getNumBoundedEdges () const {
    return m_BoundedEdge.size ();
  }

  inline size_t AffinePseudoSphereArrangement::getNumBoundedVertices () const {
    return m_BoundedVertex.size ();
  }

  inline void AffinePseudoSphereArrangement::setInfinityElement (index_t i) {
    AffineObject::setInfinityElement (i);
    updateBoundedFaces (); // bounded faces need to be updated
  }

  inline AffinePseudoSphereArrangement::bounded_cell_iterator 
  AffinePseudoSphereArrangement::bounded_cell_begin ()
  {
    return m_BoundedCell.begin ();
  }

  inline AffinePseudoSphereArrangement::bounded_cell_iterator 
  AffinePseudoSphereArrangement::bounded_cell_end () 
  {
    return m_BoundedCell.end ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_cell_iterator 
  AffinePseudoSphereArrangement::bounded_cell_rbegin ()
  {
    return m_BoundedCell.rbegin ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_cell_iterator 
  AffinePseudoSphereArrangement::bounded_cell_rend () 
  {
    return m_BoundedCell.rend ();
  }

  inline AffinePseudoSphereArrangement::bounded_facet_iterator 
  AffinePseudoSphereArrangement::bounded_facet_begin ()
  {
    return m_BoundedFacet.begin ();
  }

  inline AffinePseudoSphereArrangement::bounded_facet_iterator 
  AffinePseudoSphereArrangement::bounded_facet_end () 
  {
    return m_BoundedFacet.end ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_facet_iterator 
  AffinePseudoSphereArrangement::bounded_facet_rbegin ()
  {
    return m_BoundedFacet.rbegin ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_facet_iterator 
  AffinePseudoSphereArrangement::bounded_facet_rend () 
  {
    return m_BoundedFacet.rend ();
  }

  inline AffinePseudoSphereArrangement::external_facet_iterator 
  AffinePseudoSphereArrangement::external_facet_begin ()
  {
    return m_ExternalFacet.begin ();
  }

  inline AffinePseudoSphereArrangement::external_facet_iterator 
  AffinePseudoSphereArrangement::external_facet_end () 
  {
    return m_ExternalFacet.end ();
  }

  inline AffinePseudoSphereArrangement::reverse_external_facet_iterator 
  AffinePseudoSphereArrangement::external_facet_rbegin ()
  {
    return m_ExternalFacet.rbegin ();
  }

  inline AffinePseudoSphereArrangement::reverse_external_facet_iterator 
  AffinePseudoSphereArrangement::external_facet_rend () 
  {
    return m_ExternalFacet.rend ();
  }

  inline AffinePseudoSphereArrangement::bounded_edge_iterator 
  AffinePseudoSphereArrangement::bounded_edge_begin ()
  {
    return m_BoundedEdge.begin ();
  }

  inline AffinePseudoSphereArrangement::bounded_edge_iterator 
  AffinePseudoSphereArrangement::bounded_edge_end () 
  {
    return m_BoundedEdge.end ();
  }
  
  inline AffinePseudoSphereArrangement::reverse_bounded_edge_iterator 
  AffinePseudoSphereArrangement::bounded_edge_rbegin ()
  {
    return m_BoundedEdge.rbegin ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_edge_iterator 
  AffinePseudoSphereArrangement::bounded_edge_rend () 
  {
    return m_BoundedEdge.rend ();
  }
  
  inline AffinePseudoSphereArrangement::bounded_vertex_iterator 
  AffinePseudoSphereArrangement::bounded_vertex_begin ()
  {
    return m_BoundedVertex.begin ();
  }

  inline AffinePseudoSphereArrangement::bounded_vertex_iterator 
  AffinePseudoSphereArrangement::bounded_vertex_end () 
  {
    return m_BoundedVertex.end ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_vertex_iterator 
  AffinePseudoSphereArrangement::bounded_vertex_rbegin ()
  {
    return m_BoundedVertex.rbegin ();
  }

  inline AffinePseudoSphereArrangement::reverse_bounded_vertex_iterator 
  AffinePseudoSphereArrangement::bounded_vertex_rend () 
  {
    return m_BoundedVertex.rend ();
  }

}; // namespace omc

#endif // OMC_AFFINE_PSEUDO_SPHERE_ARRANGEMENT_H

---