Chirotope.h

//-----------------------------------------------------------------------------
//
// Module:       Chirotope.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Chirotope.
//
// Note:
//   1) A basis of an (r,n)-chirotope is an r-tuple whose sign is nonzero.
//      So the iterator of bases will skip the r-tuples with zero sign.
//
// Todo:
//   *) Segment fault while using copy on basis_iterator. (copy constructor
//      not implemented?)
//   *) Implement relabel, reorient, remove, contract.
//
// Change log:
//   09-07-03    Created.
//   09-07-23    Add iterator for bases (basis_iterator).
//
//-----------------------------------------------------------------------------

#ifndef OMC_CHIROTOPE_H
#define OMC_CHIROTOPE_H

#include "Core.h"
#include "Tuple.h"
#include "SignedSet.h"
#include "OrientedMatroid.h"
#include "Verifiable.h"
#include "Combination.h"
#include "Permutation.h"
#include "Util.h"
#include <algorithm>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <typeinfo>

namespace omc 
{
  class Chirotope : public OrientedMatroid, Verifiable {
    friend inline std::ostream & operator<< (std::ostream &, Chirotope &);
    friend inline std::istream & operator>> (std::istream &, Chirotope &);
  
  public:
    Chirotope (size_t, size_t, OrientedMatroid::om_type);         // constructors
    Chirotope (size_t, size_t, std::string);
    Chirotope (const Chirotope &);      // copy constructor

    ~Chirotope () {};                   // destructor

    Chirotope* clone () const;          // "virtual constructor"

    sign_t getSign (const Tuple &) const; // get the sign of an r-tuple
    sign_t getSign (const std::string &) const; 

    void setSign (const Tuple &, sign_t); // set the sign of an r-tuple
    void setSign (const std::string &, sign_t); 

    void setSigns (std::string);        // set the signs

    void relabel (index_t, index_t);    // implement OrientedMatroid::relabel
    void relabel (const Permutation &); 

    void reorient (index_t);            // implement OrientedMatroid::reorient
    void reorient (const std::set<index_t> &);
    void reorient (const Combination &);

    void remove (index_t);              // implement OrientedMatroid::remove
    void contract (index_t);            // implement OrientedMatroid::contract

    bool operator== (const OrientedMatroid &) const; // operator ==

    bool verify ();                      // implement Verifiable::verify()

    // Input iterator of bases (tuples with non-zero signs).
    class basis_iterator 
      : public std::iterator <std::input_iterator_tag, Tuple> 
    {
    public:
      basis_iterator () {};           // empty constructor, used by basis_end()
      basis_iterator (const Chirotope *, const Tuple &); // constructor
      
      ~basis_iterator () {};           // destructor
      
      Tuple & operator* ();            // operater * (dereference)
      Tuple * operator-> ();           // operator ->
      
      Tuple & operator++ ();           // prefix operator ++
      Tuple operator++ (int);          // postfix operator ++
      
      bool operator== (basis_iterator); // operator ==
      bool operator!= (basis_iterator); // operator !=

    private:
      const Chirotope *m_Chi_p;         // pointer to the chirotope
      Tuple m_basis;                    // current basis
    };

    // Iterator functions.
    basis_iterator basis_begin () const;
    basis_iterator basis_end () const;

  protected:
    SignedSet m_Sign;                   // signs

  }; // class Chirotope


  inline Chirotope::Chirotope (size_t r, size_t n, 
                               OrientedMatroid::om_type omt = OrientedMatroid::empty) 
    : OrientedMatroid (r, n), m_Sign (util::choose(n,r))
  {
    if (omt == alternating) // alternating oriented matroid
      for (int i=0; i<m_Sign.size(); i++) 
        m_Sign[i] = 1;
  }

  inline Chirotope::Chirotope (size_t r, size_t n, std::string signs) 
    : OrientedMatroid (r, n), m_Sign (util::choose(n,r))
  {
    setSigns (signs);
  }

  inline Chirotope::Chirotope (const Chirotope & C) 
    : OrientedMatroid (C.m_rank, C.m_numElements), m_Sign (C.m_Sign)
  {}

  inline Chirotope* Chirotope::clone () const {
    return new Chirotope (*this);
  }

  
  inline Chirotope::basis_iterator::basis_iterator (const Chirotope * c_p, 
                                             const Tuple & t)
    : m_Chi_p (c_p), m_basis (t)
  {}
    
  inline Tuple & Chirotope::basis_iterator::operator* () { 
    return m_basis; 
  }

  inline Tuple * Chirotope::basis_iterator::operator-> () {
    return & m_basis;
  }
  
  inline Tuple & Chirotope::basis_iterator::operator++ () {
    while (m_basis.next()) 
      if (m_Chi_p->getSign (m_basis) != 0) return m_basis;

    // End of bases reached.
    m_basis = Tuple();
    return m_basis;
  }

  inline Tuple Chirotope::basis_iterator::operator++ (int dummy) {
    Tuple basis = m_basis;

    while (m_basis.next()) 
      if (m_Chi_p->getSign (m_basis) != 0) return basis;

    // End of bases reached. 
    m_basis = Tuple ();
    return basis;
  }
  
  inline bool Chirotope::basis_iterator::operator== (basis_iterator bi) {
    return (m_Chi_p == bi.m_Chi_p && m_basis == bi.m_basis);
  }
  
  inline bool Chirotope::basis_iterator::operator!= (basis_iterator bi) {
    return (m_Chi_p != bi.m_Chi_p || m_basis != bi.m_basis);
  }


  inline std::ostream & operator<< (std::ostream & os, Chirotope & C) {
    os << C.m_Sign;
    return os;
  }

  inline std::istream & operator>> (std::istream & is, Chirotope & C) {
    is >> C.m_Sign;
    return is;
  }

}; // namespace omc

#endif // OMC_CHIROTOPE_H

---