EGTPopulation.h

Go to the documentation of this file.

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

$Id: EGTPopulation.h,v 1.8 2003/01/27 10:11:47 miyabi Exp $
Copyright (C) 2002 Higuchi Lab. All rights reserved.

*****************************************************************************/
#ifndef INCLUDE__POPULATION_H__FILE
#define INCLUDE__POPULATION_H__FILE

#include "defs.h"
#include "env.h"
#include "EGException.h"
#include "EGTGraph.h"
#include "EGTVector.h"
#include <fstream>
//#include <iomanip>
#include "EGFileIO.h" // for GetDatFileName()

template<class TG>
class EGTPopulation {
public:
  typedef TG                   Graph;
  typedef EGTVector<Graph*>    Graphs;
  typedef typename Graphs::Iterator GraphsIterator;
  typedef typename Graphs::ConstIterator GraphsConstIterator;
  typedef EGTPopulation<Graph> Self;
  typedef EGTEvaluation<Graph> Eval;

  EGTPopulation() { }
  EGTPopulation(const Self&);
  virtual ~EGTPopulation();

  void InitPopulation(UInt n = 0);
  Float GetFitnessAvg() const;
  void SavePopulation() const;
  bool LoadPopulation();
  void Display(std::ostream&) const;

  void AssignGraphID();
  Graph* GetGraph(UInt);
  const Graph* GetGraph(UInt) const;
  Graph* GetBestGraph() const;
  EGTVector<const Graph*> GetGraphs() const;

  void AddGraph(Graph* pg) { m_tGraphs.PushBack(pg); }
  UInt GetNumGraphs() const {  return m_tGraphs.Size(); }

protected:
  void CheckIndex(UInt uNum, char* filename, UInt uLine) const;

private:
  Graphs m_tGraphs;
  Self& operator=(const Self&);
};

//============================================================================
template<class TG>
EGTVector<const TG*>
EGTPopulation<TG>::GetGraphs() const
{
  EGTVector<const Graph*> graphs;
  GraphsConstIterator it    = m_tGraphs.Begin();
  GraphsConstIterator itEnd = m_tGraphs.End();
  for (; it != itEnd; ++it) {
    graphs.PushBack(*it);
  }
  return graphs;
}

//============================================================================
template<class TG>
EGTPopulation<TG>::EGTPopulation(const Self& rhs)
{
  GraphsConstIterator itEnd = rhs.m_tGraphs.End();
  for (GraphsConstIterator it = rhs.m_tGraphs.Begin(); it != itEnd; ++it) {
    m_tGraphs.PushBack(new Graph(**it));
  }
}

//============================================================================
template<class TG>
EGTPopulation<TG>::~EGTPopulation()
{
  GraphsIterator itEnd = m_tGraphs.End();
  for (GraphsIterator it = m_tGraphs.Begin(); it != itEnd; ++it) {
    delete (*it);
  }
}

//============================================================================
template<class TG> 
void EGTPopulation<TG>::InitPopulation(UInt n)
{
  if (n == 0) {
    n = Env::Instance().PopSize();
  }
  if (n < m_tGraphs.Size()) {
    return;
  }
  n -= m_tGraphs.Size();
  Graph* pg;
  for (UInt i=0; i<n; ++i) {
    pg = new Graph();
    if (pg->InitGraph() == false) {
      delete pg;
      throw EGException("EGTPopulation::InitPopulation(), "
                        "Initialization failed.", __FILE__, __LINE__);
    }
    m_tGraphs.PushBack(pg);
  }
}

//============================================================================
template<class TG>
const TG* EGTPopulation<TG>::GetGraph(UInt uNum) const
{
  CheckIndex(uNum, __FILE__, __LINE__);
  return m_tGraphs[uNum];
}

//============================================================================
template<class TG>
TG* EGTPopulation<TG>::GetGraph(UInt uNum)
{
  CheckIndex(uNum, __FILE__, __LINE__);
  return m_tGraphs[uNum];
}

//============================================================================
template<class TG>
TG* EGTPopulation<TG>::GetBestGraph() const
{
  GraphsConstIterator it    = m_tGraphs.Begin();
  GraphsConstIterator itEnd = m_tGraphs.End();
  if (it == itEnd) {
    throw EGException("EGTPopulatoin::GetBestGraph(), There is no graph.",
                      __FILE__, __LINE__);
  }
  Graph* pg = *it;
  Float fit = (*it)->GetFitness();

  for (++it; it != itEnd; ++it) {
    if ((*it)->GetFitness() > fit) {
      fit = (*it)->GetFitness();
      pg = *it;
    }
  }
  return pg;
}

//============================================================================
template<class TG>
Float EGTPopulation<TG>::GetFitnessAvg() const
{
  const UInt uPopSize = m_tGraphs.Size();
  if (uPopSize == 0) {
    return 0;
  }
  Float fSum = 0.0;
  GraphsConstIterator itEnd = m_tGraphs.End();
  for (GraphsConstIterator it = m_tGraphs.Begin(); it != itEnd; ++it) {
    fSum += (*it)->GetFitness();
  }
  return fSum / uPopSize;
}

//============================================================================
template<class TG>
void EGTPopulation<TG>::AssignGraphID()
{
  UInt i=0;
  GraphsIterator it = m_tGraphs.Begin();
  GraphsIterator itEnd = m_tGraphs.End();
  for (; it != itEnd; ++it) {
    (*it)->SetGraphID(i++);
  }
}


//============================================================================
template<class TG>
void EGTPopulation<TG>::SavePopulation() const
{
  UInt i = 0;
  GraphsConstIterator itEnd = m_tGraphs.End();
  for (GraphsConstIterator it = m_tGraphs.Begin(); it != itEnd; ++it) {
    const std::string name = EGFileIO::GetDatFileName(i++);
    std::ofstream fout(name.c_str());
    if (!fout) {
      throw EGException("Can't open file", __FILE__, __LINE__);
    }
    (*it)->SaveGraph(fout);
  }
}

//============================================================================
template<class TG>
bool EGTPopulation<TG>::LoadPopulation()
{
  UInt uPopSize = Env::Instance().PopSize();
  Graph* pg;
  for (UInt i=0; i<uPopSize; ++i) {
    pg = new Graph;
    const std::string name = EGFileIO::GetDatFileName(i);
    if (pg->LoadGraph(name.c_str()) == false) {
      delete pg;
      return false;
    }
    else {
      AddGraph(pg);
    }
  }
  return true;
}

//============================================================================
template<class TG>
void EGTPopulation<TG>::Display(std::ostream& out) const
{
  UInt i = 0;
  GraphsConstIterator it = m_tGraphs.Begin();
  GraphsConstIterator itEnd = m_tGraphs.End();

  out << "#Graph   ";
  (*it)->DisplayFitness(out, true);
  out << "\tOperation\n";

  for (; it != itEnd; ++it) {
    out << i++ << '\t';
    (*it)->DisplayFitness(out, false);
    switch ((*it)->GetOperator()) {
    case OP_CROSSOVER:
      out << "\tcrossover(" << (*it)->GetMother() << ", " << (*it)->GetFather() << ")\n"; break;
    case OP_MUTATION:
      out << "\tmutation(" << (*it)->GetMother() << ")\n"; break;
    case OP_SELECTION:
      out << "\tselection(" << (*it)->GetMother() << ")\n"; break;
    default: out << "\tundefined\n"; break;
    }
  }
}

//============================================================================
template<class TG>
void EGTPopulation<TG>::CheckIndex(UInt uNum, 
                                   char* filename,
                                   UInt uLine) const
{
#ifdef DEBUG
  if (uNum > m_tGraphs.Size()) {
    throw EGException("EGTPopulation, "
                      "Index is greater than the number of Population.",
                      filename, uLine);
  }
#endif //DEBUG
}

#endif //INCLUDE__POPULATION_H__FILE