Chromosome.h

Go to the documentation of this file.

/*
 * GALib v2.0- A simple C++ library for Genetic Algorithms
 * Arthur van Dam <dam@math.uu.nl>
 * $Id: Chromosome.h 441 2007-11-15 16:55:50Z adam $
 */
#ifndef __GAL_CHROMOSOME_H
#define __GAL_CHROMOSOME_H

#include <iostream>
#include <string>
#include <list>
#include <time.h>
#include <stdlib.h>
#include "Util.h"

namespace gal {

    template <class T> class Chromosome {
    private:
        int _length;

    protected:
        std::list<char> _bits; 
    private:
        bool _isElite;
        static char _getRandomBit()
        {
            return (char)(random() > RANDOM_MAX/2);
        }

    /* 
     * Constructors
     */
    public:
        Chromosome() : _isElite(false) {}

        Chromosome(int length) : _isElite(false)
        {
            _length = length;
            for (int i = 0; i < length; ++i) {
                _bits.push_back(_getRandomBit());
            }
        }

    /* 
     * Accessing variables
     */
    public:
        int length()
        {
            return _length;
        }

        bool isElite()
        {
            return _isElite;
        }

        void setElite(bool isElite = true)
        {
            _isElite = isElite;
        }

        void setLength(int length)
        {
            _length=length;
        }

        virtual void setBits(char *c)
        {
            std::list<char>::iterator it;
            int i;
            
            i = 0;
            for (it = _bits.begin(); it != _bits.end(); it++) {
                *it = c[i]-'0';
                i++;
            }
        }

    /*
     * Representation
     */
    public:
        virtual std::list<char> const getInterpretedBitstring()
        {
            return _bits;
        }

        virtual T const getValue() {}

        virtual std::string const getValueText() {}

        virtual std::string const getBitstringText()
        {
            return bitstos(_bits);
        }

        virtual std::string const getInterpretedBitstringText()
        {
            return bitstos(getInterpretedBitstring());
        }


    /* 
     * Genetic manipulation
     */
    public:
        virtual void mutate(double prob)
        {

            /*** Perform mutation on the bitstring of this chromosome ***/
        }

        virtual void crossover(int pos, Chromosome<T>* g)
        {

            /*** The idea of this crossover implementation is as follows:
                 this current Chromosome object is asked to `crossover'
                 himself with another Chromosome g.
                 It needs to cut its own bitstring and that of g into two
                 pieces, and exchange the tail parts of the two bitstrings.
                 Since g is a pointer to the other Chromosome, you're able
                 to modify the bitstring contents of that Chromosome.

                 You could create a loop over both bitstrings, and copy
                 the bits to the correct new bitstring.
                 A faster, but more technical approach uses the splice
                 function of the standard C++ vector class. See the library
                 docs for details.
            ***/

            std::list<char> gbits_tmp; // fill the bits for g in this temp. variable.

            /*** Start a loop to exchange all necessary bits ***/
        }

        virtual void crossover(Chromosome<T>* g)
        {
            int pos;
            pos = random_int(_length);
            crossover(pos, g);
        }

    };
}
#endif /* __GAL_CHROMOSOME_H */

---