Vectors.h

//-----------------------------------------------------------------------------
//
// Module:       Vectors.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Vectors/Covectors.
//
// Note:         1) Vectors are obtained by repeated composition of circuits.
//               2) Since vectors are symmetric by negation, only the positve
//                  half is stored.
//               3) Vectors are stored in set for fast lookup.
//
// Change log:
//   09-06-23    Created.
//
//-----------------------------------------------------------------------------

#ifndef OMC_VECTORS_H
#define OMC_VECTORS_H

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

namespace omc 
{
  class Vectors {
  public:
    Vectors (const Circuits &);         // constructor
    Vectors (const Vectors &);          // copy constructor

    ~Vectors () {};                     // destructor

    size_t getRank () const;            // get the rank of the OM
    size_t getNumElements () const;     // get the number of elements of the OM
    size_t getNumVectors () const;      // get the number of vectors

    void relabel (index_t, index_t);    // relabeling
    void relabel (const Permutation &);

    void reorient (size_t);             // reorientation
    void reorient (const Combination &);

    bool operator== (const Vectors & C) const; // operator ==

    //bool verify () const;                

    // Iterators.
    typedef std::set<SignedSet>::iterator vector_iterator;
    vector_iterator vector_begin ();
    vector_iterator vector_end ();

    typedef std::set<SignedSet>::reverse_iterator reverse_vector_iterator;
    reverse_vector_iterator vector_rbegin ();
    reverse_vector_iterator vector_rend ();

  protected:
    Circuits m_circuits;              // the underlying circuits

    std::set <SignedSet> m_Vector;    // set of vectors

    void generate_vectors ();         // generate vectors from circuits

  }; // class Vectors

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


  inline Vectors::Vectors (const Circuits & C) 
    : m_circuits (C)
  {
    generate_vectors ();
  }

  inline Vectors::Vectors (const Vectors & V) 
    : m_circuits (V.m_circuits)
  {
    generate_vectors ();
  }

  inline size_t Vectors::getRank () const {
    return m_circuits.getRank ();
  }

  inline size_t Vectors::getNumElements () const {
    return m_circuits.getNumElements ();
  }

  inline size_t Vectors::getNumVectors () const {
    return m_Vector.size ();
  }

  inline void Vectors::relabel (index_t i, index_t j) {
    m_circuits.relabel (i, j);
    generate_vectors ();
  }

  inline void Vectors::relabel (const Permutation & perm) {
    m_circuits.relabel (perm);
    generate_vectors ();
  }

  inline void Vectors::reorient (size_t i) {
    m_circuits.reorient (i);
    generate_vectors ();
  }

  inline void Vectors::reorient (const Combination & comb) {
    m_circuits.reorient (comb);
    generate_vectors ();
  }

  inline bool Vectors::operator== (const Vectors & V) const {
    return (m_circuits == V.m_circuits) ? true : false;
  }

  inline Vectors::vector_iterator Vectors::vector_begin () {
    return m_Vector.begin ();
  }

  inline Vectors::vector_iterator Vectors::vector_end () {
    return m_Vector.end ();
  }

  inline Vectors::reverse_vector_iterator Vectors::vector_rbegin () {
    return m_Vector.rbegin ();
  }

  inline Vectors::reverse_vector_iterator Vectors::vector_rend () {
    return m_Vector.rend ();
  }
  
}; // namespace omc

#endif // OMC_VECTORS_H

---