#include <CGA.h>

Inheritance diagram for CGA:

Collaboration diagram for CGA:

Public Member Functions
	CGA ()

	CGA (const CGA &source)

int	cleanup ()

void	copy (unsigned int o, unsigned int d)

void	creation (unsigned int l, unsigned int u)

void	crossover (unsigned int p1, unsigned int p2, unsigned int c1, unsigned int c2)

void	dumpData (unsigned int i)

double	evaluate (unsigned int i)

unsigned int	fittest (void)

double	getBestCandidate ()

unsigned int	getGeneration ()

int	getParamNum ()

int	getPopSize ()

void	initFirstGeneration ()

bool	initialize ()

int	initOptRandom ()

void	mutate (unsigned int i)

CGA &	operator= (const CGA &source)

int	optimise ()

void	replicate (void)

void	select (int method)

void	setBest (unsigned int num)

void	setCandx (int i, double num)

void	setGeneration (int num)

void	setIndv (int i, int j, double num)

void	setMax (double num)

void	setMin (double num)

void	setMutVar (double num)

void	setParamNum (int num)

void	setPopSize (int num)

void	setRealProblem (CRealProblem &aProb)

void	shuffle (void)

void	swap (unsigned int o, unsigned int d)

	~CGA ()

Private Attributes
unsigned int	mBest

double *	mCandX

int	mCrossNum

unsigned int *	mCrp

unsigned int	mGener

double **	mIndV

double	mMax

unsigned int *	mMidX

double	mMin

double	mMutProb

double	mMutVar

int	mParamNum

unsigned int	mPopSize

CRealProblem	mRealProblem

unsigned int *	mWins

Detailed Description

Definition at line 35 of file CGA.h.

Constructor & Destructor Documentation

CGA::CGA ( )

default constructor

File name: CGA.cpp

Programmer: Yongqun He Contact email: yohe@.nosp@m.vt.e.nosp@m.du Purpose: This is the implementation (.cpp file) of the CGA class. It is to implement the genetic algorithm for COPASI optimization Note: Modified from Gepasi and Dingjun Chen's implementation

Definition at line 42 of file CGA.cpp.

References mCandX, mCrp, mGener, mIndV, mMidX, mParamNum, mPopSize, and mWins.

 {
   // this->super();
 
   mPopSize = 0;
   mGener = 0;
   mParamNum = 0;
 
   mCrp = NULL;
   mMidX = NULL;
   mIndV = NULL;
   mCandX = NULL;
   mWins = NULL;
 
   setMethodParameterNumber(3);
   std::vector <COptAlgorithmParameter> & AlgorithmParameters = getMethodParameters();
 
   AlgorithmParameters.resize(3);
   //#1:
   AlgorithmParameters[0].setName("Population Size");
   AlgorithmParameters[0].setValue(100);  // Set a default value
   //#2:
   AlgorithmParameters[1].setName("Generation Number");
   AlgorithmParameters[1].setValue(100.0);  // Set a default value
   //#3:
   AlgorithmParameters[2].setName("Mutation Variance");
   AlgorithmParameters[2].setValue(0.1);  // Set a default value
 
   //initialize();
 }

CGA::CGA ( const CGA & source )

constructor for initializing population Copy constructor

Parameters

source a CGA object for copy

Definition at line 140 of file CGA.cpp.

References mBest, mCandX, mCrossNum, mCrp, mGener, mIndV, mMax, mMidX, mMin, mMutProb, mMutVar, mParamNum, mPopSize, and mWins.

                           : COptAlgorithm(source)
 {
   mGener = source.mGener;
   mPopSize = source.mPopSize;
   mCrossNum = source.mCrossNum;
   mMin = source.mMin;
   mMax = source.mMax;
   mMutVar = source.mMutVar;
   mMutProb = source.mMutProb;
   mBest = source.mBest;
   mParamNum = source.mParamNum;
   mIndV = source.mIndV;
   mCandX = source.mCandX;
   mCrp = source.mCrp;
   mMidX = source.mMidX;
   mWins = source.mWins;
 }

CGA::~CGA ( )

destructor

Definition at line 189 of file CGA.cpp.

References mCandX, mCrp, mIndV, mMidX, and mWins.

 {
   delete mIndV;
   delete mMidX;
   delete mCrp;
   delete mWins;
   delete mCandX;
 }

Member Function Documentation

int CGA::cleanup ( )

clean up

Definition at line 185 of file CGA.cpp.

Referenced by operator=().

186 {return 0;}

void CGA::copy	(	unsigned int	o,
		unsigned int	d
	)

copy individual o to position d

Definition at line 352 of file CGA.cpp.

References mCandX, mIndV, and mParamNum.

Referenced by replicate(), and select().

 {
   int i;
 
   for (i = 0; i < mParamNum; i++)
     mIndV[d][i] = mIndV[o][i];
 
   mCandX[d] = mCandX[o];
 }

void CGA::creation	(	unsigned int	l,
		unsigned int	u
	)

initialise the population

Definition at line 609 of file CGA.cpp.

References evaluate(), FALSE, fittest(), linear(), max, mBest, mCandX, mIndV, mMax, mMin, mParamNum, and TRUE.

Referenced by initFirstGeneration(), and optimise().

 {
   unsigned int i;
   int j;
 
   // double mMin, mMax, la;
   double la;
 
   // BOOL linear;
   bool linear;
 
   for (i = l; i < u; i++)
     {
       for (j = 0; j < mParamNum; j++)
         {
           try
             {
               // determine if linear or log scale
               linear = FALSE;
               la = 1.0;
 
               if (mMin == 0.0)
                 mMin = std::numeric_limits< C_FLOAT64 >::epsilon();
 
               if ((mMax <= 0.0) || (mMin <= 0.0))
                 linear = TRUE;
               else
                 {
                   la = log10(mMax) - log10(mMin);
 
                   if (la < 1.8)
                     linear = TRUE;
                 }
 
               // set it to a random value within the interval
               if (linear)
                 mIndV[i][j] = mMin + dr250() * (mMax - mMin);
               else
                 mIndV[i][j] = mMin * pow(10.0, la * dr250());
             }
           catch (unsigned int e)
             {
               mIndV[i][j] = (mMax - mMin) * 0.5 + mMin;
             }
         }
 
       try
         {
           // calculate its fitness
           mCandX[i] = evaluate(i);
         }
       catch (unsigned int e)
         {
           mCandX[i] = std::numeric_limits< C_FLOAT64 >::max();
         }
     }
 
   // get the index of the fittest
   mBest = fittest();
 }

void CGA::crossover	(	unsigned int	p1,
		unsigned int	p2,
		unsigned int	c1,
		unsigned int	c2
	)

process crossover

Definition at line 430 of file CGA.cpp.

References mCrossNum, mCrp, mIndV, and mParamNum.

Referenced by replicate().

 {
   int i, j, s, e;
   unsigned int pp1, pp2, tmp, l;
 
   try
     {
       if (mParamNum > 1)
         {
           // get a random number of crossover points, always less than half the number of genes
           mCrossNum = r250n((unsigned int) mParamNum / 2);
         }
       else
         mCrossNum = 0;
 
       // if less than 0 just copy parent to child
       if (mCrossNum == 0)
         {
           for (j = 0; j < mParamNum; j++)
             {
               mIndV[c1][j] = mIndV[p1][j];
               mIndV[c2][j] = mIndV[p2][j];
             }
 
           return;
         }
 
       // chose first point
       mCrp[0] = 1 + r250n(mParamNum - mCrossNum);
 
       // chose the others
       for (i = 1; i < mCrossNum; i++)
         {
           l = mParamNum - mCrossNum + i - 1 - mCrp[i - 1];
           mCrp[i] = 1 + mCrp[i - 1] + (l == 0 ? 0 : r250n(l));
         }
 
       // copy segments
       pp1 = p2;
 
       pp2 = p1;
 
       for (i = 0; i <= mCrossNum; i++)
         {
           // swap the indexes
           tmp = pp1;
           pp1 = pp2;
           pp2 = tmp;
 
           if (i == 0)
             s = 0;
           else
             s = mCrp[i - 1];
 
           if (i == mCrossNum)
             e = mParamNum;
           else
             e = mCrp[i];
 
           for (j = s; j < e; j++)
             {
               mIndV[c1][j] = mIndV[pp1][j];
               mIndV[c2][j] = mIndV[pp2][j];
             }
         }
     }
   catch (unsigned int e)
     {}}

void CGA::dumpData ( unsigned int i )

dump data to a file

Definition at line 671 of file CGA.cpp.

References mBest, mCandX, mIndV, and mParamNum.

Referenced by optimise().

 {
   //YOHE: use cout instead
   //ofstream finalout("debugopt.dat",ios::app);
 
   //if (!finalout)
   //  {
   //  cout << "debugopt.dat cannot be opened!" << endl;
   // exit(1);
   //}
   //finalout << "#" << i << "\t" << mCandX[mBest] << endl;
   std::cout << "#" << i << "\t" << mCandX[mBest] << std::endl;
 
   for (int j = 0; j < mParamNum; j++)
     {
       //finalout << mIndV[mBest][j] << "\t";
       std::cout << mIndV[mBest][j] << "\t";
     }
 
   //finalout << std::endl;
   // finalout << std::endl;
   //finalout.close();
 }

double CGA::evaluate ( unsigned int i )

evaluate the fitness of one individual

Definition at line 296 of file CGA.cpp.

References CRealProblem::calculate(), mIndV, mParamNum, and mRealProblem.

Referenced by creation(), initFirstGeneration(), and mutate().

 {
   int j;
   double tmp;
 
   for (j = 0; j < mParamNum; j++)
     {
       tmp = mIndV[i][j];
       mRealProblem.setParameter(j, tmp);
     }
 
   //for debugging purpose
   //std::cout << "Debug: mRealProblem.getParameterNum() is:" << mRealProblem.getParameterNum() << std::endl;
 
   mRealProblem.calculate();
 
   return mRealProblem.getBestValue();
 }

unsigned int CGA::fittest ( void )

check the best individual at this generation

Definition at line 591 of file CGA.cpp.

References mCandX, and mPopSize.

Referenced by creation(), initFirstGeneration(), and optimise().

 {
   unsigned int i, b;
   double f;
   f = mCandX[0];
   b = 0;
 
   for (i = 1; i < mPopSize; i++)
     if (mCandX[i] < f)
       {
         b = i;
         f = mCandX[i];
       }
 
   return b;
 }

double CGA::getBestCandidate ( )

get the best candidate

Definition at line 269 of file CGA.cpp.

References mBest, and mCandX.

Referenced by optimise().

 {
   return mCandX[mBest];
 }

unsigned int CGA::getGeneration ( )

get generation number

Definition at line 275 of file CGA.cpp.

References mGener.

Referenced by optimise().

 {
   return mGener;
 }

int CGA::getParamNum ( )

get the parameter number

Definition at line 263 of file CGA.cpp.

References mParamNum.

 {
   return mParamNum;
 }

int CGA::getPopSize ( )

get population size

Definition at line 281 of file CGA.cpp.

References mPopSize.

Referenced by optimise().

 {
   return mPopSize;
 }

void CGA::initFirstGeneration ( )

initialize the first generation

Definition at line 116 of file CGA.cpp.

References creation(), evaluate(), fittest(), max, mBest, mCandX, mIndV, mParamNum, and mPopSize.

Referenced by initialize().

 {
   int i;
 
   for (i = 0; i < mParamNum; i++)
     mIndV[0][i] = 1.1 + dr250();
 
   try
     {
       // calculate the fitness
       mCandX[0] = evaluate(0);
     }
   catch (unsigned int e)
     {
       mCandX[0] = std::numeric_limits< C_FLOAT64 >::max();
     }
 
   // the others are randomly generated
   creation(1, mPopSize);
 
   mBest = fittest();
 }

bool CGA::initialize ( )

initialize function

Definition at line 74 of file CGA.cpp.

References initFirstGeneration(), mCandX, mCrp, mGener, mIndV, mMax, mMidX, mMin, mMutVar, mParamNum, mPopSize, mRealProblem, and mWins.

 {
   unsigned int i;
 
   mMin = *(mRealProblem.getParameterMin());
   mMax = *(mRealProblem.getParameterMax());
   mParamNum = mRealProblem.getParameterNum();
 
   std::vector <COptAlgorithmParameter> &AlgmParams = getMethodParameters();
 
   for (i = 0; i < getMethodParameterNumber(); i++)
     {
       if (AlgmParams[i].getName() == "Population Size")
         mPopSize = unsigned(AlgmParams[i].getValue());
       else if (AlgmParams[i].getName() == "Generation Number")
         mGener = unsigned(AlgmParams[i].getValue());
       else if (AlgmParams[i].getName() == "Mutation Variance")
         mMutVar = AlgmParams[i].getValue();
     }
 
   mCandX = new double[2 * mPopSize];
   // create array for tournament
   mWins = new unsigned int[2 * mPopSize];
   // create array for crossover points
   mCrp = new unsigned int[mParamNum];
   // create array for shuffling the population
   mMidX = new unsigned int[mPopSize];
   // create the population array
   mIndV = new double * [2 * mPopSize];
   // create the individuals
 
   for (i = 0; i < 2*mPopSize; i++)
     {
       mIndV[i] = new double[mParamNum];
     }
 
   initFirstGeneration();
 
   return 0;
 }

int CGA::initOptRandom ( )

Set the random seed with time

Definition at line 287 of file CGA.cpp.

Referenced by optimise().

 {
   struct timeb init_time;
   ftime(&init_time);
   r250_init(init_time.millitm);
   return 0;
 }

void CGA::mutate ( unsigned int i )

process mutation

Definition at line 384 of file CGA.cpp.

References evaluate(), mCandX, mIndV, mMax, mMin, mMutVar, and mParamNum.

Referenced by replicate().

 {
   int j;
   //double mMin, mMax, mut;
   double mut;
   // mutate the parameters
 
   for (j = 0; j < mParamNum; j++)
     {
       //YOHE: test
       //  double indtmp = mIndV[i][j];
       //  double rnorm = rnormal01();
       //  mut = indtmp * (1 + mMutVar * rnorm);
 
       // calculate the mutatated parameter
       mut = mIndV[i][j] * (1 + mMutVar * rnormal01());
 
       // force it to be within the bounds
 
       if (mut <= mMin)
         mut = mMin + std::numeric_limits< C_FLOAT64 >::epsilon();
       else
 
         {
           if (mut < mMin)
             mut = mMin;
         }
 
       if (mut >= mMax)
         mut = mMax - std::numeric_limits< C_FLOAT64 >::epsilon();
       else
 
         {
           if (mut > mMax)
             mut = mMax;
         }
 
       // store it
       mIndV[i][j] = mut;
     }
 
   // evaluate the fitness
   mCandX[i] = evaluate(i);
 }

CGA & CGA::operator= ( const CGA & source )

Object assignment overloading

Parameters

source a CGA object for copy

Returns: an assigned CGA object

Definition at line 159 of file CGA.cpp.

References cleanup(), mBest, mCandX, mCrossNum, mCrp, mGener, mIndV, mMax, mMidX, mMin, mMutProb, mMutVar, mParamNum, mPopSize, and mWins.

 {
   cleanup();
 
   if (this != &source)
     {
       mGener = source.mGener;
       mPopSize = source.mPopSize;
       mCrossNum = source.mCrossNum;
       mMin = source.mMin;
       mMax = source.mMax;
       mMutVar = source.mMutVar;
       mMutProb = source.mMutProb;
       mBest = source.mBest;
       mParamNum = source.mParamNum;
       mIndV = source.mIndV;
       mCandX = source.mCandX;
       mCrp = source.mCrp;
       mMidX = source.mMidX;
       mWins = source.mWins;
     }
 
   return *this;
 }

int CGA::optimise ( )

optimization function

Definition at line 696 of file CGA.cpp.

References creation(), dumpData(), fittest(), getBestCandidate(), getGeneration(), getPopSize(), initOptRandom(), mMax, mMin, mParamNum, mRealProblem, replicate(), select(), and setBest().

 {
   unsigned int i, last_update, u100, u300, u500;
   double bx;
 
   struct timeb before, after;
   double dTime = 0;
 
   ftime(&before);
   dTime = time(NULL);
 
   //mMin = *(mRealProblem.getParameterMin());
   //mMax = *(mRealProblem.getParameterMax());
   //mParamNum = mRealProblem.getParameterNum();
 
   std::cout << "mMin = " << mMin << ", mMax= " << mMax << ", mParamNum = " << mParamNum << std::endl;
   std::cout << "mRealProblem.getParameterNum() = " << mRealProblem.getParameterNum() << std::endl;
 
   initOptRandom();
 
   /*
   //YOHE: new
 
   std::vector <COptAlgorithmParameter> *AlgmParams = getMethodParameters();
 
   for (int i=0; i < (getMethodParameterNumber()); i++)
   {
   if ((*AlgmParams)[i].getName() == "Population Size")
   mPopSize = (*AlgmParams)[i].getValue();
   else if ((*AlgmParams)[i].getName() == "Generation Number")
   mGener =  (*AlgmParams)[i].getValue();
   else if ((*AlgmParams)[i].getName() == "Mutation Variance")
   mMutVar = (*AlgmParams)[i].getValue();
   }
   */
 
   // initialise the variance for mutations
   //setMutVar(0.1);
 
   // initialise the update registers
   last_update = 0;
   u100 = u300 = u500 = 0;
 
   //Display layout of all MPI processes
   std::cout << std::endl;
   std::cout << "Initial populaiton has successfully created!!!!!" << std::endl;
 
   // and store that value
   bx = getBestCandidate();
 
   std::cout << "-----------------------------best result at each generation---------------------" << std::endl;
   std::cout << "Generation\t" << "Best candidate value for object function\t" << "Display " << mParamNum << " parameters" << std::endl;
   std::cout << std::endl;
 
   int psize = getPopSize();
 
   // ITERATE FOR gener GENERATIONS
 
   for (i = 0; i < getGeneration(); i++)
     {
       std::cout << std::endl;
       std::cout << "GA is processing at generation " << i << std::endl;
 
       dumpData(i);
       // replicate the individuals
       replicate();
       // select the most fit
       select(2);
       // get the index of the fittest
       // mBest = fittest();
       setBest(fittest());
 
       if (getBestCandidate() != bx)
         {
           last_update = i;
           bx = getBestCandidate();
         }
 
       if (u100)
         u100--;
 
       if (u300)
         u300--;
 
       if (u500)
         u500--;
 
       // perturb the population if we have stalled for a while
       if ((u500 == 0) && (i - last_update > 500))
         {
           creation(psize / 2, psize);
           u500 = 500;
           u300 = 300;
           u100 = 100;
         }
 
       else if ((u300 == 0) && (i - last_update > 300))
         {
           creation(unsigned(psize*0.7), psize);
 
           u300 = 300;
           u100 = 100;
         }
 
       else if ((u100 == 0) && (i - last_update > 100))
         {
           creation(unsigned(psize*0.9), psize);
           u100 = 100;
         }
     }
 
   ftime(&after);
   std::ofstream tout("time.dat");
 
   if (!tout)
     {
       std::cout << " tout cannot output!" << std::endl;
       exit(0);
     }
 
   tout << "CPU's Calculation Time [ms]:" << 1000*(after.time - before.time) + (after.millitm - before.millitm) << std::endl;
   tout << " It has taken about " << time(NULL) - dTime << " seconds!" << std::endl;
   tout.close();
 
   std::cout << std::endl;
   std::cout << "GA has successfully done!" << std::endl;
   std::cout << " It has taken about " << time(NULL) - dTime << " seconds!" << std::endl;
   std::cout << "and it is ready to exit now!" << std::endl;
 
   return 0;
 }

void CGA::replicate ( void )

replicate the individuals w/ crossover

Definition at line 518 of file CGA.cpp.

References copy(), crossover(), mMidX, mPopSize, mutate(), and shuffle().

Referenced by optimise().

 {
   unsigned int i;
 
   // generate a random order for the parents
   shuffle();
   // reproduce in consecutive pairs
 
   for (i = 0; i < mPopSize / 2; i++)
     crossover(mMidX[i*2], mMidX[i*2 + 1], mPopSize + i*2, mPopSize + i*2 + 1);
 
   // check if there is one left over and just copy it
   if (mPopSize % 2 > 0)
     copy(mPopSize - 1, 2*mPopSize - 1);
 
   // mutate the offspring
   for (i = 0; i < mPopSize; i++)
     mutate(mPopSize + i);
 }

void CGA::select ( int method )

select popsize individuals

Definition at line 539 of file CGA.cpp.

References copy(), mCandX, mPopSize, mWins, and swap().

Referenced by optimise().

 {
   unsigned int i, j, nopp, opp;
 
   switch (method)
     {
       case 1:         // parent-offspring competition
 
         for (i = mPopSize; i < 2*mPopSize; i++)
           {
             // if offspring is fitter keep it
 
             if (mCandX[i] < mCandX[i - mPopSize])
               copy(i, i - mPopSize);
           }
 
         break;
 
       case 2:         // tournament competition
         // compete with 20% of the population
         nopp = mPopSize / 5;
         // but at least one
 
         if (nopp < 1)
           nopp = 1;
 
         // parents and offspring are all in competition
         for (i = 0; i < 2*mPopSize; i++)
           {
             mWins[i] = 0;
 
             for (j = 0; j < nopp; j++)
               {
                 // get random opponent
                 opp = r250n(mPopSize * 2);
 
                 if (mCandX[i] <= mCandX[opp])
                   mWins[i]++;
               }
           }
 
         // selection of top mPopSize winners
         for (i = 0; i < mPopSize; i++)
           for (j = i + 1; j < 2*mPopSize; j++)
             if (mWins[i] < mWins[j])
               swap(i, j);
 
         break;
     }
 }

void CGA::setBest ( unsigned int num )

set the best result

Definition at line 255 of file CGA.cpp.

References mBest.

Referenced by optimise().

 {
   mBest = num;
 }

void CGA::setCandx	(	int	i,
		double	num
	)

set mCandX, the private member

Definition at line 249 of file CGA.cpp.

References mCandX.

 {
   mCandX[i] = num;
 }

void CGA::setGeneration ( int num )

set generation number

Definition at line 219 of file CGA.cpp.

References mGener.

 {
   mGener = num;
 }

void CGA::setIndv	(	int	i,
		int	j,
		double	num
	)

set mIndV, the private member

Definition at line 243 of file CGA.cpp.

References mIndV.

 {
   mIndV[i][j] = num;
 }

void CGA::setMax ( double num )

set the max

Definition at line 237 of file CGA.cpp.

References mMax.

 {
   mMax = num;
 }

void CGA::setMin ( double num )

set the minimum

Definition at line 231 of file CGA.cpp.

References mMin.

 {
   mMin = num;
 }

void CGA::setMutVar ( double num )

set the mutation variance

Definition at line 225 of file CGA.cpp.

References mMutVar.

 {
   mMutVar = num;
 }

void CGA::setParamNum ( int num )

set parameter

Definition at line 207 of file CGA.cpp.

References mParamNum.

 {
   mParamNum = num;
 }

void CGA::setPopSize ( int num )

set population size

Definition at line 213 of file CGA.cpp.

References mPopSize.

 {
   mPopSize = num;
 }

void CGA::setRealProblem ( CRealProblem & aProb )

Declare the prototype of member functions set real problem

Definition at line 201 of file CGA.cpp.

References mRealProblem.

 {
   mRealProblem = aProb;
 }

void CGA::shuffle ( void )

shuffle data

Definition at line 500 of file CGA.cpp.

References mMidX, and mPopSize.

Referenced by replicate().

 {
   unsigned int i, a, b, tmp;
 
   for (i = 0; i < mPopSize; i++)
     mMidX[i] = i;
 
   for (i = 0; i < mPopSize / 2; i++)
     {
       a = r250n(mPopSize);
       b = r250n(mPopSize);
       tmp = mMidX[a];
       mMidX[a] = mMidX[b];
       mMidX[b] = tmp;
     }
 }

void CGA::swap	(	unsigned int	o,
		unsigned int	d
	)

swap individuals o and d

Definition at line 363 of file CGA.cpp.

References mCandX, mIndV, mParamNum, and mWins.

Referenced by select().

 {
   int i;
   double tmp;
 
   for (i = 0; i < mParamNum; i++)
     {
       tmp = mIndV[d][i];
       mIndV[d][i] = mIndV[o][i];
       mIndV[o][i] = tmp;
     }
 
   tmp = mCandX[d];
   mCandX[d] = mCandX[o];
   mCandX[o] = tmp;
   i = mWins[d];
   mWins[d] = mWins[o];
   mWins[o] = i;
 }