FloatFunHelpers.h

Go to the documentation of this file.

#ifndef __FLOATFUNHELPERS_H
#define __FLOATFUNHELPERS_H

#include "jbltools/sfh/FloatFun.h"

#ifndef __JBLMATH_H
#include "jbltools/sfh/JBLMath.h"
#endif /* #ifndef __JBLMATH_H */

#include "jbltools/sfh/ROListPoR.h"
#include "jbltools/sfh/CachedO.h"
#include "jbltools/sfh/FloatFunPoR.h"

#include <vector>
 

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

    // Data members
    const FloatFun& arg;       
};

template<Float_FF fun(Float_FF)> 
class AnyFloatFun1: public OneFunCompound   {
  public:
    AnyFloatFun1 (const char *name_,      
                 const FloatFun& arg_    
                 )
    : OneFunCompound (name_, arg_){}
    virtual Float_FF operator() () const {
      return fun(arg());
    }
  protected:
    virtual ~AnyFloatFun1() {}
};

//  Class TwoFunCompound:
// Helper class for binary arithmetic operations between FloatFun objects
/*
 * This Class holds pointers to two other FloatFun objects.
 * The derived classes ProdOfTwoFuns and SumOfTwoFuns implement
 * operator().
 */
class TwoFunCompound : public FloatFun {
  public:
    TwoFunCompound (const FloatFun& lhs_, 
                    const std::string opname_,
                    const FloatFun& rhs_
                   );
    TwoFunCompound (const std::string funname_,
                    const FloatFun& lhs_, 
                    const FloatFun& rhs_
                   );
    TwoFunCompound (const FloatFun& lhs_, 
                    const FloatFun& rhs_, 
                    const std::string name_
                   );
    
    virtual Float_FF operator() () const = 0;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    virtual ~TwoFunCompound() {} 

    const FloatFun& lhs;
    const FloatFun& rhs;
};

template<Float_FF fun(Float_FF, Float_FF)> 
class AnyFloatFun2: public TwoFunCompound   {
  public:
    AnyFloatFun2 (const char *name_,      
                  const FloatFun& lhs_,  
                  const FloatFun& rhs_   
                 )
    : TwoFunCompound (name_, lhs_, rhs_){}
    AnyFloatFun2 (const FloatFun& lhs_,  
                  const char *opname_,    
                  const FloatFun& rhs_   
                 )
    : TwoFunCompound (lhs_, name_, rhs_){}
    virtual Float_FF operator() () const {
      return fun(lhs(), rhs());
    }
  protected:
    virtual ~AnyFloatFun2() {}
};

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

//  Class DiffOfTwoFuns:
// Helper class for the implementation of FloatFun - FloatFun
/*
 * Returns the differemce of two FloatFun objects.
 */
class DiffOfTwoFuns : public TwoFunCompound {
  public:
    DiffOfTwoFuns (const FloatFun& lhs_,   
                   const FloatFun& rhs_    
                  )
    : TwoFunCompound (lhs_, "-", rhs_) {}
  
    virtual Float_FF operator() () const {
      return lhs() - rhs();
    };
    
  protected:
    ~DiffOfTwoFuns() {} 
};
 

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

//  Class DivOfTwoFuns:
// Helper class for the implementation of FloatFun / FloatFun
/*
 * Returns the quotient of two FloatFun objects.
 */
class DivOfTwoFuns : public TwoFunCompound {
  public:
    DivOfTwoFuns (const FloatFun& lhs_, const FloatFun& rhs_)
    : TwoFunCompound (lhs_, "/", rhs_) {}
  
    virtual Float_FF operator() () const {
      Float_FF r = rhs();
      return (r) ? lhs() / r : 0;
    };
    
  protected:
    ~DivOfTwoFuns() {} 
};

//  Class ScalarSumFloatFun:
// Helper class for sum of a FloatFun with a scalar value
class ScalarSumFloatFun: public OneFunCompound   {
  public:
    ScalarSumFloatFun (Float_FF s_,                     
                       const FloatFun& arg_             
                       )
    : OneFunCompound (str(s_)+"+", arg_), s (s_), a(1) {}
    ScalarSumFloatFun (Float_FF s_,                     
                       const FloatFun& arg_,            
                       Float_FF a_,                     
                       const std::string& name_         
                       )
    : OneFunCompound (arg_, name_), s (s_), a(a_) {}
    
    virtual Float_FF operator() () const { return s + a*arg(); }
    
  protected:
    virtual ~ScalarSumFloatFun() {}

    Float_FF s;                                      
    Float_FF a;                                      
};

//  Class ScalarProductFloatFun:
// Helper class for multiplication of a FloatFun with a scalar value
class ScalarProductFloatFun: public OneFunCompound   {
  public:
    ScalarProductFloatFun (Float_FF s_,                     
                           const FloatFun& arg_             
                           )
    : OneFunCompound (str(s_)+"*", arg_), s (s_) {}
    ScalarProductFloatFun (const std::string& funname_,     
                           Float_FF s_,                     
                           const FloatFun& arg_             
                           )
    : OneFunCompound (funname_, arg_), s (s_) {}
    
    virtual Float_FF operator() () const { return s * arg(); }
    
  protected:
    virtual ~ScalarProductFloatFun() {} 

    Float_FF s;                                      
};

//  Class ScalarDivisionFloatFun:
// Helper class for division of a scalar value by a FloatFun
class ScalarDivisionFloatFun: public OneFunCompound   {
  public:
    ScalarDivisionFloatFun (Float_FF s_,            
                            const FloatFun& arg_    
                            )
    : OneFunCompound (str(s_)+'/', arg_), s (s_) {};
    
    virtual Float_FF operator() () const {
      Float_FF a = arg();
      return (a) ? s/a : 0;
    }
    
  protected:
    virtual ~ScalarDivisionFloatFun() {}; 

    Float_FF s;                                      
};

//  Class TwoFloatFunComp:
// Helper class for comparisons between FloatFun objects
/*
 * This cut holds pointers to two FloatFun objects.
 * The derived classes implement operator().
 */
class  TwoFloatFunComp: public FloatFunComp {
  public:
    TwoFloatFunComp (const FloatFun& lhs_,        
                     const std::string& opname_,   
                     const FloatFun& rhs_         
                    );
    virtual Float_FF lhsValue() const {
      return lhs();
    }
    virtual Float_FF rhsValue() const {
      return rhs();
    }
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    virtual ~TwoFloatFunComp() {} 

    const FloatFun& lhs;                     
    const FloatFun& rhs;                     
};


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

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

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

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

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

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


//  Class ChainComparison:
// Abstract base class for (FloatFun < FloatFun) < FloatFun
class  ChainComparison: public FloatFunComp {
  public:
    ChainComparison (const FloatFunComp& lhs_,    
                     const std::string&  opname_, 
                     const FloatFun&     rhs_     
                     );
    virtual Float_FF lhsValue() const {
      return lhs.lhsValue();
    }
    virtual Float_FF rhsValue() const {
      return rhs();
    }
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    virtual ~ChainComparison() {}
    
    // Data members
    const FloatFunComp& lhs;    
    const FloatFun&     rhs;    
};

//  Class ChainCompLess:
// Helper class for (FloatFun < FloatFun) < FloatFun
class  ChainCompLess: public ChainComparison {
  public:
    ChainCompLess (const FloatFunComp&  lhs_,    
                   const FloatFun&  rhs_         
                   )
    : ChainComparison (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() < rhs());
    }
    
  protected:
    virtual ~ChainCompLess() {}
};

//  Class ChainCompLessEqual:
// Helper class for (FloatFun < FloatFun) <= FloatFun
class  ChainCompLessEqual: public ChainComparison {
  public:
    ChainCompLessEqual (const FloatFunComp&  lhs_,    
                        const FloatFun&  rhs_               
                       )
    : ChainComparison (lhs_, "<=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() <= rhs());
    }
    
  protected:
    virtual ~ChainCompLessEqual() {}
};

//  Class ChainCompGreater:
// Helper class for (FloatFun > FloatFun) > FloatFun
class  ChainCompGreater: public ChainComparison {
  public:
    ChainCompGreater (const FloatFunComp&  lhs_,    
                      const FloatFun&  rhs_               
                      )
    : ChainComparison (lhs_, ">", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() > rhs());
    }
    
  protected:
    virtual ~ChainCompGreater() {}
};

//  Class ChainCompGreaterEqual:
//  Helper class for (FloatFun > FloatFun) >= FloatFun
class  ChainCompGreaterEqual: public ChainComparison {
  public:
    ChainCompGreaterEqual (const FloatFunComp&  lhs_,    
                           const FloatFun&  rhs_               
                          )
    : ChainComparison (lhs_, ">=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() >= rhs());
    }
    
  protected:
    virtual ~ChainCompGreaterEqual() {}
};

//  Class ChainCompEqual:
//  Helper class for (FloatFun > FloatFun) == FloatFun
class  ChainCompEqual: public ChainComparison {
  public:
    ChainCompEqual (const FloatFunComp&  lhs_,    
                    const FloatFun&  rhs_               
                   )
    : ChainComparison (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() == rhs());
    }
    
  protected:
    virtual ~ChainCompEqual() {}
};

//  Class ChainCompNotEqual:
//  Helper class for (FloatFun > FloatFun) != FloatFun
class  ChainCompNotEqual: public ChainComparison {
  public:
    ChainCompNotEqual (const FloatFunComp&  lhs_,    
                       const FloatFun&  rhs_               
                      )
    : ChainComparison (lhs_, "!=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() != rhs());
    }
    
  protected:
    virtual ~ChainCompNotEqual() {}
};


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

    // Data members
    const FloatFunComp& lhs;    
    Float_FF            rhs;    
};

//  Class ChainCompFloatLess:
//  Helper class for (FloatFun < FloatFun) < Float_FF
class  ChainCompFloatLess: public ChainCompFloat {
  public:
    ChainCompFloatLess (const FloatFunComp& lhs_,    
                        Float_FF            rhs_      
                        )
    : ChainCompFloat (lhs_, "<", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() < rhs);
    }
    
  protected:
    virtual ~ChainCompFloatLess() {}
};

//  Class ChainCompFloatLessEqual:
//  Helper class for (FloatFun < FloatFun) <= Float_FF
class  ChainCompFloatLessEqual: public ChainCompFloat {
  public:
    ChainCompFloatLessEqual (const FloatFunComp& lhs_,    
                             Float_FF            rhs_     
                            )
    : ChainCompFloat (lhs_, "<=", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() <= rhs);
    }
    
  protected:
    virtual ~ChainCompFloatLessEqual() {}
};

//  Class ChainCompFloatGreater:
//  Helper class for (FloatFun < FloatFun) > Float_FF
class  ChainCompFloatGreater: public ChainCompFloat {
  public:
    ChainCompFloatGreater (const FloatFunComp& lhs_,    
                           Float_FF            rhs_     
                           )
    : ChainCompFloat (lhs_, ">", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() > rhs);
    }
    
  protected:
    virtual ~ChainCompFloatGreater() {}
};

//  Class ChainCompFloatGreaterEqual:
//  Helper class for (FloatFun < FloatFun) >= Float_FF
class  ChainCompFloatGreaterEqual: public ChainCompFloat {
  public:
    ChainCompFloatGreaterEqual (const FloatFunComp& lhs_,    
                                Float_FF            rhs_     
                               )
    : ChainCompFloat (lhs_, ">=", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() >= rhs);
    }
    
  protected:
    virtual ~ChainCompFloatGreaterEqual() {}
};

//  Class ChainCompFloatEqual:
//  Helper class for (FloatFun < FloatFun) == Float_FF
class  ChainCompFloatEqual: public ChainCompFloat {
  public:
    ChainCompFloatEqual (const FloatFunComp& lhs_,    
                         Float_FF            rhs_     
                        )
    : ChainCompFloat (lhs_, "==", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() == rhs);
    }
    
  protected:
    virtual ~ChainCompFloatEqual() {}
};

//  Class ChainCompFloatNotEqual:
//  Helper class for (FloatFun < FloatFun) != Float_FF
class  ChainCompFloatNotEqual: public ChainCompFloat {
  public:
    ChainCompFloatNotEqual (const FloatFunComp& lhs_,    
                            Float_FF            rhs_     
                            )
    : ChainCompFloat (lhs_, "!=", rhs_) {}
    virtual bool operator() () const {
      return lhs() && (lhs.rhsValue() != rhs);
    }
    
  protected:
    virtual ~ChainCompFloatNotEqual() {}
};

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

    // Data members
    Float_FF           lhs;     
    const FloatFun& rhs;     
};

//  Class FloatFloatFunLess:
//  Helper class for Float_FF < FloatFun
class  FloatFloatFunLess: public FloatFloatFunComp {
  public:
    FloatFloatFunLess (Float_FF        lhs_,    
                       const FloatFun& rhs_     
                      )
    : FloatFloatFunComp (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs < rhs();
    }
  protected:
    virtual ~FloatFloatFunLess() {}
};

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

//  Class FloatFloatFunGreater:
//  Helper class for Float_FF > FloatFun
class  FloatFloatFunGreater: public FloatFloatFunComp {
  public:
    FloatFloatFunGreater (Float_FF        lhs_,    
                          const FloatFun& rhs_     
                         )
    : FloatFloatFunComp (lhs_,">",  rhs_) {}
    
    virtual bool operator() () const {
      return lhs > rhs();
    }
  protected:
    virtual ~FloatFloatFunGreater() {}
};

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

//  Class FloatFloatFunEqual:
//  Helper class for Float_FF == FloatFun
class  FloatFloatFunEqual: public FloatFloatFunComp {
  public:
    FloatFloatFunEqual (Float_FF        lhs_,    
                        const FloatFun& rhs_     
                       )
    : FloatFloatFunComp (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs == rhs();
    }
  protected:
    virtual ~FloatFloatFunEqual() {}
};

//  Class FloatFloatFunEqual:
//  Helper class for Float_FF != FloatFun
class  FloatFloatFunNotEqual: public FloatFloatFunComp {
  public:
    FloatFloatFunNotEqual (Float_FF        lhs_,    
                           const FloatFun& rhs_     
                          )
    : FloatFloatFunComp (lhs_, "!=", rhs_) {}
    
    virtual bool operator() () const {
      return lhs != rhs();
    }
  protected:
    virtual ~FloatFloatFunNotEqual() {}
};


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

    // Data members
    const FloatFun& lhs;     
    Float_FF           rhs;     
};

//  Class FloatFunFloatLess:
//  Helper class for FloatFun < Float_FF
class  FloatFunFloatLess: public FloatFunFloatComp {
  public:
    FloatFunFloatLess (const FloatFun& lhs_,    
                       Float_FF        rhs_     
                      )
    : FloatFunFloatComp (lhs_, "<", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() < rhs;
    }
  protected:
    virtual ~FloatFunFloatLess() {}
};

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

//  Class FloatFunFloatGreater:
//  Helper class for FloatFun > Float_FF
class  FloatFunFloatGreater: public FloatFunFloatComp {
  public:
    FloatFunFloatGreater (const FloatFun& lhs_,    
                          Float_FF        rhs_     
                         )
    : FloatFunFloatComp (lhs_, ">", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() > rhs;
    }
  protected:
    virtual ~FloatFunFloatGreater() {}
};

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

//  Class FloatFunFloatEqual:
//  Helper class for FloatFun == Float_FF
class  FloatFunFloatEqual: public FloatFunFloatComp {
  public:
    FloatFunFloatEqual (const FloatFun& lhs_,    
                        Float_FF        rhs_     
                        )
    : FloatFunFloatComp (lhs_, "==", rhs_) {}
    
    virtual bool operator() () const {
      return lhs() == rhs;
    }
  protected:
    virtual ~FloatFunFloatEqual() {}
};

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


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

class CachedFloatFunIt: public FloatFun, public CachedO {
  public:
    CachedFloatFunIt (const ROListPoR&     rol,  
                      const FloatFun&      arg_, 
                      const FillIterator&  iter_ 
                     );
    
    virtual Float_FF 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 ~CachedFloatFunIt() {}
    
    // Data members
    const   FloatFun& arg;                      
    const   FillIterator&  iter;                  
    mutable std::vector<bool>  cacheValid;      
    mutable std::vector<Float_FF> cachedValues;    
};


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

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

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

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

// Returns sum of all fun objects that fulfill cut
class AverageFloatFun: public CollectiveFloatFun {
  public: 
    AverageFloatFun (const FloatFunPoRConst&      fun_=0,      
                     const BaseCutPoRConst&       cut_=0,      
                     const FillIteratorPoR&       intiter_=0,  
                     const FillIteratorPoRConst&  extiter_=0   
                     )
     : CollectiveFloatFun  ("average", fun_, cut_, intiter_, extiter_)
     {}
     
   virtual Float_FF operator() () const;           
  protected:
    virtual ~AverageFloatFun() {}
};
 
#endif /* #ifndef __FLOATFUNHELPERS_H */

---