Tuple.h

//-----------------------------------------------------------------------------
//
// Module:       Tuple.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Tuple of elements. (used for chirotope basis)
//
// Note:         1) Element index starts from 0.
//               2) A tuple is considered normalized if its indices are in
//                  strictly increasing order.
//               3) The normalized tuples are ordered in lexicographical order, 
//                  e.g. 012,013,014,023,024,034,123,124,134,234, with orders
//                        1   2   3   4   5   6   7   8   9  10.
//               4) A tuple with repeated indices has no order (Tuple::norder).
//               5) All other tuples can be converted to normalized ones by
//                  a sequence of transpositions. If the number of 
//                  transpositions needed is even, then its order is the same
//                  as its normalized one, otw. it is the negative of the order
//                  of its normalized one.
//                  e.g. the orders of 102 and 120 are -1 and 1 respectively.
//
// Change log:
//   09-07-07    Created.
//
// Todo:
//   *) Do we really need an constructor for all-zero tuple?
//
//-----------------------------------------------------------------------------

#ifndef OMC_TUPLE_H
#define OMC_TUPLE_H

#include "Core.h"
#include "Util.h"
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <climits>

namespace omc
{
  class Tuple
  {
    friend std::ostream & operator<< (std::ostream &, const Tuple &);

  public:
    Tuple (size_t, size_t);    // min-tuple constructor
    Tuple (size_t, const std::string &);
    Tuple (size_t, const std::vector <index_t> &); // constructor from vector
    Tuple ();                        // null-tuple
    Tuple (const Tuple &);           // copy constructor

    bool next ();                    // get the next tuple

    index_t & operator[] (index_t);  // operator []
    index_t operator[] (index_t) const;

    bool operator== (const Tuple &); // operator ==
    bool operator!= (const Tuple &); // operator !=

    size_t size () const;            // size of the tuple

    int order () const;              // order of the current tuple

    static const int norder = 0;     // not an order (for tuples with 
                                     // duplicate indices, e.g. 121)
  protected:
    size_t m_numElements;            // number of elements in {1,...,n}

    std::vector <index_t> m_Element; // internal representation

  private:
    index_t increment (index_t);     // helper function of next()
  };

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


  inline Tuple::Tuple () 
    : m_numElements (0), m_Element()  
  {} 

  inline Tuple::Tuple (const Tuple & T) 
    : m_numElements (T.m_numElements), m_Element (T.m_Element)
  {}

  inline bool Tuple::next () {
    return increment (m_Element.size()-1) < m_numElements ? true : false;
  }

  inline index_t & Tuple::operator[] (index_t i) {
    return m_Element[i];
  }

  inline index_t Tuple::operator[] (index_t i) const {
    return m_Element[i];
  }

  inline bool Tuple::operator== (const Tuple & t) {
    return m_numElements == t.m_numElements &&
      m_Element.size() == t.m_Element.size() && m_Element == t.m_Element;
  }

  inline bool Tuple::operator!= (const Tuple & t) {
    return ! ( (*this) == t);
  }

  inline size_t Tuple::size () const {
    return m_Element.size();
  }

  inline std::ostream & operator<< (std::ostream & os, const Tuple & T) {
    for (index_t i=0; i<T.size(); i++) 
      os << T[i];
    return os;
  }

} // namespace omc

#endif // OMC_TUPLE_H

---