IntFun.C

Go to the documentation of this file.

#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/FloatFun.h"
#include "jbltools/sfh/IntFunHelpers.h"
#include "jbltools/sfh/JBLMath.h"

#include <cstdlib>
#include <iostream>
#include <climits>
#include <cmath>

#include <stdio.h>
#include <cstring>
#include <vector>

static const char *ident="@(#)$Id: IntFun.C,v 1.16 2005/11/22 09:00:17 blist Exp $";

FloatIntFun::FloatIntFun(const IntFun& theIntFun_, const char *name_)
: FloatFun (name_ ? name_ : std::string("float(")+theIntFun_.getName()+")"),
  theIntFun (theIntFun_) 
  {}

OneIntFunCompound::OneIntFunCompound (const std::string& funname_, const IntFun& arg_)
: IntFun (funname_+'('+arg_.getName()+')'),
  arg (arg_) 
  {}
    
ScalarIntFunCompound::ScalarIntFunCompound (int s_,  const std::string& opname_, const IntFun& fun_)
: IntFun (str(s_)+opname_+'('+fun_.getName()+')'),
  fun (fun_), s (s_) 
{
  assert(&fun); 
}
ScalarIntFunCompound::ScalarIntFunCompound (int s_, const IntFun& fun_,  const std::string& name_)
: IntFun (name_),
  fun (fun_), s (s_) 
{
  assert(&fun); 
}

ScalarDivisionIntFun2::ScalarDivisionIntFun2 (const IntFun& fun_, int s_)
  : ScalarIntFunCompound (s_, fun_, std::string(fun_.getName())+'/'+str(s_))
{}

TwoIntFunCompound::TwoIntFunCompound (const IntFun& lhs_, const std::string& opname_,  const IntFun& rhs_)
: IntFun (str('(')+lhs_.getName()+')'+opname_+'('+rhs_.getName()+')'),
  lhs (lhs_), 
  rhs (rhs_)
{
  assert (&lhs);
  assert (&rhs);
  assert (!lhs.getIterator() || !rhs.getIterator() || lhs.getIterator()==rhs.getIterator());
}

const FillIterator *TwoIntFunCompound::getIterator() const { 
  assert (!lhs.getIterator() || !rhs.getIterator() || lhs.getIterator()==rhs.getIterator());
  return (lhs.getIterator()) ? lhs.getIterator() : rhs.getIterator();
}
    
    
TwoIntFunComp::TwoIntFunComp (const IntFun& lhs_, const std::string& opname_, const IntFun& rhs_)
: IntFunComp (str('(')+lhs_.getName()+')'+opname_+'('+rhs_.getName()+')'),
  lhs (lhs_), 
  rhs (rhs_)
{
  assert (&lhs);
  assert (&rhs);
}

IntChainComparison::IntChainComparison (const IntFunComp& lhs_, const std::string& opname_, const IntFun& rhs_)
: IntFunComp (str('(')+lhs_.getName()+')'+opname_+'('+rhs_.getName()+')'), 
  lhs (lhs_), 
  rhs (rhs_)
{
  assert (&lhs);
  assert (&rhs);
}

IntChainCompInt::IntChainCompInt (const IntFunComp& lhs_, const std::string& opname_, int rhs_)
: IntFunComp (str('(')+lhs_.getName()+')'+opname_+str(rhs_)), 
  lhs (lhs_), 
  rhs (rhs_) 
{
  assert (&lhs);
}
IntIntFunComp::IntIntFunComp (int lhs_, const std::string& opname_, const IntFun& rhs_)
: IntFunComp (str(lhs_)+opname_+'('+rhs_.getName()+')'), 
  lhs (lhs_), 
  rhs (rhs_) 
{
  assert (&rhs);
}

IntFunIntComp::IntFunIntComp (const IntFun& lhs_, const std::string& opname_, int rhs_)
: IntFunComp (str('(')+lhs_.getName()+')'+opname_+str(rhs_)), 
  lhs (lhs_), 
  rhs (rhs_)
{
  assert (&lhs);
}

FloatFun& IntFun::Float () const {
  return *new FloatIntFun(*this);
}


CollectiveIntFun::CollectiveIntFun (const std::string&          funname_,
                                    const IntFunPoRConst&       fun_,
                                    const BaseCutPoRConst&      cut_,     
                                    const FillIteratorPoR&      intiter_, 
                                    const FillIteratorPoRConst& extiter_
                                   )
: IntFun (makeName (funname_, fun_, cut_, intiter_, extiter_)),
  fun (fun_.pif), cut (cut_.pbc), intiter (intiter_.pfi), extiter (extiter_.pfi)
{ 
  checkIterators();
  setName (makeName (funname_, fun, cut, intiter, extiter));
}     
                
std::string CollectiveIntFun::makeName(const std::string&           funname_,       
                                       const IntFunPoRConst&        fun_,        
                                       const BaseCutPoRConst&       cut_,      
                                       const FillIteratorPoR&       intiter_,  
                                       const FillIteratorPoRConst&  extiter_   
                                      ){
  const char *fname       = fun_.pif     ? fun_.pif->getName() : 0;
  const char *cutname     = cut_.pbc     ? cut_.pbc->getName() : 0;
  const char *intitername = intiter_.pfi ? intiter_.pfi->getName() : 0;
  const char *extitername = extiter_.pfi ? extiter_.pfi->getName() : 0;
  if (!fname)       fname="1";
  if (!cutname)     cutname="true";
  std::string result = funname_+'('+fname+", "+cutname+')';
  if (extitername) result = result + '['+intitername+']';
  
  return result;
}

void CollectiveIntFun::checkIterators() {
  // Rules:
  // If no internal iterator is given, try to get iterator from
  // fun or cut; if both have an iterator, they must be equal or 
  // one of them must be equal to the external ietartor
  
  FillIterator *funiter = fun ? const_cast<FillIterator *>(fun->getIterator()) : 0;
  FillIterator *cutiter = cut ? const_cast<FillIterator *>(cut->getIterator()) : 0;
  
  if (!intiter) {
    // intiter not explicitly given, try to get it
    if (funiter && cutiter) {
      // funiter and cutiter defined
      if (funiter == cutiter) {
        if (funiter != extiter) {
          intiter = funiter;
#if (DEBUG>=2)
          std::cerr << "CollectiveIntFun: taking intiter from funiter == cutiter\n";
#endif
        }
      }
      else {
        // funiter and cutiter different: One  must be equal to extiter,
        // the other should become intiter.
        if (funiter == extiter) {
          intiter = cutiter;
#if (DEBUG>=2)
          std::cerr << "CollectiveIntFun: taking intiter from cutiter != funiter\n";
#endif
        }
        else if  (cutiter == extiter) {
          intiter = funiter;
#if (DEBUG>=2)
          std::cerr << "CollectiveIntFun: taking intiter from funiter != cutiter\n";
 #endif
        }
      }
    }
    else if (funiter) {
      // funiter defined, cutiter == 0
      if (funiter != extiter) {
        intiter = funiter;
#if (DEBUG>=2)
        std::cerr << "CollectiveIntFun: taking intiter from funiter, cutiter==0\n";
#endif
      }
    }
    else if (cutiter) {
      // cutiter defined, funiter == 0
      if (cutiter != extiter) {
#if (DEBUG>=2)
        std::cerr << "CollectiveIntFun: taking intiter from cutiter, cutiter==0\n";
#endif
        intiter = cutiter;
      }
    }
    else {
      // funcutiter and cutiter == 0
      std::cerr << "CollectiveIntFun: Error! cutiter, intiter and intiter all 0!\n";
    }
  }
  
  if (!intiter) {
    std::cerr << "CollectiveIntFun: Cannot determine intiter from fun and cut!\n";
  }
  
  assert (intiter);
  assert (!extiter || extiter!=intiter);
  assert (!funiter || funiter==intiter || funiter==extiter);
  assert (!cutiter || cutiter==intiter || cutiter==extiter);
}

int MaxIntFun::operator() () const {
  // int result = std::numeric_limits<int>::min();
  int result = INT_MIN;
  if (intiter->reset()) {
    do {
      if (!cut || (*cut)()) {
        int f = fun ? (*fun)() : 0;
        if (f > result) result = f;
      }
    } while (intiter->next());
  }
  return result;
}             

int MinIntFun::operator() () const {
  // int result = std::numeric_limits<int>::max();
  int result = INT_MAX;
  if (intiter->reset()) {
    do {
      if (!cut || (*cut)()) {
        int f = fun ? (*fun)() : 0;
        if (f < result) result = f;
      }
    } while (intiter->next());
  }
  return result;
}             

int SumIntFun::operator() () const {
  int sum = 0;
  if (intiter->reset()) {
    do {
      if (!cut || (*cut)()) {
        int f = fun ? (*fun)() : 1;
        sum += f;
      }
    } while (intiter->next());
  }
  return sum;
}             

CachedIntFun::CachedIntFun (const ROListPoR& rol, const IntFun&  arg_)
: IntFun (std::string("cached(")+arg_.getName()+')'),
  CachedO (rol), 
  arg(arg_), 
  cacheValid (false)         
{ 
  assert (&arg); 
}   

int CachedIntFun::operator() () const {
  if (!cacheValid) {
    cachedValue = arg();
    cacheValid = true;
  }
  return cachedValue;
}

CachedIntFunIt::CachedIntFunIt (const ROListPoR&     rol, 
                                    const IntFun&      arg_, 
                                    const FillIterator&  iter_ 
                                   )
: IntFun (std::string("cached(")+arg_.getName()+')'),
  CachedO (rol), 
  arg (arg_), 
  iter (iter_), 
  cacheValid (), 
  cachedValues ()              
{ 
  assert (&arg); 
  assert (&iter);
}   

int CachedIntFunIt::operator() () const {
  int i = iter();
  assert (i >= 0);
  if (static_cast<unsigned int>(i) >= cacheValid.size()) growCache (i+1); 
  if (!cacheValid[i]) {
    cacheValid[i] = true;
    cachedValues[i] = arg();
  }
  return cachedValues[i];
}

void CachedIntFunIt::growCache (unsigned int s) const {
  unsigned int oldsize = cacheValid.size();
  if (s < oldsize) return;
  cacheValid.resize (s);
  cachedValues.resize(s);
  for (unsigned int i = oldsize; i < s; ++i) cacheValid[i] = false;
}

IntFun& cached (const ROListPoR&   rol,    
                const IntFunPoR& fun,    
                const FillIteratorPoR& iter
               ) {
  assert (fun.pif);                     
  if (iter.pfi) return *new CachedIntFunIt (rol, *fun.pif, *iter.pfi);
  if (const FillIterator *fi = fun.pif->getIterator()) 
    return  *new CachedIntFunIt (rol, *fun.pif, *fi);
  return *new CachedIntFun (rol, *fun.pif);                  
}


FloatFun& Float (const IntFun& arg) {
  return *new FloatIntFun(arg);
}

IntFun& operator+ (const IntFun& lhs_, const IntFun& rhs_) {
  return *new SumOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator+ (int lhs_, const IntFun& rhs_) {
  return *new ScalarSumIntFun (lhs_, rhs_);
}

IntFun& operator+ (const IntFun& lhs_, int rhs_) {
  return *new ScalarSumIntFun (rhs_, lhs_);
}

IntFun& operator- (const IntFun& lhs_, const IntFun& rhs_) {
  return *new DiffOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator- (int lhs_, const IntFun& rhs_) {
  return *new ScalarDiffIntFun (lhs_, rhs_);
}

IntFun& operator- (const IntFun& lhs_, int rhs_) {
  return *new ScalarSumIntFun (-rhs_, lhs_);
}

IntFun& operator- (const IntFun& arg_) {
  return *new ScalarProductIntFun (-1, arg_, std::string("-(")+arg_.getName()+')');
}

IntFun& operator+ (IntFun& arg_) {
  return arg_;
}

const IntFun& operator+ (const IntFun& arg_) {
  return arg_;
}

IntFun& operator* (const IntFun& lhs_, const IntFun& rhs_) {
  if (&lhs_ == &rhs_) return square (lhs_);
  return *new ProdOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator/ (const IntFun& lhs_, const IntFun& rhs_) {
  return *new DivOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator* (int lhs_, const IntFun& rhs_) {
  return *new ScalarProductIntFun (lhs_, rhs_);
}

IntFun& operator* (const IntFun& lhs_, int rhs_) {
  return *new ScalarProductIntFun (rhs_, lhs_);
}


IntFun& operator/ (int lhs_, const IntFun& rhs_) {
  return *new ScalarDivisionIntFun (lhs_, rhs_);
}

IntFun& operator/ (const IntFun& lhs_, int rhs_) {
  return *new ScalarDivisionIntFun2 (lhs_, rhs_);
}

IntFun& operator& (const IntFun& lhs_, const IntFun& rhs_) {
  return *new AndOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator| (const IntFun& lhs_, const IntFun& rhs_) {
  return *new OrOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator^ (const IntFun& lhs_, const IntFun& rhs_) {
  return *new XorOfTwoIntFuns (lhs_, rhs_);
}

IntFun& operator& (const IntFun& lhs_, int rhs_) {
  return *new ScalarAndIntFun (rhs_, lhs_);
}

IntFun& operator& (int lhs_, const IntFun& rhs_) {
  return *new ScalarAndIntFun (lhs_, rhs_);
}

IntFun& operator| (const IntFun& lhs_, int rhs_) {
  return *new ScalarOrIntFun (rhs_, lhs_);
}

IntFun& operator| (int lhs_, const IntFun& rhs_) {
  return *new ScalarOrIntFun (lhs_, rhs_);
}

IntFun& operator^ (const IntFun& lhs_, int rhs_) {
  return *new ScalarXorIntFun (rhs_, lhs_);
}

IntFun& operator^ (int lhs_, const IntFun& rhs_) {
  return *new ScalarXorIntFun (lhs_, rhs_);
}

IntFun& operator~ (const IntFun&  arg_) {
  return *new IntFunComplement (arg_);
}


IntFun& square (const IntFun& arg_) {
  return *new AnyIntFun1<square>("square", arg_);
}

IntFun& abs (const IntFun& arg_) {
  return *new AnyIntFun1<std::abs>("abs", arg_);
}

IntFunComp& operator< (const IntFun& lhs_, const IntFun& rhs_) {
  return *new IntFunLess (lhs_, rhs_);
}

IntFunComp& operator> (const IntFun& lhs_, const IntFun& rhs_) {
  return *new IntFunGreater (lhs_, rhs_);
}

IntFunComp& operator<= (const IntFun& lhs_, const IntFun& rhs_) {
  return *new IntFunLessEqual (lhs_, rhs_);
}

IntFunComp& operator>= (const IntFun& lhs_, const IntFun& rhs_) {
  return *new IntFunGreaterEqual (lhs_, rhs_);
}

IntFunComp& operator== (const IntFun& lhs_, const IntFun& rhs_) {
  return *new IntFunEqual (lhs_, rhs_);
}

IntFunComp& operator!= (const IntFun& lhs_, const IntFun& rhs_) {
  return *new IntFunNotEqual (rhs_, lhs_);
}

// External functions that implement comparison operators between
// a int and a IntFun object

IntFunComp& operator< (int lhs_, const IntFun& rhs_) {
  return *new IntIntFunLess (lhs_, rhs_);
}

IntFunComp& operator<= (int lhs_, const IntFun& rhs_) {
  return *new IntIntFunLessEqual (lhs_, rhs_);
}

IntFunComp& operator> (int lhs_, const IntFun& rhs_) {
  return *new IntIntFunGreater (lhs_, rhs_);
}

IntFunComp& operator>= (int lhs_, const IntFun& rhs_) {
  return *new IntIntFunGreaterEqual (lhs_, rhs_);
}

IntFunComp& operator== (int lhs_, const IntFun& rhs_) {
  return *new IntIntFunEqual (lhs_, rhs_);
}

IntFunComp& operator!= (int lhs_, const IntFun& rhs_) {
  return *new IntIntFunNotEqual (lhs_, rhs_);
}

IntFunComp& operator< (const IntFun& lhs_, int rhs_) {
  return *new IntFunIntLess (lhs_, rhs_);
}

IntFunComp& operator<= (const IntFun& lhs_, int rhs_) {
  return *new IntFunIntLessEqual (lhs_, rhs_);
}

IntFunComp& operator> (const IntFun& lhs_, int rhs_) {
  return *new IntFunIntGreater (lhs_, rhs_);
}

IntFunComp& operator>= (const IntFun& lhs_, int rhs_) {
  return *new IntFunIntGreaterEqual (lhs_, rhs_);
}

IntFunComp& operator== (const IntFun& lhs_, int rhs_) {
  return *new IntFunIntEqual (lhs_, rhs_);
}

IntFunComp& operator!= (const IntFun& lhs_, int rhs_) {
  return *new IntFunIntNotEqual (lhs_, 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)

IntFunComp& operator< (const IntFunComp& lhs_, const IntFun& rhs_) {
  return *new IntChainCompLess (lhs_, rhs_);
}

IntFunComp& operator<= (const IntFunComp& lhs_, const IntFun& rhs_) {
  return *new IntChainCompLessEqual (lhs_, rhs_);
}

IntFunComp& operator> (const IntFunComp& lhs_, const IntFun& rhs_) {
  return *new IntChainCompGreater (lhs_, rhs_);
}

IntFunComp& operator>= (const IntFunComp& lhs_, const IntFun& rhs_) {
  return *new IntChainCompGreaterEqual (lhs_, rhs_);
}

IntFunComp& operator== (const IntFunComp& lhs_, const IntFun& rhs_) {
  return *new IntChainCompEqual (lhs_, rhs_);
}

IntFunComp& operator!= (const IntFunComp& lhs_, const IntFun& rhs_) {
  return *new IntChainCompNotEqual (lhs_, rhs_);
}


IntFunComp& operator< (const IntFunComp& lhs_, int rhs_) {
  return *new IntChainCompIntLess (lhs_, rhs_);
}

IntFunComp& operator<= (const IntFunComp& lhs_, int rhs_) {
  return *new IntChainCompIntLessEqual (lhs_, rhs_);
}

IntFunComp& operator> (const IntFunComp& lhs_, int rhs_) {
  return *new IntChainCompIntGreater (lhs_, rhs_);
}

IntFunComp& operator>= (const IntFunComp& lhs_, int rhs_) {
  return *new IntChainCompIntGreaterEqual (lhs_, rhs_);
}

IntFunComp& operator== (const IntFunComp& lhs_, int rhs_) {
  return *new IntChainCompIntEqual (lhs_, rhs_);
}

IntFunComp& operator!= (const IntFunComp& lhs_, int rhs_) {
  return *new IntChainCompIntNotEqual (lhs_, rhs_);
}

IntFun& max (const IntFunPoRConst&         fun,    
              const BaseCutPoRConst&       cut,    
              const FillIteratorPoR&       intiter,
              const FillIteratorPoRConst&  extiter 
             ) {
  return *new MaxIntFun (fun, cut, intiter, extiter);
}

IntFun& min (const IntFunPoRConst&        fun,     
             const BaseCutPoRConst&       cut,     
             const FillIteratorPoR&       intiter, 
             const FillIteratorPoRConst&  extiter  
            ) {
  return *new MinIntFun (fun, cut, intiter, extiter);
}

IntFun& sum (const IntFunPoRConst&        fun,      
             const BaseCutPoRConst&       cut,      
             const FillIteratorPoR&       intiter,  
             const FillIteratorPoRConst&  extiter   
            ) {
  return *new SumIntFun (fun, cut, intiter, extiter);
}

IntFun& count (const BaseCutPoRConst&       cut,     
               const FillIteratorPoR&       intiter, 
               const FillIteratorPoRConst&  extiter  
              ) {
  return *new SumIntFun (0, cut, intiter, extiter);
}

---