Binary.h

#ifndef BINARY_H_
#define BINARY_H_
 
#include "BinaryCrsOnePoint.h"
#include "BinaryCrsTwoPoint.h"
#include "BinaryMutSimple.h"
#include "BinaryMutMix.h"
#include "BinaryCrsUniform.h"
#include "BinaryCrsHalfUniform.h"
#include "BinaryCrsReducedSurrogate.h"
#include "BinaryCrsSegmented.h"
#include "BinaryCrsShuffle.h"
#include "BinaryCrsNonGeometric.h"
#include "BinaryCrsRandomRespectful.h"
#include "BinaryCrsMasked.h"
 
#include "../RealValueGenotype.h"
 
namespace Binary
{
 
class Binary: public RealValueGenotype {
    friend class BinaryMutSimple;   // za potrebe ad-hoc lokalnog operatora!
protected:
    uint nDecimal_;                   
    uint nBits_;                      
    long potention_;
    bool bRounding_;                  
    typedef std::vector<bool> v_bool;
    v_bool vBool_;                    
 
    double logbase(double a, double base);
    double round(double, int);
 
public:
    std::vector<long int> decValue;    
    std::vector<v_bool> variables;     
 
    Binary ()
    {   name_ = "Binary";   }
 
    uint getNumBits()
    {   return nBits_;  }
 
    bool initialize (StateP state);
 
    void registerParameters(StateP state);
 
    bool update (void);
 
    Binary* copy()
    {
        Binary *newObject = new Binary(*this);
        return newObject;
    }
 
    std::vector<CrossoverOpP> getCrossoverOp()
    {
        std::vector<CrossoverOpP> crx;
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsOnePoint));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsTwoPoint));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsUniform));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsHalfUniform));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsReducedSurrogate));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsSegmented));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsShuffle));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsNonGeometric));
        crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsRandomRespectful));
        // TODO: reimplement
        //crx.push_back(static_cast<CrossoverOpP> (new BinaryCrsMasked));
        return crx;
    }
 
    std::vector<MutationOpP> getMutationOp()
    {   
        std::vector<MutationOpP> mut;
        mut.push_back(static_cast<MutationOpP> (new BinaryMutSimple));
        mut.push_back(static_cast<MutationOpP> (new BinaryMutMix));
        return mut;
    }
 
    void write(XMLNode& xBinary);
 
    void read(XMLNode& xBinary);
};
 
}
typedef boost::shared_ptr<Binary::Binary> BinaryP;
#endif