406 lines
11 KiB
C++
406 lines
11 KiB
C++
//-----------------------------------------------------------------------------
|
|
// eoBin.h
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef eoBin_h
|
|
#define eoBin_h
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include <iostream> // ostream, istream
|
|
#include <bvector.h> // bit_vector
|
|
#include <string> // string
|
|
#include <EO.h> // EO
|
|
#include <eoOp.h> // eoMonOp
|
|
#include <eoUniform.h> // eoUniform
|
|
#include <eoRnd.h> // eoRnd
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/// eoBin: implementation of binary chromosome.
|
|
/// based on STL's bit_vector (vector<bool>)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class F> class eoBin: public EO<F>, public bit_vector
|
|
{
|
|
public:
|
|
typedef bool Type;
|
|
|
|
/// (Default) Constructor.
|
|
/// @param size Size of the binary string.
|
|
eoBin(const unsigned& size = 0, const bool& value = false):
|
|
bit_vector(size, value) {}
|
|
|
|
/// (Default) Constructor.
|
|
/// @param size Size of the binary string.
|
|
eoBin(const unsigned& size, const eoRnd<Type>& rnd): bit_vector(size)
|
|
{
|
|
generate(begin(), end(), rnd);
|
|
}
|
|
|
|
/// Constructor from istream.
|
|
/// @param is The istream to read from.
|
|
eoBin(istrstream& is)
|
|
{
|
|
readFrom(is);
|
|
}
|
|
|
|
/// My class name.
|
|
string className() const
|
|
{
|
|
return "eoBin";
|
|
}
|
|
|
|
/// To print me on a stream.
|
|
/// @param os The ostream.
|
|
void printOn(ostream& os) const
|
|
{
|
|
copy(begin(), end(), ostream_iterator<bool>(os));
|
|
}
|
|
|
|
/// To read me from a stream.
|
|
/// @param is The istream.
|
|
void readFrom(istream& is)
|
|
{
|
|
string bits;
|
|
is >> bits;
|
|
if (is)
|
|
{
|
|
resize(bits.size());
|
|
transform(bits.begin(), bits.end(), begin(),
|
|
bind2nd(equal_to<char>(), '1'));
|
|
}
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinRandom --> mofify a chromosome in a random way
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinRandom: public eoMonOp<Chrom>
|
|
{
|
|
public:
|
|
/// The class name.
|
|
string className() const { return "eoBinRandom"; }
|
|
|
|
/// Randomizes a cromosome.
|
|
/// @param chrom The cromosome to be randomize.
|
|
void operator()(Chrom& chrom) const
|
|
{
|
|
eoUniform<float> uniform(0.0, 1.0);
|
|
for (unsigned i = 0; i < chrom.size(); i++)
|
|
chrom[i] = (uniform() < 0.5) ? false : true;
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinBitFlip --> chages a bit
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinBitFlip: public eoMonOp<Chrom>
|
|
{
|
|
public:
|
|
/// The class name.
|
|
string className() const { return "eoBinBitFlip"; }
|
|
|
|
/// Change one bit.
|
|
/// @param chrom The cromosome which one bit is going to be changed.
|
|
void operator()(Chrom& chrom) const
|
|
{
|
|
eoUniform<float> uniform(0.0, 1.0);
|
|
for (unsigned i = 0; i < chrom.size(); i++)
|
|
chrom[i] = (uniform() < 0.5) ? false : true;
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinMutation --> classical mutation
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinMutation: public eoMonOp<Chrom>
|
|
{
|
|
public:
|
|
/// (Default) Constructor.
|
|
/// @param _rate Rate of mutation.
|
|
eoBinMutation(const double& _rate = 0.01): rate(_rate), uniform(0.0, 1.0) {}
|
|
|
|
/// The class name.
|
|
string className() const { return "eoBinMutation"; }
|
|
|
|
/// Mutate a chromosome.
|
|
/// @param chrom The chromosome to be mutated.
|
|
void operator()(Chrom& chrom) const
|
|
{
|
|
for (unsigned i = 0; i < chrom.size(); i++)
|
|
if (uniform() < rate)
|
|
chrom[i] = !chrom[i];
|
|
}
|
|
|
|
private:
|
|
double rate;
|
|
mutable eoUniform<float> uniform;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinInversion --> inverts the bits of the chromosome between an interval
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinInversion: public eoMonOp<Chrom>
|
|
{
|
|
public:
|
|
/// The class name.
|
|
string className() const { return "eoBinInversion"; }
|
|
|
|
/// Inverts a range of bits in a binary chromosome.
|
|
/// @param chrom The chromosome whos bits are going to be inverted (a range).
|
|
void operator()(Chrom& chrom) const
|
|
{
|
|
eoUniform<unsigned> uniform(0, chrom.size() + 1);
|
|
|
|
unsigned u1 = uniform(), u2;
|
|
do u2 = uniform(); while (u1 == u2);
|
|
unsigned r1 = min(u1, u2), r2 = max(u1, u2);
|
|
|
|
reverse(chrom.begin() + r1, chrom.begin() + r2);
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinNext --> next binary value
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinNext: public eoMonOp<Chrom>
|
|
{
|
|
public:
|
|
/// The class name.
|
|
string className() const { return "eoBinNext"; }
|
|
|
|
/// Change the bit string x to be x+1.
|
|
/// @param chrom The chromosome to be added one.
|
|
void operator()(Chrom& chrom) const
|
|
{
|
|
for (int i = chrom.size() - 1; i >= 0; i--)
|
|
if (chrom[i])
|
|
{
|
|
chrom[i] = 0;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
chrom[i] = 1;
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinPrev --> previos binary value
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinPrev: public eoMonOp<Chrom>
|
|
{
|
|
public:
|
|
/// The class name.
|
|
string className() const { return "eoBinPrev"; }
|
|
|
|
/// Change the bit string x to be x-1.
|
|
/// @param chrom The chromosome to be substracted one.
|
|
void operator()(Chrom& chrom) const
|
|
{
|
|
for (int i = chrom.size() - 1; i >= 0; i--)
|
|
if (chrom[i])
|
|
{
|
|
chrom[i] = 0;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
chrom[i] = 1;
|
|
continue;
|
|
}
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinCrossover --> classic crossover
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinCrossover: public eoBinOp<Chrom>
|
|
{
|
|
public:
|
|
/// The class name.
|
|
string className() const { return "eoBinCrossover"; }
|
|
|
|
/// 2-point crossover for binary chromosomes.
|
|
/// @param chrom1 The first chromosome.
|
|
/// @param chrom2 The first chromosome.
|
|
void operator()(Chrom& chrom1, Chrom& chrom2) const
|
|
{
|
|
eoUniform<unsigned> uniform(1, min(chrom1.size(), chrom2.size()));
|
|
swap_ranges(chrom1.begin(), chrom1.begin() + uniform(), chrom2.begin());
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinNxOver --> n-point crossover
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinNxOver: public eoBinOp<Chrom>
|
|
{
|
|
public:
|
|
/// (Defualt) Constructor.
|
|
eoBinNxOver(const unsigned& _num_points = 2): num_points(_num_points)
|
|
{
|
|
if (num_points < 1)
|
|
{
|
|
cerr << "NxOver --> invalid number of points " << num_points << endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
/// The class name.
|
|
string className() const { return "eoBinNxOver"; }
|
|
|
|
/// n-point crossover for binary chromosomes.
|
|
/// @param chrom1 The first chromosome.
|
|
/// @param chrom2 The first chromosome.
|
|
void operator()(Chrom& chrom1, Chrom& chrom2) const
|
|
{
|
|
unsigned max_size = min(chrom1.size(), chrom2.size());
|
|
unsigned max_points = min(max_size - 1, num_points);
|
|
|
|
vector<bool> points(max_size, false);
|
|
eoUniform<unsigned> uniform(1, max_size);
|
|
|
|
// select ranges of bits to swap
|
|
do {
|
|
unsigned bit = uniform();
|
|
if (points[bit])
|
|
continue;
|
|
else
|
|
{
|
|
points[bit] = true;
|
|
max_points--;
|
|
}
|
|
} while (max_points);
|
|
|
|
|
|
// swap bits between chromosomes
|
|
bool change = false;
|
|
for (unsigned bit = 1; bit < points.size(); bit++)
|
|
{
|
|
if (points[bit])
|
|
change = !change;
|
|
|
|
if (change)
|
|
swap(chrom1[bit], chrom2[bit]);
|
|
}
|
|
}
|
|
|
|
private:
|
|
unsigned num_points;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinGxOver --> gene crossover
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinGxOver: public eoBinOp<Chrom>
|
|
{
|
|
public:
|
|
/// Constructor.
|
|
eoBinGxOver(const unsigned _gene_size, const unsigned _num_points = 2):
|
|
gene_size(_gene_size), num_points(_num_points)
|
|
{
|
|
if (gene_size < 1)
|
|
{
|
|
cerr << "GxOver --> invalid gene size " << gene_size << endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (num_points < 1)
|
|
{
|
|
cerr << "GxOver --> invalid number of points " << num_points << endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
/// The class name
|
|
string className() const { return "eoBinGxOver"; }
|
|
|
|
/// Gene crossover for binary chromosomes.
|
|
/// @param chrom1 The first chromosome.
|
|
/// @param chrom2 The first chromosome.
|
|
void operator()(Chrom& chrom1, Chrom& chrom2) const
|
|
{
|
|
unsigned max_genes = min(chrom1.size(), chrom2.size()) / gene_size;
|
|
unsigned cut_genes = min(max_genes, num_points);
|
|
|
|
vector<bool> points(max_genes, false);
|
|
eoUniform<unsigned> uniform(0, max_genes);
|
|
|
|
// selects genes to swap
|
|
do {
|
|
unsigned bit = uniform();
|
|
if (points[bit])
|
|
continue;
|
|
else
|
|
{
|
|
points[bit] = true;
|
|
cut_genes--;
|
|
}
|
|
} while (cut_genes);
|
|
|
|
// swaps genes
|
|
for (unsigned i = 0; i < points.size(); i++)
|
|
if (points[i])
|
|
swap_ranges(chrom1.begin() + i * gene_size,
|
|
chrom1.begin() + i * gene_size + gene_size,
|
|
chrom2.begin() + i * gene_size);
|
|
}
|
|
|
|
private:
|
|
unsigned gene_size;
|
|
unsigned num_points;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eoBinUxOver --> uniform crossover
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<class Chrom> class eoBinUxOver: public eoBinOp<Chrom>
|
|
{
|
|
public:
|
|
/// (Default) Constructor.
|
|
eoBinUxOver(const float _rate = 0.5): rate(_rate)
|
|
{
|
|
if (rate < 0 || rate > 1)
|
|
{
|
|
cerr << "UxOver --> invalid rate " << rate << endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
/// The class name.
|
|
string className() const { return "eoBinUxOver"; }
|
|
|
|
/// Uniform crossover for binary chromosomes.
|
|
/// @param chrom1 The first chromosome.
|
|
/// @param chrom2 The first chromosome.
|
|
void operator()(Chrom& chrom1, Chrom& chrom2) const
|
|
{
|
|
unsigned min_size = min(chrom1.size(), chrom2.size());
|
|
eoUniform<float> uniform(0, 1);
|
|
|
|
for (unsigned bit = 0; bit < min_size; bit++)
|
|
if (uniform() < rate)
|
|
swap(chrom1[bit], chrom2[bit]);
|
|
}
|
|
|
|
public:
|
|
float rate;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
#endif eoBin_h
|