Circuits.h

//-----------------------------------------------------------------------------
//
// Module:       Circuits.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Circuits/Cocircuits.
//
// Note:         1) Since circuits are symmetric by negation, only the "bigger"
//                  ("positive") half are stored.
//               2) Circuits are stored in a list considering that every 
//                  circuit need to be modified in relabeling & reorientation,
//                  making self-sorted containers like set unusable.
//               3) The circuits in the list are always sorted.
//
// Change log:
//   09-06-01    Created.
//   09-07-02    Inherit from Verifiable.
//   09-07-22    Constructor from chiropte.
//   09-07-29    Single element deletion and contraction.
//
//-----------------------------------------------------------------------------

#ifndef OMC_CIRCUITS_H
#define OMC_CIRCUITS_H

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

namespace omc 
{
  class Circuits : public OrientedMatroid, Verifiable {
  public:
    Circuits (size_t, size_t);          // constructors
    Circuits (const Chirotope &);       // converter constructor
    Circuits (const Circuits &);        // copy constructor

    ~Circuits () { m_Circuit.clear(); }; // destructor

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

    size_t getNumCircuits () const;     // get the number of circuits

    void addCircuit (SignedSet);        // add a circuit
    void addCircuit (const std::string); 
    void addCircuit (const char*);

    void clear ();                      // clear the circuits

    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()

    // Iterators.
    typedef std::list<SignedSet>::iterator circuit_iterator;
    circuit_iterator circuit_begin ();
    circuit_iterator circuit_end ();

    typedef std::list<SignedSet>::reverse_iterator reverse_circuit_iterator;
    reverse_circuit_iterator circuit_rbegin ();
    reverse_circuit_iterator circuit_rend();

  protected:
    std::list <SignedSet> m_Circuit;    // list of circuits

    void chirotope2cocircuits (const Chirotope &); // Chirotope -> cocircuits

    void normalize ();                  // normalize the stored circuits

  }; // class Circuits

  // Output/input stream overloading
  std::ostream & operator<< (std::ostream &, Circuits &);
  std::istream & operator>> (std::istream &, Circuits &);


  inline Circuits::Circuits (size_t r, size_t n) 
    : OrientedMatroid (r, n), m_Circuit ()
  {}

  inline Circuits::Circuits (const Chirotope & Chi) 
    : OrientedMatroid (Chi.getRank(), Chi.getNumElements()), m_Circuit ()
  {
    chirotope2cocircuits (Chi);
  }

  inline Circuits::Circuits (const Circuits & C) 
    : OrientedMatroid (C.m_rank, C.m_numElements), m_Circuit (C.m_Circuit)
  {}

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

  inline size_t Circuits::getNumCircuits () const {
    return m_Circuit.size ();
  }

  inline void Circuits::addCircuit (const std::string s) {
    SignedSet S (s);
    addCircuit (S);
  }
  
  inline void Circuits::addCircuit (const char* s) {
    SignedSet S (s);
    addCircuit (S);
  }

  inline void Circuits::clear () {
    m_Circuit.clear ();
  }
  
  inline Circuits::circuit_iterator Circuits::circuit_begin () {
    return m_Circuit.begin ();
  }

  inline Circuits::circuit_iterator Circuits::circuit_end () {
    return m_Circuit.end ();
  }

  inline Circuits::reverse_circuit_iterator Circuits::circuit_rbegin () {
    return m_Circuit.rbegin ();
  }

  inline Circuits::reverse_circuit_iterator Circuits::circuit_rend () {
    return m_Circuit.rend ();
  }

}; // namespace omc

#endif // OMC_CIRCUITS_H

---