// This works only for enumerated sets. If someone tries to use this on a // non-enumerated set then we post an error message. No bounds checking on // the value that was passed to us, but we do modulo it so that we'll never // break. Also, this means you can wrap an allele set around an array that // is significantly larger than the allele set that defines its contents. template <class T> T GAAlleleSet<T>::allele(unsigned int i) const { if(core->type == GAAllele::ENUMERATED) return core->a[i % core->sz]; else if(core->type == GAAllele::DISCRETIZED){ GAErr(GA_LOC, "GAAlleleSet", "allele(unsigned int)", gaErrOpUndef); return core->a[0]; } else{ GAErr(GA_LOC, "GAAlleleSet", "allele(unsigned int)", gaErrNoAlleleIndex); return core->a[0]; } }
// When returning an allele from the set, we have to know what type we are. // The allele that we return depends on the type. If we're an enumerated set // then just pick randomly from the list of alleles. If we're a bounded set // then pick randomly from the bounds, and respect the bound types. If we're // a discretized set then we do much as we would for the bounded set, but we // respect the discretization. // Be sure to specialize this member function (see the real genome for an // example of how to do this) template <class T> T GAAlleleSet<T>::allele() const { if(core->type == GAAllele::ENUMERATED) return core->a[GARandomInt(0, core->sz-1)]; else if(core->type == GAAllele::DISCRETIZED){ GAErr(GA_LOC, "GAAlleleSet", "allele(unsigned int)", gaErrOpUndef); return core->a[0]; } else{ GAErr(GA_LOC, "GAAlleleSet", "allele(unsigned int)", gaErrOpUndef); return core->a[0]; } }
template <class T> int GA3DArrayGenome<T>:: resizeBehaviour(GAGenome::Dimension which, unsigned int lower, unsigned int upper) { if(upper < lower){ GAErr(GA_LOC, className(), "resizeBehaviour", gaErrBadResizeBehaviour); return resizeBehaviour(which); } switch(which){ case WIDTH: minX = lower; maxX = upper; if(nx > upper) GA3DArrayGenome<T>::resize(upper,ny,nz); if(nx < lower) GA3DArrayGenome<T>::resize(lower,ny,nz); break; case HEIGHT: minY = lower; maxY = upper; if(ny > upper) GA3DArrayGenome<T>::resize(nx,upper,nz); if(ny < lower) GA3DArrayGenome<T>::resize(nx,lower,nz); break; case DEPTH: minZ = lower; maxZ = upper; if(nz > upper) GA3DArrayGenome<T>::resize(nx,ny,upper); if(nz < lower) GA3DArrayGenome<T>::resize(nx,ny,lower); break; default: break; } return resizeBehaviour(which); }
int GA2DBinaryStringGenome:: resizeBehaviour(Dimension which, unsigned int lower, unsigned int upper) { if(upper < lower){ GAErr(GA_LOC, className(), "resizeBehaviour", gaErrBadResizeBehaviour); return resizeBehaviour(which); } switch(which){ case WIDTH: minX = lower; maxX = upper; if(nx > upper) resize(upper,ny); if(nx < lower) resize(lower,ny); break; case HEIGHT: minY = lower; maxY = upper; if(ny > upper) resize(nx,upper); if(ny < lower) resize(nx,lower); break; default: break; } return resizeBehaviour(which); }
const GAPopulation& GASteadyStateGA::population(const GAPopulation& p) { if(p.size() < 1) { GAErr(GA_LOC, className(), "population", gaErrNoIndividuals); return *pop; } GAGeneticAlgorithm::population(p); delete tmpPop; if(which == USE_PREPL){ double n = pRepl * pop->size(); if(n < 1) n = 1.0; nRepl = (unsigned int)n; params.set(gaNnReplacement, nRepl); } else{ if(nRepl > (unsigned int)(pop->size())) nRepl = pop->size(); if(nRepl < 1) nRepl = 1; } tmpPop = new GAPopulation(pop->individual(0), nRepl); tmpPop->geneticAlgorithm(*this); return *pop; }
// Resize the population. If we shrink, we delete the extra genomes. If // we grow, we clone new ones (and we DO NOT initialize them!!!). When we // trash the genomes, we delete the worst of the population! We do not // free up the space used by the array of pointers, but we do free up the // space used by the genomes. // We do a clone of the genome contents so that we don't have to initialize // the new ones (what if the population has a custom initilizer?). We randomly // pick which ones to clone from the existing individuals. If the population // contains no genomes, then we post an error message (since there are no // individuals from which to clone the new ones). // If the population was evaluated, then we evaluate the new genomes. We // do not sort nor restat the population, and we tag the statted and sorted // flags to reflect the fact that they are no longer valid. // Resizing to a bigger size is the same as a batch 'add' int GAPopulation::size(unsigned int popsize){ if(popsize == n) return n; if(n == 0 && popsize > 0) { GAErr(GA_LOC, "GAPopuluation", "size", gaErrNoIndividuals); return n; } if(popsize > n){ grow(popsize); for(unsigned int i=n; i<popsize; i++) rind[i] = rind[GARandomInt(0,n-1)]->clone(GAGenome::CONTENTS); rsorted = gaFalse; } else{ for(unsigned int i=popsize; i<n; i++) // trash the worst ones (if sorted) delete rind[i]; // may not be sorted!!!! } memcpy(sind, rind, N * sizeof(GAGenome*)); ssorted = scaled = statted = divved = selectready = gaFalse; n = popsize; if(evaluated == gaTrue) evaluate(gaTrue); return n; }
int GA2DBinaryStringGenome::read(STD_ISTREAM & is) { static char c; unsigned int i=0, j=0; while(!is.fail() && !is.eof() && j < ny) { is >> c; if(isdigit(c)){ gene(i, j, ((c == '0') ? 0 : 1)); if(++i >= nx){ // ready for next row i=0; j++; } } } _evaluated = gaFalse; if(is.eof() && ((j < ny) || // didn't get some lines (i < nx && i != 0))){ // stopped early on a row GAErr(GA_LOC, className(), "read", gaErrUnexpectedEOF); is.clear(STD_IOS_BADBIT | is.rdstate()); return 1; } return 0; }
/// Must do a special case for double/float. Any floats that get passed to this /// routine will be cast to doubles, but then we need to force them back to a /// float if FLOAT is the type that is expected. Kind of sucks, eh? /// We could check the parameter type against the type here, but we don't. /// (could do it for all of the 'set' members). Maybe in a later release. int GAParameterList::set(const char* name, double v) { int found = 0; for(unsigned int i = 0; i < n; i++) { if(strcmp(name, p[i]->fullname()) == 0 || strcmp(name, p[i]->shrtname()) == 0) { if(p[i]->type() == GAParameter::FLOAT) { float fval = (float)v; p[i]->value((void*)&fval); } else if(p[i]->type() == GAParameter::DOUBLE) { p[i]->value((void*)&v); } else { GAErr(GA_LOC, "GAParameterList", "set", gaErrBadTypeIndicator); } found = 1; } } return found ? 0 : -1; }
// Remove the specified node from the tree. We don't cruise through the tree // to make certain that the node is in the tree. But we do check to make sure // that the connections were ok before we prune the node. If there is any // problem with the links, we return a NULL. If we get a NULL node, then we // don't do anything. // We don't do anything to the next, prev, etc links of the node that is // being removed (they are left pointing to where they used to point) so be // careful!! // If the removal is on the root node, set the root node to NULL. GANodeBASE * GATreeBASE::remove(GANodeBASE * n) { if(!n) return (GANodeBASE *)0; if(!n->next || !n->prev || n->prev->next != n || n->next->prev != n){ GAErr(GA_LOC, "GATreeBASE", "remove", gaErrBadTreeLinks); return (GANodeBASE*)0; } if(n->next == n || !n->next){ if(n->parent && n->parent->child == n) n->parent->child = (GANodeBASE *)0; } else{ if(n->parent && n->parent->child == n) n->parent->child = n->next; n->prev->next = n->next; n->next->prev = n->prev; } if(n == rt) rt = (GANodeBASE *)0; // uncomment these to modify the node that is getting removed n->prev = n; n->next = n; n->parent = 0; csz = 1; cdpth = 1; return n; }
// Set the bits of the binary string based on the decimal value that is passed // to us. Notice that the number you pass may or may not be set properly. It // depends on the resolution defined in the phenotype. If you didn't define // enough resolution, then there may be no way to represent the number. // We round off to the closest representable value, then return the number // that we actually entered (the rounded value). // *** this is dangerous! we're accessing the superclass' data representation // directly, so if the representation changes to a bit stream, this will break. // If someone tries to set the phenotype beyond the bounds, we post an error // then set the bits to the closer bound. float GABin2DecGenome::phenotype(unsigned int n, float val) { if(n >= ptype->nPhenotypes()){ GAErr(GA_LOC, className(), "phenotype", gaErrBadPhenotypeID); return val; } if(val < ptype->min(n) || val > ptype->max(n)){ GAErr(GA_LOC, className(), "phenotype", gaErrBadPhenotypeValue); val = ((val < ptype->min(n)) ? ptype->min(n) : ptype->max(n)); } encode(val, &(data[ptype->offset(n)]), ptype->length(n), ptype->min(n), ptype->max(n)); return val; }
int GA3DBinaryStringGenome::read(std::istream & is) { static char c; unsigned int i=0, j=0, k=0; do{ is >> c; if(isdigit(c)){ gene(i++, j, k, ((c == '0') ? 0 : 1)); if(i >= nx){ i=0; j++; } if(j >= ny){ j=0; k++; } } } while(!is.fail() && !is.eof() && k < nz); _evaluated = gaFalse; if(is.eof() && ((k < nz) || // didn't get some lines (j < ny && j != 0) || // didn't get some lines (i < nx && i != 0))){ // didn't get some lines GAErr(GA_LOC, className(), "read", gaErrUnexpectedEOF); is.clear(std::ios::badbit | is.rdstate()); return 1; } return 0; }
GABin2DecPhenotypeCore::~GABin2DecPhenotypeCore(){ if(cnt > 0) GAErr(GA_LOC, "GABin2DecPhenotypeCore", "destructor", gaErrRefsRemain); delete [] nbits; delete [] oset; delete [] minval; delete [] maxval; }
const GAGenome & GAStatistics::bestIndividual(unsigned int n) const { if(boa == 0 || (int)n >= boa->size()){ GAErr(GA_LOC, "GAStatistics", "bestIndividual", gaErrBadPopIndex); n = 0; } return boa->best(n); // this will crash if no boa }
// Set the multiplier for this selection type. It should be greater than or // equal to zero. float GASigmaTruncationScaling::multiplier(float fm) { if(fm < 0.0){ GAErr(GA_LOC, className(), "multiplier", gaErrBadSigmaTruncationMult); return c; } return c = fm; }
// The cutoff for triangular sharing must always be greater than 0 float GASharing::sigma(float c) { if(c <= 0.0){ GAErr(GA_LOC, className(), "sigma", gaErrBadSharingCutoff); return _sigma; } return _sigma = c; }
// Set the multiplier for this selection type. The fmultiplier must be greater // than 1.0 or else we'll get a divide by zero error in our scaling operations. float GALinearScaling::multiplier(float fm) { if(fm <= 1.0){ GAErr(GA_LOC, className(), "multiplier", gaErrBadLinearScalingMult); return c; } return c = fm; }
GAAlleleSetCore<T>::~GAAlleleSetCore() { if(cnt > 0) { GAErr(GA_LOC, "GAAlleleSetCore", "destructor", gaErrRefsRemain); } delete [] a; }
// This is the class-specific copy method. It will get called by the super // class since the superclass operator= is set up to call ccopy (and that is // what we define here - a virtual function). We should check to be sure that // both genomes are the same class. void BitStringGenome::copy(const GAGenome & orig) { if(&orig == this) return; if(!sameClass(orig)){ GAErr(GA_LOC, className(), "copy", gaErrObjectTypeMismatch); return; } GAGenome::copy(orig); BitStringGenome &bsg = (BitStringGenome &)orig; BitString::operator=(bsg._substr(0,bsg.length())); }
int GAIncrementalGA::nOffspring(unsigned int value){ if(value != 1 && value != 2){ GAErr(GA_LOC, className(), "numCrossStrategy", gaErrBadCS); noffspr = 1; } else{ noffspr = value; } params.set(gaNnOffspring, value); return noffspr; }
GAIncrementalGA::ReplacementScheme GAIncrementalGA:: replacement(GAIncrementalGA::ReplacementScheme n, GAIncrementalGA::ReplacementFunction f){ switch(n){ case BEST: case WORST: case RANDOM: case PARENT: rs = n; break; case CUSTOM: if(f){ rs = n; rf = f; } else GAErr(GA_LOC, className(), "replacement", gaErrNeedRS); break; default: GAErr(GA_LOC, className(), "replacement", gaErrBadRS); break; } return rs; }
const GAPopulation& GAGeneticAlgorithm::population(const GAPopulation& p) { if(p.size() < 1) { GAErr(GA_LOC, className(), "population", gaErrNoIndividuals); return *pop; } pop->copy(p); pop->geneticAlgorithm(*this); return *pop; }
// Do some basic stupidity checks then initialize the population. We must // also initialize our temporary genomes, but we don't have to evaluate // them. Finally, reset the statistics. void GAIncrementalGA::initialize(unsigned int seed) { GARandomSeed(seed); pop->initialize(); pop->evaluate(gaTrue); stats.reset(*pop); if(!scross) GAErr(GA_LOC, className(), "initialize", gaErrNoSexualMating); }
int GAParameterList::write(const char* filename) const { STD_OFSTREAM outfile(filename, (STD_IOS_OUT | STD_IOS_TRUNC)); // should be done this way, but SGI systems (and others?) don't do it right... // if(! outfile.is_open()){ if(outfile.fail()){ GAErr(GA_LOC, "GAParameterList", "write", gaErrWriteError, filename); return 1; } int status = write(outfile); outfile.close(); return status; }
// You can specify the data that you want to dump out when you call this // routine, or you can just let it use the selection from the object. If you // specify a data set, that will be used rather than the 'which' in the object. int GAStatistics::scores(const char* filename, int w){ STD_OFSTREAM outfile(filename, (STD_IOS_OUT | STD_IOS_TRUNC)); // should be done this way, but SGI systems (and others?) don't do it right... // if(! outfile.is_open()){ if(outfile.fail()){ GAErr(GA_LOC, "GAStatistics", "scores", gaErrWriteError, filename); return 1; } scores(outfile, w); outfile.close(); return 0; }
int GAParameterList::write(const char* filename) const { std::ofstream outfile(filename, (std::ios::out | std::ios::trunc)); // should be done this way, but SGI systems (and others?) don't do it right... // if(! outfile.is_open()){ if(outfile.fail()){ GAErr(GA_LOC, "GAParameterList", "write", gaErrWriteError, filename); return 1; } int status = write(outfile); outfile.close(); return status; }
// We access the data string directly here. This could be dangerous (if the // bitstream ever changes on us it will affect the way this method sees the // data string). // Eventually we may need to cache the decimal values in an array of floats, // but for now we call the converter routine every time each phenotype is // requested. float GABin2DecGenome::phenotype(unsigned int n) const { if(n >= ptype->nPhenotypes()){ GAErr(GA_LOC, className(), "phenotype", gaErrBadPhenotypeID); return(0.0); } float val=0.0; decode(val, &(data[ptype->offset(n)]), ptype->length(n), ptype->min(n), ptype->max(n)); return val; }
// Set the resize behaviour of the genome. A genome can be fixed // length, resizeable with a max and min limit, or resizeable with no limits // (other than an implicit one that we use internally). // A value of 0 means no resize, a value less than zero mean unlimited // resize, and a positive value means resize with that value as the limit. // We return the upper limit of the genome's size. int GA1DBinaryStringGenome:: resizeBehaviour(unsigned int lower, unsigned int upper) { if(upper < lower){ GAErr(GA_LOC, className(), "resizeBehaviour", gaErrBadResizeBehaviour); return resizeBehaviour(); } minX = lower; maxX = upper; if(nx > upper) resize(upper); if(nx < lower) resize(lower); return resizeBehaviour(); }
int GADemeGA::populationSize(int i, unsigned int value){ if(value < 1){ GAErr(GA_LOC, className(), "populationSize", gaErrBadPopSize); value = 1; } if(i == ALL) for(unsigned int ii=0; ii<npop; ii++) deme[ii]->size(value); else deme[i]->size(value); return value; }
// This is an implementation of the most basic form of power scaling, where the // fitness is a function of the objective score raised to some power. Negative // objective scores are not allowed. If we get one, we post an error and set // all of the fitness scores to zero. void GAPowerLawScaling::evaluate(const GAPopulation & p) { for(int i=0; i<p.size(); i++){ double f = p.individual(i).score(); if(f < 0.0){ GAErr(GA_LOC, className(), "evaluate", gaErrPowerNegFitness); for(int ii=0; ii<p.size(); ii++) p.individual(ii).fitness(0.0); return; } f = pow(f,(double)k); p.individual(i).fitness((float)f); // might lose information here! } }
// Set the resize behaviour of the genome. A genome can be fixed // length, resizeable with a max and min limit, or resizeable with no limits // (other than an implicit one that we use internally). // A value of 0 means no resize, a value less than zero mean unlimited // resize, and a positive value means resize with that value as the limit. template <class T> int GA1DArrayGenome<T>:: resizeBehaviour(unsigned int lower, unsigned int upper) { if(upper < lower) { GAErr(GA_LOC, className(), "resizeBehaviour", gaErrBadResizeBehaviour); return resizeBehaviour(); } minX = lower; maxX = upper; if(nx > upper) GA1DArrayGenome<T>::resize(upper); if(nx < lower) GA1DArrayGenome<T>::resize(lower); return resizeBehaviour(); }