AffineCircuits.h

//-----------------------------------------------------------------------------
//
// Module:       AffineCircuits.h
//
// Author:       Feng Xie -- xief@mcmaster.ca
//
// Discription:  Affine circuits/cocircuits: circuits/cocircuits with an
//               infinity element specified.
//
// Change log:
//   09-06-04    Created.
//
//-----------------------------------------------------------------------------

#ifndef OMC_AFFINE_CIRCUITS_H
#define OMC_AFFINE_CIRCUITS_H

#include "Circuits.h"
#include "AffineObject.h"
#include "Permutation.h"
#include <iostream>

namespace omc
{
  class AffineCircuits : public Circuits, public AffineObject
  {
  public:
    AffineCircuits (int, int, int);      // constructors
    AffineCircuits (const Circuits&, int);
    AffineCircuits (const AffineCircuits &);
    
    void setInfinityElement (index_t);   // overiding method of AffineObject
    
    void relabel (const Permutation &);  // relabeling

    bool operator== (const AffineCircuits &) const;  // operatro ==

  };


  inline AffineCircuits::AffineCircuits (int rank, int numElements, 
                                         int infinityElement)
    : Circuits (rank, numElements), AffineObject (infinityElement)
  {}

  inline AffineCircuits::AffineCircuits (const Circuits & C, int infinityElement)
    : Circuits (C), AffineObject (infinityElement)
  {}

  inline AffineCircuits::AffineCircuits (const AffineCircuits & AC)
    : Circuits (AC), AffineObject (AC.m_infinityElement)
  {}

  inline void AffineCircuits::setInfinityElement (index_t infinityElement) {
    if (infinityElement >= m_numElements) 
      throw OMCException ("Index out of bound!", 
                          "AffineCircuits::setIninityElement");
    m_infinityElement = infinityElement;
  }

  inline void AffineCircuits::relabel (const Permutation & pi) {
    Circuits::relabel (pi);
    m_infinityElement = pi (m_infinityElement);
  }

  inline bool AffineCircuits::operator== (const AffineCircuits & AC) const {
    return (m_infinityElement == AC.m_infinityElement && 
            (Circuits&)(*this) == (Circuits&) AC);
  }

  inline std::ostream & operator<< (std::ostream & os, AffineCircuits & AC) {
    os << (Circuits&) AC << std::endl;
    os << "Infinity Element: " << AC.getInfinityElement();
    return os;
  }

  inline std::istream & operator>> (std::istream & is, AffineCircuits & AC) {
    index_t infinityElement;
    is >> infinityElement; 
    AC.setInfinityElement (infinityElement);

    is >> (Circuits&) AC;
    return is;
  }

} // namespace omc

#endif

---