EGTMutation.h

Go to the documentation of this file.

/****************************************************************************

$Id: EGTMutation.h,v 1.1.1.1 2002/10/19 08:14:51 motegi Exp $
Copyright (C) 2002 Higuchi Lab. All rights reserved.

*****************************************************************************/
#ifndef INCLUDE__MUTATION_H__FILE
#define INCLUDE__MUTATION_H__FILE

#include "defs.h"
#include "env.h"
#include "EGException.h"
#include "EGRandom.h"
#include "EGTVector.h"

template<class TP>
class EGTMutation {
public:
  typedef TP                       Pop;
  typedef typename Pop::Graph      Graph;
  typedef EGTVector<const Graph*>  Graphs;
  typedef typename Graph::SubGraph SubGraph;

  virtual ~EGTMutation() { }
  virtual UInt Mutation(const Graphs& src, Pop& dest);

protected:
  virtual bool DoMutation(const Graph& src, Pop& dest);
};

//============================================================================
template<class TP>
UInt EGTMutation<TP>::Mutation(const Graphs& src, Pop& dest) {
  Float fMutationRate = Env::Instance().MutationRate();
  UInt uPopSize = Env::Instance().PopSize();           

  if (fMutationRate > 1.0) {  
    fMutationRate = 1.0;
  }
  UInt uMax = src.Size();
  if (uMax == 0) {
    throw EGException("EGTMutation::Mutation(), "
                      "Can't perform the mutation operation: no individuals.",
                      __FILE__, __LINE__);
  }
  // Number of mutation operations
  UInt uMutationCount = (UInt)(uPopSize * fMutationRate);

  UInt uSel = (UInt)(uMax * EGRandom::NextReal());

  UInt n = 0;
  for (UInt i=0; i<uMutationCount; ++i) {
    if (uSel == uMax) {
      uSel = 0;
    }
    if (DoMutation(*src[uSel++], dest) == true) {
      ++n;
    }
  }
  return n;
}

//============================================================================
template<class TP>
bool EGTMutation<TP>::DoMutation(const Graph& src, Pop& dest)
{
  UInt uNumSubGraphs = src.GetNumSubGraphs();
  if (uNumSubGraphs == 0) {
    return false;
  }
  //Selects a SubGraph randomly from the Graph.
  const UInt uRan = EGRandom::NextInt(0, uNumSubGraphs - 1);
  const SubGraph* ptSelSubGraph = src.GetSubGraph(uRan);

  if (ptSelSubGraph == 0) {
    return false;
  }
  //Creates a compatible SubGraph with the selected SubGraph.
  const UInt uIn = ptSelSubGraph->GetNumInTerms();
  const UInt uOut = ptSelSubGraph->GetNumOutTerms();
  SubGraph* ptNewSubGraph = new SubGraph;
  if (ptNewSubGraph->InitSubGraph(uIn, uOut) == false) {
    delete ptNewSubGraph;
    return false;
  }

  UInt uMaxNodeSize = Env::Instance().MaxNodeSize();
  //Creates the complement of the selected SubGraph.
  UInt uMax = 2 * uMaxNodeSize - ptNewSubGraph->GetNumNodes();
  SubGraph* ptRestSubGraph = src.CreateComplementarySubGraph(uRan, uMax);
  if (ptRestSubGraph == 0) {
    return false;
  }

  Graph* ptNewGraph = new Graph;

  //Combines "ptNewSubGraph" with "ptRestSubGraph".
  if (ptNewGraph->InitGraph(*ptRestSubGraph, *ptNewSubGraph, 2) == false) {
    delete ptNewGraph;
    delete ptNewSubGraph;
    delete ptRestSubGraph;
    return false;
  }

  ptNewGraph->SetOperator(OP_MUTATION);
  ptNewGraph->SetMother(src.GetGraphID());
  //Generated individuals are stored in "dest".
  dest.AddGraph(ptNewGraph);

#ifdef MUTATION_DETAIL
  std::cout << "The mutation operation performed.\n";
  std::cout << "*** Base SubGraph ***\n";      ptRestSubGraph->Display(std::cout);
  std::cout << "*** Generated SubGraph ***\n"; ptNewSubGraph->Display(std::cout);
#endif

  delete ptNewSubGraph;
  delete ptRestSubGraph;
  return true;
}

#endif //INCLUDE__MUTATION_H__FILE