SignedSet.h

//-----------------------------------------------------------------------------
//
// Module:       SignedSet.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Signed set, e.g. {+,+,0,-}.
//
// Todo:         1) Make it more like an atomic data type: -, compose ....
//
// Change log:
//   09-05-27    Created.
//
//-----------------------------------------------------------------------------

#ifndef OMC_SIGNED_SET_H
#define OMC_SIGNED_SET_H

#include "Core.h"
#include "Permutation.h"
#include "Combination.h"
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>

namespace omc 
{
  class SignedSet {
  
  public:
    SignedSet (size_t);              // constructor
    SignedSet (const std::string);
    SignedSet (const char*);
    SignedSet (const SignedSet &);   // copy costructor

    ~SignedSet () {};                // destructor

    size_t size () const;            // length of the signed set

    void shrink ();                  // shrink the size by 1

    size_t numZeros () const;        // # of zeros
    size_t numNonZeros () const;     // # of non-zeros

    sign_t & operator[] (index_t i); // assessor of a sign in the signed set
    sign_t operator[] (index_t i) const;

    bool negative () const;          // test if the first non-zero sign is -
    
    void negate ();                  // sign negation

    void compose (SignedSet &);      // composition

    void relabel (index_t, index_t); // relabeling
    void relabel (const Permutation &);  
    void reorient (index_t i);       // reorientation
    void reorient (const Combination &);

    bool operator< (const SignedSet &) const;  // comparator <
    bool operator== (const SignedSet &) const; // comparator ==
    bool operator!= (const SignedSet &) const; // comparator !=

    bool operator*= (const SignedSet &) const; // operator *= (conformal)
    bool operator/= (const SignedSet &) const; // operator /= (confirms to)
    bool operator-= (const SignedSet &) const; // operator -= (subset)
    bool operator+= (const SignedSet &) const; // operator += (support subset)
    SignedSet operator- (const SignedSet &) const; // operator -

    SignedSet operator- () const;              // unary operator -
    
    std::ostream & show (std::ostream &) const;

  protected:
    std::vector <sign_t> m_Sign;     // internal data structure: a vector

  }; // class SignedSet

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

  
  inline SignedSet::SignedSet (size_t len)
    : m_Sign (len, 0)
  {}

  inline SignedSet::SignedSet (const SignedSet & sSet) 
    : m_Sign (sSet.m_Sign)
  {}

  inline size_t SignedSet::size () const {
    return m_Sign.size();
  }

  inline void SignedSet::shrink () {
    m_Sign.pop_back(); // constant time erasing
  }

  inline size_t SignedSet::numNonZeros () const {
    return m_Sign.size() - numZeros();
  }

  inline sign_t & SignedSet::operator[] (index_t i) {
    return m_Sign[i];
  }
  
  inline sign_t SignedSet::operator[] (index_t i) const {
    return m_Sign[i];
  }

  inline void SignedSet::negate () {
    for (index_t i=0; i<m_Sign.size(); i++) 
      m_Sign[i] *= -1;
  }

  inline SignedSet SignedSet::operator- () const {
    SignedSet S (*this);
    S.negate ();
    return S;
  }

  inline void SignedSet::relabel (index_t i, index_t j) {
    std::swap (m_Sign[i], m_Sign[j]);
  }

  inline void SignedSet::relabel (const Permutation & perm) {
    std::vector <sign_t> Sign (m_Sign);
    for (index_t i=0; i<m_Sign.size(); i++) 
      m_Sign[perm(i)] = Sign[i];
  }

  inline void SignedSet::reorient (index_t i) {
    if (i >= m_Sign.size()) 
      throw OMCException ("Index out of bound", "SignedSet::reorient");

    m_Sign[i] *= -1;
  }

  inline void SignedSet::reorient (const Combination & comb) {
    if (comb.size() != m_Sign.size())
      throw OMCException ("Incompatible combination size", "SignedSet::reorient");

    for (int i=0; i<comb.size(); i++) 
      if (comb.has (i))
        m_Sign[i] *= -1;
  }

  inline std::ostream & SignedSet::show (std::ostream & os) const {
    for (index_t i=0; i<m_Sign.size(); i++) 
      os << (m_Sign[i] ? (m_Sign[i] > 0 ? "+" : "-") : "0");
    return os;
  }


  inline std::ostream & operator<< (std::ostream & os, SignedSet & S) {
    for (index_t i=0; i<S.size(); i++) 
      os << (S[i] ? (S[i] > 0 ? "+" : "-") : "0");
    return os;
  }

  inline std::istream & operator>> (std::istream & is, SignedSet & S) {
    std::string s; is >> s;
    S = SignedSet (s);
    return is;
  }

}; // namespace omc

#endif // OMC_SIGNED_SET_H

---