D:/Projekt/ECF_trunk/ECF/binary/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 "../Genotype.h"

namespace Binary
{

class Binary: public Genotype {
    friend class BinaryMutSimple;   // za potrebe ad-hoc lokalnog operatora!
protected:
    double minValue_;                 
    double maxValue_;                 
    uint nDecimal_;                   
    uint nDimension_;                 
    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<double> realValue;     
    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));
        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