Re: Inexplicable segfault
In article <pan.2006.09.25.10.03.09.998000@cui.unige.ch>, Jonas Latt
<Jonas.Latt@cui.unige.ch> writes
#include <iostream>
#include <ostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <time.h>
class Individual {
public:
Individual(int size) { build(size); }
int size() const { return genome_.size(); }
int& operator[](int i) { return genome_[i]; }
double fitness() const { return compute_fitness(); }
void randomize() { build(size()); }
bool operator<( const Individual& rhs ) const {
return this->fitness() < rhs.fitness();
}
private:
void build(int size) {
genome_.resize(size);
for (int i=0; i<size; ++i) {
genome_[i] = rand() % 2;
}
}
double compute_fitness() const {
int sum = std::count( genome_.begin(), genome_.end(), 1 );
double n = static_cast<double>( genome_.size() );
return (n - sum) / n;
}
private:
std::vector<int> genome_;
};
<Snipped>
int main( int argc, char** argv ) {
const int indSize = 2000;
const int popSize = 1000;
srand ( time(NULL) );
Individual populator(indSize);
Individual indiv (indSize);
Population pop(populator, popSize);
for (int i=0; i<pop.size(); ++i) {
pop[i] = indiv;
}
pop.sort_indiv();
std::cout << "Best fitness:" << pop[0].fitness() << std::endl;
}
A fascinating example of problems with repeatedly recomputing values.
std::sort requires that the values be ordered, but the repeated
recomputation of 'fitness' is resulting in tiny differences. This is a
problem with using floating point, particularly when there is no
intermediate storage of the results that forces trimming of excess bits.
Replace the operator < overload with:
bool operator<( const Individual& rhs ) const {
double c1= compute_fitness();
double c2= rhs.compute_fitness();
return c1 < c2;
}
And now all will work (I think)
even better change the class definition/implementation to:
class Individual {
public:
Individual(int size) { build(size); fitness_ = compute_fitness(); }
int size() const { return genome_.size(); }
int& operator[](int i) { return genome_[i]; }
double fitness() const { return fitness_; }
void randomize() { build(size()); }
bool operator<( const Individual& rhs ) const {
return fitness_ < rhs.fitness_;
}
private:
<snipped>
std::vector<int> genome_;
double fitness_;
};
so that fitness is computed and stored just once per instance.
Remember that using temporary floating point values is dangerous as they
will not have extra bits trimmed and what those bits are may depend on
what was in those registers when they were last used.
--
Francis Glassborow ACCU
Author of 'You Can Do It!' and "You Can Program in C++"
see http://www.spellen.org/youcandoit
For project ideas and contributions:
http://www.spellen.org/youcandoit/projects
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]