STAT_Combinatorial.h

Go to the documentation of this file.

#ifndef STAT_Combinatorial_H
#define STAT_Combinatorial_H

#include "CORE_Object.h"
#include "CORE_ListPointers.h"
#include <vector>
#include <time.h>
template<class T>
class STAT_Combinatorial : public CORE_Object {
  
    // ATTRIBUTES
    
private:
    
  
    static const tFlag COMBINATION;
    static const tFlag PERMUTATION;
    static const tFlag CIRCULAR_PERMUTATION;
    tFlag mFunction;
    
    unsigned int mCount;
    size_t mSize;
    T *mVector;
 
  
    
    T *mFirstIndex;
    T *mLastIndex;
    T *mEnd;
    size_t mDistanceIndex;
    
    T *mCombinatorialList;
    tBoolean mIsDisplay;
  

    
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    STAT_Combinatorial(void);
    
  
  
    // DESTRUCTORS 
  
  
    virtual ~STAT_Combinatorial(void);
  
public:
 // -----------------------
    // shared pointer operator
    // ------------------------
    
    void getSharedPointer(boost::shared_ptr<STAT_Combinatorial<T> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);
        p=boost::dynamic_pointer_cast<STAT_Combinatorial<T> >(r);       
    };
    void getSharedPointer( boost::shared_ptr<const STAT_Combinatorial<T> >& p) const{           
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const STAT_Combinatorial<T> >(r);                         
    }; 
private:
    inline boost::shared_ptr<STAT_Combinatorial<T> > getThis() {
        boost::shared_ptr<STAT_Combinatorial<T> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const STAT_Combinatorial<T> > getThis() const {                                   
        boost::shared_ptr<const STAT_Combinatorial<T> > p;
        getSharedPointer(p);
        return p;       
    };

    // ----------------
    // New constructors
    // ----------------
public:
    static inline boost::shared_ptr<STAT_Combinatorial<T> > New() {
        boost::shared_ptr<STAT_Combinatorial<T> > p(new STAT_Combinatorial<T>(),
                                                   CORE_Object::Delete());
        p->setThis(p);
        return p;
    };  
    static inline boost::shared_ptr<STAT_Combinatorial<T> > New(const int& n) {
        boost::shared_ptr<STAT_Combinatorial<T> > p(new STAT_Combinatorial<T>(),
                                                   CORE_Object::Delete());
        p->setSize(n);
        p->setThis(p);
        return p;
    };

    
    // -----------------------
    // operator accessors
    // -----------------------
    
    inline const T& operator[](const int& i) const {
        ASSERT_IN(i<mSize);
        return mVector[i];
    };
    
    inline T& operator[](const int& i) {
        ASSERT_IN(i<mSize);
        return mVector[i];
    };
    

    inline void resize(const size_t& n) {
        T* vector=new T[n+1];
        size_t dim=(n<mSize)?n:mSize;
        for (size_t i=0;i<dim;i++) vector[i]=mVector[i];
        for (size_t i=dim;i<=n;i++) vector[i]=i;
        if (mVector!=null) delete[] mVector;
        mVector=vector;
        mSize=n;
        mEnd=&mVector[mSize];
        
    }
    inline void setSize(const size_t& n) {
        if (n<mSize) mSize=n;
        else resize(n);
    }

    inline void initVector() {
        int i=0;
        for (T *iter=&mVector[0];iter!=mEnd;iter++) *iter=i++;
    }
    inline static void initSeed(const long int& v) {
        srand(v);
    }

    inline static void initSeed() {
        initSeed(time(NULL));
    }



    inline void setIsDisplay(const tBoolean& b) {
        mIsDisplay=b;
    }
    
    template<class UINT>
    static UINT getCombinationsNumber(const UINT& p,const UINT& n);

    template<class UINT>
    inline UINT getCombinationsNumber(const UINT& p) {
        ASSERT_IN(p<=(UINT)mSize);
        return getCombinationsNumber(p,(UINT)mSize);
    };

    template<class UINT>
    static UINT getPermutationsNumber(const UINT& p,const UINT& n);
    
    template<class UINT>
    inline UINT getPermutationsNumber(const UINT& p) {
        ASSERT_IN(p<=(UINT)mSize);
        return getPermutationsNumber(p,(UINT)mSize);
    };
    template<class UINT>
    static UINT getCircularPermutationsNumber(const UINT& p,const UINT& n);
    template<class UINT>
    inline UINT getCircularPermutationsNumber(const UINT& p) {
        ASSERT_IN(p<=(UINT)mSize);
        return getCircularPermutationsNumber(p,(UINT)mSize);
    };
    
    inline static void computeRandomPermutation(T* vect,const int& s) {
        for(int i=0; i<s; i++) {
            swap(vect[rand()%(s-i)+i],vect[i]);
        }
    }

    inline static void computeRandomPermutation(T* vect,const int& s,const int& q) {
        int n=s/q;
        int jp,jj=0;
        for(int j=0; j<n; j++) {
            jp=(rand()%(n-j)+j)*q;
            for (int i=0;i<q;i++) {
                swap(vect[jp++],vect[jj++]);
            }
        }
    }
    
    int computeCombinations(const int& p);
    
    inline int computeCombinations(T* combinations,const int& p) {
        mCombinatorialList=combinations;
        return computeCombinations(p);
    }
    
    int computePermutations(const int& p);
    
    inline int computePermutations(T* cpermutations,const int& p) {
        mCombinatorialList=cpermutations;
        return computePermutations(p);
    }
    
    int computeCircularPermutations(const int& p);
    
    inline int computeCircularPermutations(T* combinations,const int& p) {
         mCombinatorialList=combinations;
         return computeCircularPermutations(p);
    };
    
    
    tBoolean oneCombinationDone() {
        
     
        if (mCombinatorialList!=null) {
            T *list=&mCombinatorialList[mCount*(mLastIndex-mFirstIndex)];
            int i=0;
            for (T* iter=mFirstIndex;iter !=mLastIndex;iter++) list[i++]=*iter;
           
        }
        mCount++;
        if (mIsDisplay) {
            display();
        }
        return false;
    };
    
    tBoolean onePermutationDone() {
        return oneCombinationDone();
    }

    void display();
    
    
    
    
private:
    
    tBoolean oneComputationDone();
  
    template<class UINT>
    static UINT greatestCommonDivisor(const UINT& p,
                                      const UINT& n);
    
    
    
    
    void rotate_discontinuous(T* first1,  T* last1,const int&  d1,
                              T* first2,  T* last2,const int&  d2);
                             
    

    bool combine_discontinuous(T* first1, T* last1,const int&  d1,
                               T* first2, T* last2,const int&  d2,
                               const int& d=0);
    tBoolean permute(T* first1, T* last1,const int& d1);
    
    tBoolean permute_(T* first1,T* last1,const int& d1);
        
        
};

#include "STAT_Combinatorial.hpp"



typedef STAT_Combinatorial<int> STAT_IntCombinatorial;
TYPEDEF_SPTR(STAT_IntCombinatorial);
TYPEDEF_SVPTR(STAT_IntCombinatorial);

#endif