EGTControl.h

Go to the documentation of this file.

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

$Id: EGTControl.h,v 1.15 2003/01/27 14:00:44 motegi Exp $
Copyright (C) 2002 Higuchi Lab. All rights reserved.

*****************************************************************************/
#ifndef INCLUDE__CONTROL_H__FILE
#define INCLUDE__CONTROL_H__FILE

#include "defs.h"
#include "env.h"
#include "EGMeasure.h"
#include "EGRandom.h"
#include "EGTCrossover.h"
#include "EGTElitistSel.h"
#include "EGTEvaluation.h"
#include "EGTMutation.h"
#include "EGTRouletteSel.h"
#include "EGTSelection.h"
#include "EGTVector.h"
#include "EGFileIO.h"
#include <iostream>
#include <fstream>

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

  EGTControl();
  virtual ~EGTControl();

  virtual void InitControl();
  virtual void LoadControl();
  virtual void SaveControl() const;
  virtual void LoadTarget(const char* filename) = 0;

  virtual void SetEvaluation(EGTEvaluation<TP>* =0) = 0;
  virtual void SetSelection(EGTSelection<TP>* =0);
  virtual void SetSelection2(EGTSelection<TP>* =0);
  virtual void SetMutation(EGTMutation<TP>* =0);
  virtual void SetCrossover(EGTCrossover<TP>* =0);
  virtual void Execute(std::ostream&);

protected:
  enum MeasureOp {START, STOP, LAP}; 

  virtual void NextGeneration();

  void SaveLogFiles(UInt, MeasureOp);
  void SaveTimeLog(UInt, MeasureOp);
  void SaveFitnessLog(UInt) const;
  void SavePopLog(UInt) const;
  virtual void SaveBestLog(UInt) const;
  virtual void SaveBestDot(UInt) const;
  virtual void SaveGeneration(UInt) const;

  Pop*               m_tPop;         
  EGTEvaluation<TP>* m_tEvaluation;  
  EGTSelection<TP>*  m_tSelection;   
  EGTSelection<TP>*  m_tSelection2;  
  EGTMutation<TP>*   m_tMutation;    
  EGTCrossover<TP>*  m_tCrossover;   
  EGMeasure          m_tMeasure;     

  Node m_Creator;
  bool m_bEvolved;
};

//============================================================================
template<class TP>
EGTControl<TP>::EGTControl()
  : m_tPop(0), m_tEvaluation(0), m_tSelection(0), m_tSelection2(0),
    m_tMutation(0), m_tCrossover(0), m_Creator(0, 0, 0), m_bEvolved(false)
{
}

//============================================================================
template<class TP>
EGTControl<TP>::~EGTControl()
{
  delete m_tPop;
  delete m_tEvaluation;
  delete m_tSelection;
  delete m_tSelection2;
  delete m_tMutation;
  delete m_tCrossover;
}

//============================================================================
template<class TP>
void EGTControl<TP>::InitControl()
{
  Graph::m_tCreator = &m_Creator;
  SubGraph::m_tCreator = &m_Creator;
  m_tPop = new Pop;
  m_tPop->InitPopulation();
  m_tPop->AssignGraphID();
  m_bEvolved = true;
}

//============================================================================
template<class TP>
void EGTControl<TP>::SetSelection(EGTSelection<TP>* ps)
{
  delete m_tSelection;
  m_tSelection = (ps) ? ps : new EGTRouletteSel<TP>;
}

//============================================================================
template<class TP>
void EGTControl<TP>::SetSelection2(EGTSelection<TP>* ps)
{
  delete m_tSelection2;
  m_tSelection2 = (ps) ? ps : new EGTElitistSel<TP>;
}

//============================================================================
template<class TP>
void EGTControl<TP>::SetMutation(EGTMutation<TP>* pm)
{
  delete m_tMutation;
  m_tMutation = (pm) ? pm : new EGTMutation<TP>;
}

//============================================================================
template<class TP>
void EGTControl<TP>::SetCrossover(EGTCrossover<TP>* pc)
{
  delete m_tCrossover;
  m_tCrossover = (pc) ? pc : new EGTCrossover<TP>;
}

//============================================================================
template<class TP>
void EGTControl<TP>::Execute(std::ostream& out)
{
  std::cout << '\n';
  out       << '\n';
  Env::Instance().Display(std::cout);
  Env::Instance().Display(out);
  std::cout << "\nNow evolving... " << std::flush;
  out       << "\nNow evolving... " << std::flush;
  
  SetEvaluation();
  SetSelection();
  SetSelection2();
  SetCrossover();
  SetMutation();

  const UInt uMaxGen = Env::Instance().MaxGeneration();

  m_tEvaluation->Evaluate(*m_tPop);   // Evaluates initial population.
  SaveLogFiles(Env::Instance().CurrentGeneration(), START);

  for (UInt i=0; i<uMaxGen; ++i) {
    NextGeneration();
    SaveLogFiles(Env::Instance().CurrentGeneration(), LAP);
    if (Interruption) {               // ex.) Ctrl-C
      Env::Instance().SetGeneratePopSave(true);
      break;
    }
  }
  SaveLogFiles(Env::Instance().CurrentGeneration(), STOP);

  std::cout << "done\n" << std::endl;
  out       << "done\n" << std::endl;
  Env::Instance().Display(std::cout);
  Env::Instance().Display(out);
  std::cout << '\n';
  out       << '\n';
}

//============================================================================
template<class TP>
void EGTControl<TP>::NextGeneration()
{
  Env::Instance().NextGeneration();
  UInt oldFit = (UInt)(m_tPop->GetBestGraph()->GetFitness() * 10000.0);

  Graphs tTempGraphs;
  Pop* ptNextPop = new Pop;
  UInt uPopSize = Env::Instance().PopSize();
  m_tSelection->Selection(*m_tPop, tTempGraphs, uPopSize); // Selection
  m_tCrossover->Crossover(tTempGraphs, *ptNextPop);        // Crossover
  m_tMutation->Mutation(tTempGraphs, *ptNextPop);          // Mutation
  
  Int rest = uPopSize - ptNextPop->GetNumGraphs();
  if (rest > 0) {
    m_tSelection2->Selection(*m_tPop, *ptNextPop, rest);   // Selection
  }
  ptNextPop->AssignGraphID();
  m_tEvaluation->Evaluate(*ptNextPop);                     // Evaluation
  delete m_tPop;
  m_tPop = ptNextPop;

  UInt newFit = (UInt)(m_tPop->GetBestGraph()->GetFitness() * 10000.0);
  m_bEvolved = (newFit > oldFit) ? true : false;
}

//============================================================================
template<class TP>
void EGTControl<TP>::LoadControl()
{
  Graph::m_tCreator = &m_Creator;
  SubGraph::m_tCreator = &m_Creator;
  m_tPop = new Pop;
  m_tPop->LoadPopulation();
  m_tPop->AssignGraphID();

  const std::string name = EGFileIO::GetSeedFileName();
  EGRandom::LoadSeed(name.c_str());
  Env::Instance().LoadEnvironment();
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveControl() const
{
  m_tPop->SavePopulation();

  const std::string name = EGFileIO::GetSeedFileName();
  EGRandom::SaveSeed(name.c_str());
  Env::Instance().SaveEnvironment();
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveLogFiles(UInt i, MeasureOp op) 
{
  SaveTimeLog(i, op);   // Records the time. (time.log)
  SaveFitnessLog(i);    // Records the fitness values of current population.
  SavePopLog(i);        // Records the data of current population.
  SaveBestLog(i);       // Records the best Graph of current population.
  SaveBestDot(i);
  SaveGeneration(i);
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveFitnessLog(UInt i) const
{
  if (Env::Instance().GenerateFitnessLog() == false) {
        return;
  }
  const std::string name = EGFileIO::GetFitnessLogFileName();
  std::ofstream fout;
  if (i == 0) {
    fout.open(name.c_str());
  }
  else {
    fout.open(name.c_str(), std::ios::out|std::ios::app);
  }
  if (!fout) {
    throw EGException("Can't open file", __FILE__, __LINE__);
  }
  if (i == 0) {
    fout << "Gen.\tAvg.\tMax(";
    m_tPop->GetBestGraph()->DisplayFitness(fout, true);
    fout << ")\n";
  }

  fout << i << '\t' << m_tPop->GetFitnessAvg() << '\t';
  m_tPop->GetBestGraph()->DisplayFitness(fout, false);
  fout << std::endl;
  fout.close();
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveTimeLog(UInt i, MeasureOp ope)
{
  if (Env::Instance().GenerateTimeLog() == false) {
        return;
  }
  const std::string name = EGFileIO::GetTimeLogFileName();
  std::ofstream fout;
  if (i == 0) {
    fout.open(name.c_str());
  }
  else {
    fout.open(name.c_str(), std::ios::out|std::ios::app);
  }
  if (!fout) {
    throw EGException("Can't open file", __FILE__, __LINE__);
  }
  if (ope == START) {
    m_tMeasure.Start(fout);
  }
  else if (ope == LAP) {
    fout  << i << '\t';
    m_tMeasure.Lap(fout);
  }
  else if (ope == STOP) {
    fout << "#Sum\t";
    m_tMeasure.Stop(fout);
  }
  fout.close();
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveGeneration(UInt n) const 
{
  if (Env::Instance().GenerateEachGeneration() == false) {
    return;
  }

  const std::string dir = EGFileIO::GetGenDirectoryName(n);
  EGFileIO::MakeDirectory(dir.c_str());

  UInt num_graphs = m_tPop->GetNumGraphs();
  for (UInt i=0; i<num_graphs; ++i) {
    const std::string name = EGFileIO::GetDotFileName(dir.c_str(), n, i);
    std::ofstream fout(name.c_str());
    if (!fout) {
      throw EGException("Can't open file", __FILE__, __LINE__);
    }
    m_tPop->GetGraph(i)->DisplayDot(fout);
    fout.close();

    const std::string name2 = EGFileIO::GetLogFileName(dir.c_str(), n, i);
    std::ofstream fout2(name2.c_str());
    if (!fout2) {
      throw EGException("Can't open file", __FILE__, __LINE__);
    }
    m_tPop->GetGraph(i)->Display(fout2);
    fout2.close();
  }
}

//============================================================================
template<class TP>
void EGTControl<TP>::SavePopLog(UInt i) const
{
  // if (i % m_uLogInterval || Env::Instance().GeneratePopLog() == false) {
  if (Env::Instance().GeneratePopLog() == false) {
    return;
  }
  const std::string name = EGFileIO::GetPopLogFileName(i);
  std::ofstream fout(name.c_str());
  if (!fout) {
    throw EGException("Can't open file", __FILE__, __LINE__);
  }
  m_tPop->Display(fout);
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveBestLog(UInt i) const
{
  if (m_bEvolved == false || Env::Instance().GenerateBestLog() == false) {
    return;
  }
  const std::string name = EGFileIO::GetBestLogFileName(i);
  std::ofstream fout(name.c_str());
  if (!fout) {
    throw EGException("Can't open file", __FILE__, __LINE__);
  }
  m_tPop->GetBestGraph()->Display(fout);
}

//============================================================================
template<class TP>
void EGTControl<TP>::SaveBestDot(UInt i) const
{
  if (m_bEvolved == false || Env::Instance().GenerateDot() == false) {
    return;
  }
  const std::string name = EGFileIO::GetBestDotFileName(i);
  std::ofstream fout(name.c_str());
  if (!fout) {
    throw EGException("Can't open file", __FILE__, __LINE__);
  }
  m_tPop->GetBestGraph()->DisplayDot(fout);
}

#endif  //INCLUDE__CONTROL_H__FILE