IntFunHelpers.h

Go to the documentation of this file.

#ifndef __INTFUNHELPERS_H
#define __INTFUNHELPERS_H

#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/CachedO.h"
#include "jbltools/sfh/ROListPoR.h"
#include "jbltools/sfh/BaseCutBase.h"
#include "jbltools/sfh/BaseCutPoR.h"
#include "jbltools/sfh/IntFunPoR.h"
#include "jbltools/sfh/FloatFunBase.h"


#include <vector>

//  Class OneIntFunCompound:
// Helper class for unary functions of IntFun objects
/*
 * This Class holds a pointer pointers to one other IntFun
 * The derived classes implement operator().
 */
class OneIntFunCompound : public IntFun {
  public:
    OneIntFunCompound (const std::string& funname_,             
                       const IntFun& arg_                       
                      );
    
    virtual int operator() () const = 0;
    
    virtual const FillIterator *getIterator() const {  
      return arg.getIterator(); 
    }
    
  protected:
    virtual ~OneIntFunCompound() {} 

    const IntFun& arg;
};

template<int fun(int)> 
class AnyIntFun1: public OneIntFunCompound   {
  public:
    AnyIntFun1 (const char *name_,      
                const IntFun& arg_      
               )
    : OneIntFunCompound (name_, arg_){}
    virtual int operator() () const {
      return fun(arg());
    }
  protected:
    virtual ~AnyIntFun1() {}
};

//  Class TwoIntFunCompound:
// Helper class for binary arithmetic operations between IntFun objects
/*
 * This Class holds pointers to two other IntFun objects.
 * The derived classes ProdOfTwoIntFuns and SumOfTwoIntFuns implement
 * operator().
 */
class TwoIntFunCompound : public IntFun {
  public:
    TwoIntFunCompound (const IntFun& lhs_,          
                       const std::string& opname_,  
                       const IntFun& rhs_           
                       );
    
    virtual int operator() () const = 0;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    virtual ~TwoIntFunCompound() {}

    const IntFun& lhs;            
    const IntFun& rhs;            
};

template<int fun(int, int)> 
class AnyIntFun2: public TwoIntFunCompound   {
  public:
    AnyIntFun2 (const char *name_,      
                const IntFun& lhs_,     
                const IntFun& rhs_      
               )
    : TwoIntFunCompound (name_, lhs_, rhs_){}
    AnyIntFun2 (const IntFun& lhs_,     
                const char *opname_,    
                const IntFun& rhs_      
               )
    : TwoIntFunCompound (lhs_, name_, rhs_){}
    virtual int operator() () const {
      return fun(lhs(), rhs());
    }
  protected:
    virtual ~AnyIntFun2() {}
};

// Helper class for Complement
class IntFunComplement: public OneIntFunCompound {
  public:
    IntFunComplement (const IntFun& arg_   
                      )
      : OneIntFunCompound ("~", arg_) { }
      
    virtual int operator() () const { return ~(arg()); }

  protected:
    virtual ~IntFunComplement() {}; 
};

//  Class SumOfTwoIntFuns:
// Helper class for the implementation of IntFun + IntFun
/*
 * Returns the sum of two IntFun objects.
 */
class SumOfTwoIntFuns : public TwoIntFunCompound {
  public:
    SumOfTwoIntFuns (const IntFun& lhs_,      
                     const IntFun& rhs_       
                 )
      : TwoIntFunCompound (lhs_, "+", rhs_) {}
  
    virtual int operator() () const {
      return lhs() + rhs();
    }
    
  protected:
    ~SumOfTwoIntFuns() {}
};

//  Class DiffOfTwoIntFuns:
// Helper class for the implementation of IntFun - IntFun
/*
 * Returns the difference of two IntFun objects.
 */
class DiffOfTwoIntFuns : public TwoIntFunCompound {
  public:
    DiffOfTwoIntFuns (const IntFun& lhs_,      
                      const IntFun& rhs_       
                     )
      : TwoIntFunCompound (lhs_, "-", rhs_) {}
  
    virtual int operator() () const {
      return lhs() - rhs();
    };
    
  protected:
    ~DiffOfTwoIntFuns() {}
};

//  Class ProdOfTwoIntFuns:
// Helper class for the implementation of IntFun * IntFun
/*
 * Returns the product of two IntFun objects.
 */
class ProdOfTwoIntFuns : public TwoIntFunCompound {
  public:
    ProdOfTwoIntFuns (const IntFun& lhs_, const IntFun& rhs_)
    : TwoIntFunCompound (lhs_, "*", rhs_) {}
  
    virtual int operator() () const {
      return lhs() * rhs();
    }
    
  protected:
    ~ProdOfTwoIntFuns() {} 
};

//  Class DivOfTwoIntFuns:
// Helper class for the implementation of IntFun / IntFun
/*
 * Returns the product of two IntFun objects.
 */
class DivOfTwoIntFuns : public TwoIntFunCompound {
  public:
    DivOfTwoIntFuns (const IntFun& lhs_, const IntFun& rhs_)
    : TwoIntFunCompound (lhs_, "/", rhs_) {}
  
    virtual int operator() () const {
      int r = rhs();
      return r ? lhs() / r : 0;
    }
    
  protected:
    ~DivOfTwoIntFuns() {} 
};

//  Class AndOfTwoIntFuns:
// Helper class for the implementation of IntFun & IntFun
/*
 * Returns the bitwise AND of two IntFun objects.
 */
class AndOfTwoIntFuns : public TwoIntFunCompound {
  public:
    AndOfTwoIntFuns (const IntFun& lhs_,      
                     const IntFun& rhs_      
                 )
    : TwoIntFunCompound (lhs_, "&", rhs_) {}
  
    virtual int operator() () const {
      return lhs() & rhs();
    }
    
  protected:
    ~AndOfTwoIntFuns() {} 
};


//  Class OrOfTwoIntFuns:
// Helper class for the implementation of IntFun & IntFun
/*
 * Returns the bitwise Or of two IntFun objects.
 */
class OrOfTwoIntFuns : public TwoIntFunCompound {
  public:
    OrOfTwoIntFuns (const IntFun& lhs_,      
                     const IntFun& rhs_      
                 )
    : TwoIntFunCompound (lhs_, "|", rhs_) { };
  
    virtual int operator() () const {
      return lhs() | rhs();
    }
    
  protected:
    ~OrOfTwoIntFuns() {} 
};

//  Class XorOfTwoIntFuns:
// Helper class for the implementation of IntFun & IntFun
/*
 * Returns the bitwise Xor of two IntFun objects.
 */
class XorOfTwoIntFuns : public TwoIntFunCompound {
  public:
    XorOfTwoIntFuns (const IntFun& lhs_,      
                     const IntFun& rhs_      
                 )
    : TwoIntFunCompound (lhs_, "^", rhs_) { }
  
    virtual int operator() () const {
      return lhs() & rhs();
    }
    
  protected:
    ~XorOfTwoIntFuns() {} 
};

//  Class ScalarIntFunCompound:
// Helper class for combination of an IntFun with a scalar value
class ScalarIntFunCompound: public IntFun   {
  public:
    ScalarIntFunCompound (int s_,                       
                          const std::string& opname_,   
                          const IntFun& fun_            
                         );
    
    ScalarIntFunCompound (int s_,                       
                          const IntFun& fun_,           
                          const std::string& name_      
                         );
    
    virtual const FillIterator *getIterator() const {  
      return fun.getIterator(); 
    }
    
  protected:
    virtual ~ScalarIntFunCompound() {} 
    // Data members
    const IntFun& fun;                          
          int     s;                            
};

//  Class ScalarProductIntFun:
// Helper class for multiplication of a IntFun with a scalar value
class ScalarProductIntFun: public ScalarIntFunCompound   {
  public:
    ScalarProductIntFun (int s_,                       
                         const IntFun& fun_            
                         )
      : ScalarIntFunCompound (s_, "*", fun_) {}
    ScalarProductIntFun (int s_,                       
                         const IntFun& fun_,           
                         const std::string& name_      
                         )
      : ScalarIntFunCompound (s_, fun_, name_) {}
      
    virtual int operator() () const { return s * fun() ; }
  protected:
    virtual ~ScalarProductIntFun() {} 
};

//  Class ScalarDivisionIntFun:
// Helper class for multiplication of a IntFun with a scalar value
class ScalarDivisionIntFun: public ScalarIntFunCompound   {
  public:
    ScalarDivisionIntFun (int s_,                       
                         const IntFun& fun_            
                         )
      : ScalarIntFunCompound (s_, "/", fun_) {}
    virtual int operator() () const { 
      int f = fun();
      return f ? s / f : 0 ; 
    }
  protected:
    virtual ~ScalarDivisionIntFun() {} 
};

//  Class ScalarDivisionIntFun2:
// Helper class for multiplication of a IntFun with a scalar value
class ScalarDivisionIntFun2: public ScalarIntFunCompound   {
  public:
    ScalarDivisionIntFun2 (const IntFun& fun_,           
                           int s_                        
                          );
    virtual int operator() () const { return s ? fun()/s : 0 ; }
  protected:
    virtual ~ScalarDivisionIntFun2() {} 
};

//  Class ScalarSumIntFun:
// Helper class for sum of a IntFun and a scalar value
class ScalarSumIntFun: public ScalarIntFunCompound   {
  public:
    ScalarSumIntFun (int s_,                        
                     const IntFun& fun_             
                    )
      : ScalarIntFunCompound (s_, "+", fun_) {}
    virtual int operator() () const { return s + fun() ; }
  protected:
    virtual ~ScalarSumIntFun() {} 
};

//  Class ScalarDiffIntFun:
// Helper class for Diff of a IntFun and a scalar value
class ScalarDiffIntFun: public ScalarIntFunCompound   {
  public:
    ScalarDiffIntFun (int s_,                        
                     const IntFun& fun_             
                    )
      : ScalarIntFunCompound (s_, "-", fun_) {}
    virtual int operator() () const { return s - fun() ; }
  protected:
    virtual ~ScalarDiffIntFun() {} 
};

//  Class ScalarAndIntFun:
// Helper class for and of a IntFun with a scalar value
class ScalarAndIntFun: public ScalarIntFunCompound   {
  public:
    ScalarAndIntFun (int s_,               
                     const IntFun& fun_    
                     )
      : ScalarIntFunCompound (s_, fun_, "c&(%s)") {}
    virtual int operator() () const { return s & fun() ; }
  protected:
    virtual ~ScalarAndIntFun() {} 
};

//  Class ScalarOrIntFun:
// Helper class for or of a IntFun with a scalar value
class ScalarOrIntFun: public ScalarIntFunCompound   {
  public:
    ScalarOrIntFun (int s_,               
                         const IntFun& fun_    
                         )
      : ScalarIntFunCompound (s_, fun_, "c|(%s)") {}
    virtual int operator() () const { return s | fun() ; }
  protected:
    virtual ~ScalarOrIntFun() {} 
};

//  Class ScalarXorIntFun:
// Helper class for xor of a IntFun with a scalar value
class ScalarXorIntFun: public ScalarIntFunCompound   {
  public:
    ScalarXorIntFun (int s_,               
                         const IntFun& fun_    
                         )
      : ScalarIntFunCompound (s_, fun_, "c^(%s)") {}
    virtual int operator() () const { return s ^ fun() ; }
  protected:
    virtual ~ScalarXorIntFun() {} 
};

// Class FloatIntFun:
//  Helper class to create a FloatFun out of a IntFun
class FloatIntFun: public FloatFun {
  public:
    explicit FloatIntFun (const IntFun& theIntFun_,  
                          const char *name_ = 0    
                         );
    virtual Float_FF operator() () const { return theIntFun();} 
    virtual const FillIterator *getIterator() const { 
      return theIntFun.getIterator(); 
    }
    
  protected:  
    virtual ~FloatIntFun() {} 
    const IntFun& theIntFun;                
};

//  Class TwoIntFunComp:
// Helper class for comparisons between IntFun objects
/*
 * This cut holds pointers to two IntFun objects.
 * The derived classes operator().
 */
class  TwoIntFunComp: public IntFunComp {
  public:
    TwoIntFunComp (const IntFun& lhs_,           
                   const std::string& opname_,   
                   const IntFun& rhs_            
                   );
    virtual const FillIterator *getIterator() const {  
      assert (!lhs.getIterator() || !rhs.getIterator() || lhs.getIterator()==rhs.getIterator());
      return (lhs.getIterator()) ? lhs.getIterator() : rhs.getIterator();
    }
                              
    virtual int lhsValue() const {
      return lhs();
    }
    virtual int rhsValue() const {
      return rhs();
    }
    
  protected:
    virtual ~TwoIntFunComp() {} 

    const IntFun& lhs;                     
    const IntFun& rhs;                     
};


//  Class IntFunLess:
// Helper class for IntFun < IntFun
class  IntFunLess: public TwoIntFunComp {
  public:
    IntFunLess (const IntFun&  lhs_,    
                const IntFun&  rhs_     
               )
    : TwoIntFunComp (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() < rhs();
    }
  protected:
    virtual ~IntFunLess() {}
};

//  Class IntFunLessEqual:
// Helper class for IntFun <= IntFun
class  IntFunLessEqual: public TwoIntFunComp {
  public:
    IntFunLessEqual (const IntFun&  lhs_,    
                     const IntFun&  rhs_     
                    )
    : TwoIntFunComp (lhs_, "<=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() <= rhs();
    };
    
  protected:
    virtual ~IntFunLessEqual() {}
};

//  Class IntFunGreater:
// Helper class for IntFun > IntFun
class  IntFunGreater: public TwoIntFunComp {
  public:
    IntFunGreater (const IntFun&  lhs_,    
                   const IntFun&  rhs_     
                   )
    : TwoIntFunComp (lhs_, ">", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() > rhs();
    };
    
  protected:
    virtual ~IntFunGreater() {}
};

//  Class IntFunGreaterEqual:
// Helper class for IntFun >= IntFun
class  IntFunGreaterEqual: public TwoIntFunComp {
  public:
    IntFunGreaterEqual (const IntFun&  lhs_,    
                        const IntFun&  rhs_     
                        )
    : TwoIntFunComp (lhs_, ">=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() >= rhs();
    };
    
  protected:
    virtual ~IntFunGreaterEqual() {}
};

//  Class IntFunEqual:
// Helper class for IntFun == IntFun
class  IntFunEqual: public TwoIntFunComp {
  public:
    IntFunEqual (const IntFun&  lhs_,    
                 const IntFun&  rhs_     
                )
    : TwoIntFunComp (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() == rhs();
    };
    
  protected:
    virtual ~IntFunEqual() {}
};

//  Class IntFunNotEqual:
// Helper class for IntFun != IntFun
class  IntFunNotEqual: public TwoIntFunComp {
  public:
    IntFunNotEqual (const IntFun&  lhs_,    
                    const IntFun&  rhs_     
                   )
      : TwoIntFunComp (lhs_, "!=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() != rhs();
    };
    
  protected:
    virtual ~IntFunNotEqual() {}
};


//  Class IntChainComparison:
// Abstract base class for (IntFun < IntFun) < IntFun
class  IntChainComparison: public IntFunComp {
  public:
    IntChainComparison (const IntFunComp& lhs_,      
                        const std::string& opname_,  
                        const IntFun&     rhs_       
                       );
    virtual const FillIterator *getIterator() const {  
      assert (!lhs.getIterator() || !rhs.getIterator() || lhs.getIterator()==rhs.getIterator());
      return (lhs.getIterator()) ? lhs.getIterator() : rhs.getIterator();
    }
                              
    virtual int lhsValue() const {
      return lhs.lhsValue();
    }
    virtual int rhsValue() const {
      return rhs();
    }
    
  protected:
    virtual ~IntChainComparison() {}
    
    // Data members
    const IntFunComp& lhs;    
    const IntFun&     rhs;    
};

//  Class IntChainCompLess:
// Helper class for (IntFun < IntFun) < IntFun
class  IntChainCompLess: public IntChainComparison {
  public:
    IntChainCompLess (const IntFunComp&  lhs_,    
                      const IntFun&      rhs_         
                      )
    : IntChainComparison (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() < rhs());
    }
    
  protected:
    virtual ~IntChainCompLess() {}
};

//  Class IntChainCompLessEqual:
// Helper class for (IntFun < IntFun) <= IntFun
class  IntChainCompLessEqual: public IntChainComparison {
  public:
    IntChainCompLessEqual (const IntFunComp&  lhs_,    
                           const IntFun&      rhs_               
                          )
    : IntChainComparison (lhs_, "<=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() <= rhs());
    }
    
  protected:
    virtual ~IntChainCompLessEqual() {}
};

//  Class IntChainCompGreater:
// Helper class for (IntFun > IntFun) > IntFun
class  IntChainCompGreater: public IntChainComparison {
  public:
    IntChainCompGreater (const IntFunComp&  lhs_,      
                         const IntFun&      rhs_       
                         )
    : IntChainComparison (lhs_, ">", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() > rhs());
    }
    
  protected:
    virtual ~IntChainCompGreater() {}
};

//  Class IntChainCompGreaterEqual:
//  Helper class for (IntFun > IntFun) >= IntFun
class  IntChainCompGreaterEqual: public IntChainComparison {
  public:
    IntChainCompGreaterEqual (const IntFunComp&  lhs_,    
                              const IntFun&      rhs_               
                              )
    : IntChainComparison (lhs_, ">=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() >= rhs());
    }
    
  protected:
    virtual ~IntChainCompGreaterEqual() {}
};

//  Class IntChainCompEqual:
//  Helper class for (IntFun > IntFun) == IntFun
class  IntChainCompEqual: public IntChainComparison {
  public:
    IntChainCompEqual (const IntFunComp&  lhs_,    
                       const IntFun&      rhs_               
                      )
    : IntChainComparison (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() == rhs());
    }
    
  protected:
    virtual ~IntChainCompEqual() {}
};

//  Class IntChainCompNotEqual:
//  Helper class for (IntFun > IntFun) != IntFun
class  IntChainCompNotEqual: public IntChainComparison {
  public:
    IntChainCompNotEqual (const IntFunComp&  lhs_,    
                          const IntFun&      rhs_               
                         )
    : IntChainComparison (lhs_, "!=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() != rhs());
    }
    
  protected:
    virtual ~IntChainCompNotEqual() {}
};


//  Class IntChainCompInt:
//  Abstract base class for (IntFun < IntFun) < int
class  IntChainCompInt: public IntFunComp {
  public:
    IntChainCompInt (const IntFunComp& lhs_,       
                     const std::string& opname_,   
                     int               rhs_        
                     );
    virtual const FillIterator *getIterator() const {  
      return lhs.getIterator();
    }
                              
    virtual int lhsValue() const {
      return lhs.lhsValue();
    }
    virtual int rhsValue() const {
      return rhs;
    }
    
  protected:
    virtual ~IntChainCompInt() {} 

    // Data members
    const IntFunComp& lhs;    
    int               rhs;    
};

//  Class IntChainCompIntLess:
//  Helper class for (IntFun < IntFun) < int
class  IntChainCompIntLess: public IntChainCompInt {
  public:
    IntChainCompIntLess (const IntFunComp& lhs_,    
                         int               rhs_     
                         )
    : IntChainCompInt (lhs_, "<", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() < rhs);
    }
    
  protected:
    virtual ~IntChainCompIntLess() {}
};

//  Class IntChainCompIntLessEqual:
//  Helper class for (IntFun < IntFun) <= int
class  IntChainCompIntLessEqual: public IntChainCompInt {
  public:
    IntChainCompIntLessEqual (const IntFunComp& lhs_,    
                              int               rhs_     
                             )
    : IntChainCompInt (lhs_, "<=", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() <= rhs);
    }
    
  protected:
    virtual ~IntChainCompIntLessEqual() {}
};

//  Class IntChainCompIntGreater:
//  Helper class for (IntFun < IntFun) > int
class  IntChainCompIntGreater: public IntChainCompInt {
  public:
    IntChainCompIntGreater (const IntFunComp& lhs_,    
                            int               rhs_     
                            )
    : IntChainCompInt  (lhs_, ">", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() > rhs);
    }
    
  protected:
    virtual ~IntChainCompIntGreater() {}
};

//  Class IntChainCompIntGreaterEqual:
//  Helper class for (IntFun < IntFun) >= int
class  IntChainCompIntGreaterEqual: public IntChainCompInt {
  public:
    IntChainCompIntGreaterEqual (const IntFunComp& lhs_,    
                                 int              rhs_     
                                )
    : IntChainCompInt (lhs_, ">=", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() >= rhs);
    }
    
  protected:
    virtual ~IntChainCompIntGreaterEqual() {}
};

//  Class IntChainCompIntEqual:
//  Helper class for (IntFun < IntFun) == int
class  IntChainCompIntEqual: public IntChainCompInt {
  public:
    IntChainCompIntEqual (const IntFunComp& lhs_,    
                          int               rhs_     
                          )
    : IntChainCompInt (lhs_, "==", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() == rhs);
    }
    
  protected:
    virtual ~IntChainCompIntEqual() {}
};

//  Class IntChainCompIntNotEqual:
//  Helper class for (IntFun < IntFun) != int
class  IntChainCompIntNotEqual: public IntChainCompInt {
  public:
    IntChainCompIntNotEqual (const IntFunComp& lhs_,    
                             int               rhs_     
                            )
    : IntChainCompInt (lhs_, "!=", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() != rhs);
    }
    
  protected:
    virtual ~IntChainCompIntNotEqual() {}
};

//  Class IntIntFunComp:
//  Helper class for comparisons between a int and a IntFun 
/*
 * This cut holds a int and a pointer to a IntFun
 * The derived classes operator().
 */
class  IntIntFunComp: public IntFunComp {
  public:
    IntIntFunComp (int lhs_,                    
                   const std::string& opname_,  
                   const IntFun& rhs_           
                  );
    virtual const FillIterator *getIterator() const {  
      return rhs.getIterator();
    }
                              
    virtual int lhsValue() const {
      return lhs;
    }
    virtual int rhsValue() const {
      return rhs();
    }
  protected:
    virtual ~IntIntFunComp() {} 

    int           lhs;     
    const IntFun& rhs;     
};

//  Class IntIntFunLess:
//  Helper class for int < IntFun
class  IntIntFunLess: public IntIntFunComp {
  public:
    IntIntFunLess (int           lhs_,    
                   const IntFun& rhs_     
                  )
    : IntIntFunComp (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs < rhs();
    }
  protected:
    virtual ~IntIntFunLess() {}
};

//  Class IntIntFunLessEqual:
//  Helper class for int <= IntFun
class  IntIntFunLessEqual: public IntIntFunComp {
  public:
    IntIntFunLessEqual (int           lhs_,    
                        const IntFun& rhs_     
                       )
    : IntIntFunComp (lhs_, "<=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs <= rhs();
    }
  protected:
    virtual ~IntIntFunLessEqual() {}
};

//  Class IntIntFunGreater:
//  Helper class for int > IntFun
class  IntIntFunGreater: public IntIntFunComp {
  public:
    IntIntFunGreater (int           lhs_,    
                      const IntFun& rhs_     
                     )
    : IntIntFunComp (lhs_, ">", rhs_) {}
    
    virtual bool operator() () const {
      return lhs > rhs();
    }
  protected:
    virtual ~IntIntFunGreater() {}
};

//  Class IntIntFunGreaterEqual:
//  Helper class for int >= IntFun
class  IntIntFunGreaterEqual: public IntIntFunComp {
  public:
    IntIntFunGreaterEqual (int           lhs_,    
                           const IntFun& rhs_     
                          )
    : IntIntFunComp (lhs_, ">=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs >= rhs();
    }
  protected:
    virtual ~IntIntFunGreaterEqual() {}
};

//  Class IntIntFunEqual:
//  Helper class for int == IntFun
class  IntIntFunEqual: public IntIntFunComp {
  public:
    IntIntFunEqual (int           lhs_,    
                    const IntFun& rhs_     
                   )
    : IntIntFunComp (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs == rhs();
    }
  protected:
    virtual ~IntIntFunEqual() {}
};

//  Class IntIntFunEqual:
//  Helper class for int != IntFun
class  IntIntFunNotEqual: public IntIntFunComp {
  public:
    IntIntFunNotEqual (int           lhs_,    
                       const IntFun& rhs_     
                      )
    : IntIntFunComp (lhs_, "!=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs != rhs();
    }
  protected:
    virtual ~IntIntFunNotEqual() {}
};


//  Class IntFunIntComp:
//  Helper class for comparisons between a int and a IntFun 
/*
 * This cut holds a pointer to a IntFun and a int 
 * The derived classes operator().
 */
class  IntFunIntComp: public IntFunComp {
  public:
    IntFunIntComp (const IntFun& lhs_,           
                   const std::string& opname_,   
                   int           rhs_            
                  );
    virtual const FillIterator *getIterator() const {  
      return lhs.getIterator();
    }
                              
    virtual int lhsValue() const {
      return lhs();
    }
    virtual int rhsValue() const {
      return rhs;
    }
    
  protected:
    virtual ~IntFunIntComp() {} 

    const IntFun& lhs;     
    int           rhs;     
};

//  Class IntFunIntLess:
//  Helper class for IntFun < int
class  IntFunIntLess: public IntFunIntComp {
  public:
    IntFunIntLess (const IntFun& lhs_,    
                   int           rhs_     
                  )
    : IntFunIntComp (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() < rhs;
    }
  protected:
    virtual ~IntFunIntLess() {}
};

//  Class IntFunIntLessEqual:
//  Helper class for IntFun <= int
class  IntFunIntLessEqual: public IntFunIntComp {
  public:
    IntFunIntLessEqual (const IntFun& lhs_,    
                        int           rhs_     
                       )
    : IntFunIntComp (lhs_, "<=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() <= rhs;
    }
  protected:
    virtual ~IntFunIntLessEqual() {}
};

//  Class IntFunIntGreater:
//  Helper class for IntFun > int
class  IntFunIntGreater: public IntFunIntComp {
  public:
    IntFunIntGreater (const IntFun& lhs_,    
                      int           rhs_     
                     )
    : IntFunIntComp (lhs_, ">", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() > rhs;
    }
  protected:
    virtual ~IntFunIntGreater() {}
};

//  Class IntFunIntGreaterEqual:
//  Helper class for IntFun >= int
class  IntFunIntGreaterEqual: public IntFunIntComp {
  public:
    IntFunIntGreaterEqual (const IntFun& lhs_,    
                           int           rhs_     
                          )
    : IntFunIntComp (lhs_, ">=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() >= rhs;
    }
  protected:
    virtual ~IntFunIntGreaterEqual() {}
};

//  Class IntFunIntEqual:
//  Helper class for IntFun == int
class  IntFunIntEqual: public IntFunIntComp {
  public:
    IntFunIntEqual (const IntFun& lhs_,    
                    int           rhs_     
                   )
    : IntFunIntComp (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() == rhs;
    }
  protected:
    virtual ~IntFunIntEqual() {}
};

//  Class IntFunIntNotEqual:
//  Helper class for IntFun != int
class  IntFunIntNotEqual: public IntFunIntComp {
  public:
    IntFunIntNotEqual (const IntFun& lhs_,    
                       int           rhs_     
                      )
    : IntFunIntComp (lhs_, "!=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() != rhs;
    }
  protected:
    virtual ~IntFunIntNotEqual() {}
};

class CachedIntFun: public IntFun, public CachedO {
  public:
    CachedIntFun (const ROListPoR& rol,  
                  const IntFun&  arg_  
                 );
    
    virtual int operator() () const;
    
    virtual void invalidateCache() { cacheValid = false; }
    
  protected:
    virtual ~CachedIntFun() {}
    
    // Data members
    const   IntFun& arg;         
    mutable bool cacheValid;       
    mutable int cachedValue;     
};

class CachedIntFunIt: public IntFun, public CachedO {
  public:
    CachedIntFunIt (const ROListPoR&     rol,  
                      const IntFun&      arg_, 
                      const FillIterator&  iter_ 
                     );
    
    virtual int operator() () const;
    
    virtual const FillIterator *getIterator() const { 
      return &iter; 
    }
    
    virtual void invalidateCache() {   
      cacheValid.resize(0);
      cachedValues.resize(0);
    }
    
  protected:
    void growCache (unsigned int s) const;
  
    virtual ~CachedIntFunIt() {}
    
    // Data members
    const   IntFun& arg;                      
    const   FillIterator&  iter;                  
    mutable std::vector<bool>  cacheValid;      
    mutable std::vector<int>  cachedValues;    
};




// Base class for "collective" IntFun classes that determine minimum, maximum etc.
class CollectiveIntFun: public IntFun {
  public:
    CollectiveIntFun (const std::string&           funname_,         
                      const IntFunPoRConst&        fun_=0,        
                      const BaseCutPoRConst&       cut_=0,      
                      const FillIteratorPoR&       intiter_=0,  
                      const FillIteratorPoRConst&  extiter_=0   
                     );    
    virtual const FillIterator *getIterator() const {  
      return extiter; 
    }
    
  protected:
    virtual ~CollectiveIntFun() {}
    void checkIterators();
    static std::string makeName(const std::string&           funname_,     
                                const IntFunPoRConst&         fun_,        
                                const BaseCutPoRConst&       cut_,         
                                const FillIteratorPoR&       intiter_,     
                                const FillIteratorPoRConst&  extiter_      
                               );
    // Data members
    const IntFun        *fun;      
    const BaseCut       *cut;      
          FillIterator  *intiter;  
    const FillIterator  *extiter;  
};

// Returns maximum value of all fun objects that fulfill cut
class MaxIntFun: public CollectiveIntFun {
  public: 
    MaxIntFun (const IntFunPoRConst&        fun_=0,      
               const BaseCutPoRConst&       cut_=0,      
               const FillIteratorPoR&       intiter_=0,  
               const FillIteratorPoRConst&  extiter_=0   
               )
     : CollectiveIntFun  ("max", fun_, cut_, intiter_, extiter_)
     {}
     
   virtual int operator() () const;           
  protected:
    virtual ~MaxIntFun() {}
};

// Returns maximum value of all fun objects that fulfill cut
class MinIntFun: public CollectiveIntFun {
  public: 
    MinIntFun (const IntFunPoRConst&        fun_=0,      
               const BaseCutPoRConst&       cut_=0,      
               const FillIteratorPoR&       intiter_=0,  
               const FillIteratorPoRConst&  extiter_=0   
               )
     : CollectiveIntFun  ("min", fun_, cut_, intiter_, extiter_)
     {}
     
   virtual int operator() () const;           
  protected:
    virtual ~MinIntFun() {}
};

// Returns sum of all fun objects that fulfill cut
class SumIntFun: public CollectiveIntFun {
  public: 
    SumIntFun (const IntFunPoRConst&        fun_=0,      
               const BaseCutPoRConst&       cut_=0,      
               const FillIteratorPoR&       intiter_=0,  
               const FillIteratorPoRConst&  extiter_=0   
               )
     : CollectiveIntFun  ("sum", fun_, cut_, intiter_, extiter_)
     {}
     
   virtual int operator() () const;           
  protected:
    virtual ~SumIntFun() {}
};

#endif /* #ifndef __INTFUNHELPERS_H */

---