individual.cpp

遗传算法程序最新版

/***************************************************************
/* Single & Multi-Objective Real-Coded Genetic Algorithms Code */
/* Author: Kumara Sastry                                       */
/* Illinois Genetic Algorithms Laboratory (IlliGAL)            */
/* Deparment of General Engineering                            */
/* University of Illinois at Urbana-Champaign                  */
/* 104 S. Mathews Ave, Urbana, IL 61801                        */
/***************************************************************/

#include "individual.hpp"
// Started Modification 02/14/2001:21:19:59 - PVP

extern GlobalSetup *globalSetup;
extern void globalEvaluate(double *values, double *objFunction, 
			   double *violation, double *penalty, 
			   int *noOfViolations);

Individual::Individual(void) {

  // This is the default constructor. Here, the properties
  // of the Individual will be set appropriately. It should be
  // noted that the default constructor of a parent class is
  // automatically called when a child class object is constructed.
  // The reason why I am saying this is that we have double *fitness
  // etc and we would have to initialize it in the NsgaIndividual
  // class constructor to an array of fitness, etc. Here, we should
  // take care that we do not allocate it again. Therefore, we have
  // to check what type of GA this is, before we allocate memory.

  // The things to be initialized:
  //    1.   Chromosome chrom; - just call default constructor - will be initialized to a random chromosome based on bounds
  //    2.   double *fitness; - initialize to new doubl if GA is SGA
  //    3.   double *objFunction; -          -do-
  //    4.   double penalty;  - initialize to ZERO.
  //    5.   double *violation, totalViolation; - Set violation to NULL if unconstrained.
  //    6.   int *freezeMask; - initialize to int[globalSetup->noOfVariables] and set everything to 0.

  // Do the evaluation after everything is done.

  // Chromosomes default constructor is called automatically.

  if (!(globalSetup->finalNoOfConstraints))
    violation = NULL;
  else
    violation = new double[globalSetup->finalNoOfConstraints];
  noOfViolations = 0;
  penalty = 0.0;
  if (globalSetup->gaType==SGA) {
    fitness = new double(0.00);
    objFunction = new double(0.00);
    if(!(globalSetup->loadPopulation)) evaluateFitness(); // If Nsga, it's constructor will call it's evaluate.
  }
}

Individual::Individual(const Individual &sourceInd ) {

  // Call operator= of chromosomes and just copy all other values after appropriate allocations
  int ii;
  chrom = sourceInd.chrom;
  if (globalSetup->gaType==SGA) {
    fitness = new double(*(sourceInd.fitness));
    objFunction = new double(*(sourceInd.objFunction));
  }
  if (globalSetup->finalNoOfConstraints) {
    noOfViolations = sourceInd.noOfViolations;
    violation = new double[globalSetup->finalNoOfConstraints];
    for(ii = 0; ii < globalSetup->finalNoOfConstraints; ii++) 
      violation[ii] = sourceInd.violation[ii];
    penalty = sourceInd.penalty;
  }
  else
    violation = NULL;

}

Individual::Individual(const Individual *sourceInd )
{
  int ii;
  chrom = sourceInd->chrom;
  if (globalSetup->gaType==SGA) {
    fitness = new double(*(sourceInd->fitness));
    objFunction = new double(*(sourceInd->objFunction));
  }
  if (globalSetup->finalNoOfConstraints) {
    noOfViolations = sourceInd->noOfViolations;
    violation = new double[globalSetup->finalNoOfConstraints];
    for(ii = 0; ii < globalSetup->finalNoOfConstraints; ii++) 
      violation[ii] = sourceInd->violation[ii];
    penalty = sourceInd->penalty;
  }
  else
    violation = NULL;

}

Individual & Individual::operator= (const Individual &sourceInd) {
  // Difference between copy constructor and this is 
  // that this guy has already been allocated some memory
  // for the dynamically allocated stuff and so it has to be freed
  // and copied or copied without reallocation.

  int ii;
  chrom = sourceInd.chrom;
  if (globalSetup->gaType==SGA) {
    *fitness = (*(sourceInd.fitness));
    *objFunction = (*(sourceInd.objFunction));
  }
  if(globalSetup->finalNoOfConstraints) {
    noOfViolations = sourceInd.noOfViolations;
    for(ii = 0; ii < globalSetup->finalNoOfConstraints; ii++) 
      violation[ii] = sourceInd.violation[ii];
    penalty = sourceInd.penalty;
  }
  return *this;
}

void Individual::loadIndividual(double *varValues, double *objValues, double *constViolValues, double penaltyValue) {
  int ii;
  for(ii = 0; ii < globalSetup->noOfDecisionVariables; ii++) 
    chrom[ii] = varValues[ii];
  for(ii = 0; ii < globalSetup->finalNoOfObjectives; ii++) 
    objFunction[ii] = objValues[ii];
  if(globalSetup->finalNoOfConstraints) {
    noOfViolations = 0;
    for(ii = 0; ii < globalSetup->finalNoOfConstraints; ii++) 
      violation[ii] = constViolValues[ii];
    if(violation[ii] >= 1.0e-5) {
      noOfViolations++;
    }
    penalty = penaltyValue;
  }
}

void Individual::evaluateFitness(void) {
  double *values;
  int ii;
  
  values = new double[globalSetup->noOfDecisionVariables];
		
  for (ii = 0; ii < globalSetup->noOfDecisionVariables; ii++)
    values[ii] = chrom[ii];
  globalEvaluate(values, objFunction, violation,
		 &penalty, &noOfViolations);
  delete [] values;
}

void Individual::mutate(int *freezeMask) 
{
  switch(globalSetup->mutationType) {
  case Selective:
    chrom.mutateMinMax(freezeMask);
    break;
  case Genewise:
    chrom.mutateNormal(freezeMask);
    break;
  case Polynomial:
    chrom.mutatePolynomial(freezeMask);
    break;
  default: exit(0);
  }
}


Individual::~Individual(void) {
  if (globalSetup->gaType==SGA) {
    delete fitness;
    delete objFunction;
  }
  if (globalSetup->finalNoOfConstraints) 
    delete [] violation;
}

// Some stuff for NsgaIndividual

NsgaIndividual::NsgaIndividual(void) {
  // At this point, chrom is ready, violation is ready and freezeMask is there even though it is 
  // not necessary. We have to initialize fitness and objFunction and do the evaluation

  fitness = new double[globalSetup->finalNoOfObjectives];
  objFunction = new double[globalSetup->finalNoOfObjectives];
  rank = 0;
  crowdingDistance=0.0;
  if(!(globalSetup->loadPopulation)) evaluateFitness();
}

NsgaIndividual::NsgaIndividual(const Individual &sourceInd):Individual(sourceInd) {
  int ii;
  NsgaIndividual *newSource = (NsgaIndividual *) &sourceInd;
  fitness = new double[globalSetup->finalNoOfObjectives];
  objFunction = new double[globalSetup->finalNoOfObjectives];
  
  for(ii = 0; ii < globalSetup->finalNoOfObjectives; ii++) {
    fitness[ii] = newSource->fitness[ii];
    objFunction[ii] = newSource->objFunction[ii];
  }
  rank = newSource->rank;
  crowdingDistance = newSource->crowdingDistance;
}

NsgaIndividual::NsgaIndividual(const Individual *sourceInd):Individual(*sourceInd){
  int ii;
  
  NsgaIndividual *newSource = (NsgaIndividual *) sourceInd;
  fitness = new double[globalSetup->finalNoOfObjectives];
  objFunction = new double[globalSetup->finalNoOfObjectives];
  for (ii = 0; ii < globalSetup->finalNoOfObjectives; ii++) {
    fitness[ii] = newSource->fitness[ii];
    objFunction[ii] = newSource->objFunction[ii];
  }
  rank = newSource->rank;
  crowdingDistance = newSource->crowdingDistance;
}
NsgaIndividual::NsgaIndividual(const NsgaIndividual &sourceInd):Individual(sourceInd) {

  int ii;
  fitness = new double[globalSetup->finalNoOfObjectives];
  objFunction = new double[globalSetup->finalNoOfObjectives];
  for (ii = 0; ii < globalSetup->finalNoOfObjectives; ii++) {
    fitness[ii] = sourceInd.fitness[ii];
    objFunction[ii] = sourceInd.objFunction[ii];
  }
  rank = sourceInd.rank;
  crowdingDistance = sourceInd.crowdingDistance;