FloatFun.h

Go to the documentation of this file.

#ifndef __FLOATFUN_H
#define __FLOATFUN_H
 
#ifndef __FLOATFUNBASE_H
#include "jbltools/sfh/FloatFunBase.h"
#endif /* #ifndef __FLOATFUNBASE_H */

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

#include "jbltools/sfh/BaseCutBase.h"     // needed as base class of FloatFunComp
#include "jbltools/sfh/BaseCutPoR.h"      // needed for default argument 
#include "jbltools/sfh/FillIteratorPoR.h" // needed for default argument 
#include "jbltools/sfh/FloatFunPoR.h"     // needed for automagic conversion 
#include "jbltools/sfh/ROListPoR.h"     // needed for automagic conversion 

// Class ConstFun
class ConstFun : public FloatFun {
  public: 
    // Constructors
    explicit ConstFun (Float_FF c_,                     
                       const char *name_ = 0            
                      ) 
   : FloatFun (name_ ? name_ : str(c_).c_str(), str(c_)), 
     c(c_) 
   {}
             ConstFun (Float_FF c_,                    
                       const std::string &name_        
                      ) 
    : FloatFun (name_, str(c_)), 
      c(c_) 
      {}
    virtual Float_FF operator() () const { return c; }
  protected:
    Float_FF c;                                           

    virtual ~ConstFun() {}
};

// Class UnityFun
// A FloatFun that returns a constant value of 1
/*
 * This class exists only for historical reasons
 * Today, a weight of "1" is simply achieved by having no
 * weight function.
 */
class UnityFun : public ConstFun {
  public: 
    UnityFun () : ConstFun (1., "1.0") {}
  protected:
    virtual ~UnityFun() {}
};

//  Class FloatFunComp:

class  FloatFunComp: public BaseCut {
  public:
    FloatFunComp (const std::string& name_) : BaseCut (name_) {}
    virtual Float_FF lhsValue() const = 0; 
    virtual Float_FF rhsValue() const = 0; 
};


// External functions that implement arithmetic operators between
// cut, so that we can write e.g. "funa + (funb * func)"


FloatFun& operator+ (const FloatFun& lhs_, const FloatFun& rhs_);


FloatFun& operator+ (const FloatFun& lhs_, Float_FF rhs_);


FloatFun& operator+ (Float_FF lhs_, const FloatFun& rhs_);


FloatFun& operator- (const FloatFun& lhs_, const FloatFun& rhs_);


FloatFun& operator- (const FloatFun& lhs_, Float_FF rhs_);

FloatFun& operator- (Float_FF lhs_, const FloatFun& rhs_);


FloatFun& operator- (const FloatFun& arg_);


FloatFun& operator+ (FloatFun& arg_);
const FloatFun& operator+ (const FloatFun& arg_);



FloatFun& operator* (const FloatFun& lhs_, const FloatFun& rhs_);


FloatFun& operator* (Float_FF lhs_, const FloatFun& rhs_);


FloatFun& operator* (const FloatFun& lhs_, Float_FF rhs_);




FloatFun& operator/ (const FloatFun& lhs_, const FloatFun& rhs_);


FloatFun& operator/ (Float_FF lhs_, const FloatFun& rhs_);


FloatFun& operator/ (const FloatFun& lhs_, Float_FF rhs_);



FloatFun& abs (const FloatFun& arg_);


FloatFun& acos (const FloatFun& arg_);

// /// Area cosine of a FloatFun
// /** \relates FloatFun */
// FloatFun& acosh (const FloatFun& arg_);
// 

FloatFun& asin (const FloatFun& arg_);

// /// Area sine of a FloatFun
// /** \relates FloatFun */
// FloatFun& asinh (const FloatFun& arg_);
// 

FloatFun& atan (const FloatFun& arg_);

// /// Area Tangent of a FloatFun
// /** \relates FloatFun */
// FloatFun& atanh (const FloatFun& arg_);
// 

FloatFun& atan2 (const FloatFun& arg1, const FloatFun& arg2);


FloatFun& ceil (const FloatFun& arg_);


FloatFun& cos (const FloatFun& arg_);


FloatFun& cosh (const FloatFun& arg_);


FloatFun& exp (const FloatFun& arg_);


FloatFun& fabs (const FloatFun& arg_);


FloatFun& floor (const FloatFun& arg_);


FloatFun& log (const FloatFun& arg_);


FloatFun& log10 (const FloatFun& arg_);


FloatFun& pow (const FloatFun& arg1_, const FloatFun& arg2_);


FloatFun& sin (const FloatFun& arg_);


FloatFun& sinh (const FloatFun& arg_);

<<<<<<< FloatFun.h
//  Class FloatFloatFunLessEqual:
//  Helper class for float <= FloatFun
class  FloatFloatFunLessEqual: public FloatFloatFunComp {
  public:
    FloatFloatFunLessEqual (float           lhs_,    
                            const FloatFun& rhs_     
                           )
    : FloatFloatFunComp (lhs_, rhs_, "%8f<=(%s)") {}
    
    virtual bool operator() () const {
      return lhs <= rhs();
    }
  protected:
    virtual ~FloatFloatFunLessEqual() {}
};

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

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

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

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


//  Class FloatFunFloatComp:
//  Helper class for comparisons between a float and a FloatFun 
/*
 * This cut holds a pointer to a FloatFun and a float 
 * The derived classes operator().
 */
class  FloatFunFloatComp: public FloatFunComp {
  public:
    FloatFunFloatComp (const FloatFun& lhs_,              
                       float           rhs_,    
                       const char *format="FloatFunFloatComp(%s,float)"
                      );
    virtual float lhsValue() const {
      return lhs();
    }
    virtual float rhsValue() const {
      return rhs;
    }
    
    virtual const FillIterator *getIterator() const {  
      return lhs.getIterator(); 
    }
    
    virtual const char *getName() const { return name; }
  protected:
    virtual ~FloatFunFloatComp() {
      delete[] name;
      name = 0;
    } 

    // Data members
    const FloatFun& lhs;     
    float           rhs;     
    char *name;                              
  private:
    FloatFunFloatComp (const FloatFunFloatComp& source);
    FloatFunFloatComp& operator= (const FloatFunFloatComp& source);
};

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

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

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

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

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

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

// Base class for "collective" FloatFun classes that determine minimum, maximum etc.
class CollectiveFloatFun: public FloatFun {
  public:
    CollectiveFloatFun (const FloatFunPoR&      fun_=0,      
                        const BaseCutPoR&       cut_=0,      
                        const FillIteratorPoR&  intiter_=0,  
                        const FillIteratorPoR&  extiter_=0,  
                        const char *format="(CollectiveFloatFun(%s,%s,%s,%s)"
                       );           
    virtual const FillIterator *getIterator() const {  
      return extiter; 
    }
    
    virtual const char *getName() const { return name; }
    
  protected:
    virtual ~CollectiveFloatFun() {
      delete[] name;
      name = 0;
    }
    void checkIterators();
    void makeName(const char *format);
    // Data members
    const FloatFun      *fun;      
    const BaseCut       *cut;      
          FillIterator  *intiter;  
    const FillIterator  *extiter;  
    char *name;                              
  private:
     CollectiveFloatFun(const CollectiveFloatFun& source);
    CollectiveFloatFun& operator= (const CollectiveFloatFun& source);
};

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

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

// Returns sum of all fun objects that fulfill cut
class SumFloatFun: public CollectiveFloatFun {
  public: 
    SumFloatFun (const FloatFunPoR&      fun_=0,      
                 const BaseCutPoR&       cut_=0,      
                 const FillIteratorPoR&  intiter_=0,  
                 const FillIteratorPoR&  extiter_=0   
                 )
     : CollectiveFloatFun  (fun_, cut_, intiter_, extiter_, "sum(%s,%s,%s,%s)")
     {}
     
   virtual float operator() () const;           
  protected:
    virtual ~SumFloatFun() {}
};

// Returns sum of all fun objects that fulfill cut
class AverageFloatFun: public CollectiveFloatFun {
  public: 
    AverageFloatFun (const FloatFunPoR&      fun_=0,      
                     const BaseCutPoR&       cut_=0,      
                     const FillIteratorPoR&  intiter_=0,  
                     const FillIteratorPoR&  extiter_=0   
                     )
     : CollectiveFloatFun  (fun_, cut_, intiter_, extiter_, "average(%s,%s,%s,%s)")
     {}
     
   virtual float operator() () const;           
  protected:
    virtual ~AverageFloatFun() {}
};


class CachedFloatFun: public FloatFun, public CachedO {
  public:
    CachedFloatFun (const ROListPoR& rol,  
                    const FloatFun&  arg_  
                   );
    
    virtual float operator() () const;
    
    virtual void invalidateCache() { cacheValid = false; }
    
    virtual const char *getName() const { return CachedFloatFun::name; }
    
  protected:
    virtual ~CachedFloatFun() {
      delete[] name;
      name = 0;
    }
    
    // Data members
    const   FloatFun& arg;         
    mutable bool cacheValid;       
    mutable float cachedValue;     
    char *name;                              
    
  private:
    CachedFloatFun (const CachedFloatFun& rhs);
    CachedFloatFun& operator= (const CachedFloatFun& rhs);
};

class CachedFloatFunIt: public FloatFun, public CachedO {
  public:
    CachedFloatFunIt (const ROListPoR&     rol,  
                      const FloatFun&      arg_, 
                      const FillIterator&  iter_ 
                     );
    
    virtual float operator() () const;
    
    virtual const FillIterator *getIterator() const { 
      return &iter; 
    }
    
    virtual void invalidateCache() {   
      cacheValid.resize(0);
      cachedValues.resize(0);
    }
    
    virtual const char *getName() const { return name; }
    
  protected:
    void growCache (unsigned int s) const;
  
    virtual ~CachedFloatFunIt() {
      delete[] name;
      name = 0;
    }
    
    // Data members
    const   FloatFun& arg;                      
    const   FillIterator&  iter;                  
    mutable std::vector<bool>  cacheValid;      
    mutable std::vector<float> cachedValues;    
    char *name;                              
    
  private:
    CachedFloatFunIt (const CachedFloatFunIt& rhs);
    CachedFloatFunIt& operator= (const CachedFloatFunIt& rhs);
};

// External functions that implement arithmetic operators between
// cut, so that we can write e.g. "funa + (funb * func)"


inline FloatFun& operator+ (const FloatFun& lhs_, const FloatFun& rhs_) {
  return *new SumOfTwoFuns (lhs_, rhs_);
}


inline FloatFun& operator+ (const FloatFun& lhs_, float rhs_) {
  return *new ScalarSumFloatFun (rhs_, lhs_);
}

inline FloatFun& operator+ (float lhs_, const FloatFun& rhs_) {
  return *new ScalarSumFloatFun (lhs_, rhs_);
}


inline FloatFun& operator- (const FloatFun& lhs_, const FloatFun& rhs_) {
  return *new DiffOfTwoFuns (lhs_, rhs_);
}

inline FloatFun& operator- (const FloatFun& lhs_, float rhs_) {
  return *new ScalarSumFloatFun (-rhs_, lhs_, 1, NamedO::str('(')+lhs_.getName()+")-"+NamedO::str(rhs_));
}

inline FloatFun& operator- (float lhs_, const FloatFun& rhs_) {
  return *new ScalarSumFloatFun (lhs_, rhs_, -1, NamedO::str(lhs_)+"-("+rhs_.getName()+')');
}


inline FloatFun& operator- (const FloatFun& arg_) {
  return *new ScalarProductFloatFun ("-", -1, arg_);
}



inline FloatFun& operator* (const FloatFun& lhs_, const FloatFun& rhs_) {
  if (&lhs_ == &rhs_) return *new SquareFloatFun (lhs_);
  return *new ProdOfTwoFuns (lhs_, rhs_);
}


inline FloatFun& operator* (float lhs_, const FloatFun& rhs_) {
  return *new ScalarProductFloatFun (lhs_, rhs_);
}

inline FloatFun& operator* (const FloatFun& lhs_, float rhs_) {
  return *new ScalarProductFloatFun (rhs_, lhs_);
}

=======

FloatFun& sqrt (const FloatFun& arg_);
>>>>>>> 1.25


FloatFun& tan (const FloatFun& arg_);


FloatFun& tanh (const FloatFun& arg_);


FloatFun& square (const FloatFun& arg_);


FloatFun& rad (const FloatFun& arg_);


FloatFun& deg (const FloatFun& arg_);


// External functions that implement comparison operators between
// FloatFun objects


FloatFunComp& operator< (const FloatFun& lhs_, const FloatFun& rhs_);

FloatFunComp& operator> (const FloatFun& lhs_, const FloatFun& rhs_);

FloatFunComp& operator<= (const FloatFun& lhs_, const FloatFun& rhs_);

FloatFunComp& operator>= (const FloatFun& lhs_, const FloatFun& rhs_);

FloatFunComp& operator== (const FloatFun& lhs_, const FloatFun& rhs_);

FloatFunComp& operator!= (const FloatFun& lhs_, const FloatFun& rhs_);

// External functions that implement comparison operators between
// a Float_FF and a FloatFun object

FloatFunComp& operator< (Float_FF lhs_, const FloatFun& rhs_);

FloatFunComp& operator<= (Float_FF lhs_, const FloatFun& rhs_);

FloatFunComp& operator> (Float_FF lhs_, const FloatFun& rhs_);

FloatFunComp& operator>= (Float_FF lhs_, const FloatFun& rhs_);

FloatFunComp& operator== (Float_FF lhs_, const FloatFun& rhs_);

FloatFunComp& operator!= (Float_FF lhs_, const FloatFun& rhs_);

// External functions that implement comparison operators between
// a FloatFun object and a Float_FF
FloatFunComp& operator< (const FloatFun& lhs_, Float_FF rhs_);

FloatFunComp& operator<= (const FloatFun& lhs_, Float_FF rhs_);

FloatFunComp& operator> (const FloatFun& lhs_, Float_FF rhs_);

FloatFunComp& operator>= (const FloatFun& lhs_, Float_FF rhs_);

FloatFunComp& operator== (const FloatFun& lhs_, Float_FF rhs_);

FloatFunComp& operator!= (const FloatFun& lhs_, Float_FF rhs_);

// External functions that allow chain comparisons like 1 < x < y <= 15
// Such a chain comparison is defined as
// (1 < x) && (x < y) && (y <= 15)

FloatFunComp& operator< (const FloatFunComp& lhs_, const FloatFun& rhs_);

FloatFunComp& operator<= (const FloatFunComp& lhs_, const FloatFun& rhs_);

FloatFunComp& operator> (const FloatFunComp& lhs_, const FloatFun& rhs_);

FloatFunComp& operator>= (const FloatFunComp& lhs_, const FloatFun& rhs_);

FloatFunComp& operator== (const FloatFunComp& lhs_, const FloatFun& rhs_);

FloatFunComp& operator!= (const FloatFunComp& lhs_, const FloatFun& rhs_);

FloatFunComp& operator< (const FloatFunComp& lhs_, Float_FF rhs_);
FloatFunComp& operator<= (const FloatFunComp& lhs_, Float_FF rhs_);
FloatFunComp& operator> (const FloatFunComp& lhs_, Float_FF rhs_);
FloatFunComp& operator>= (const FloatFunComp& lhs_, Float_FF rhs_);
FloatFunComp& operator== (const FloatFunComp& lhs_, Float_FF rhs_);
FloatFunComp& operator!= (const FloatFunComp& lhs_, Float_FF rhs_);

FloatFun& max (const FloatFunPoRConst&      fun,        
               const BaseCutPoRConst&       cut=0,      
               const FillIteratorPoR&       intiter=0,  
               const FillIteratorPoRConst&  extiter=0   
              );

FloatFun& min (const FloatFunPoRConst&      fun,        
               const BaseCutPoRConst&       cut=0,      
               const FillIteratorPoR&       intiter=0,  
               const FillIteratorPoRConst&  extiter=0   
              );

FloatFun& sum (const FloatFunPoRConst&      fun,        
               const BaseCutPoRConst&       cut=0,      
               const FillIteratorPoR&       intiter=0,  
               const FillIteratorPoRConst&  extiter=0   
              );

FloatFun& average (const FloatFunPoRConst&      fun,        
                   const BaseCutPoRConst&       cut=0,      
                   const FillIteratorPoR&       intiter=0,  
                   const FillIteratorPoRConst&  extiter=0   
                  );

FloatFun& cached (const ROListPoR&   rol,        
                  const FloatFunPoR& fun,        
                  const FillIteratorPoR& iter=0  
                 );

#endif /* #ifndef __FLOATFUN_H */

---