eoPop.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

//-----------------------------------------------------------------------------
// eoPop.h 
// (c) GeNeura Team, 1998
/* 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
 */
//-----------------------------------------------------------------------------

#ifndef _EOPOP_H
#define _EOPOP_H

#include <algorithm>
#include <iostream>
#include <iterator> // needed for GCC 3.2
#include <vector>

// EO includes
#include <eoOp.h> // for eoInit
#include <eoPersistent.h>
#include <eoInit.h>
#include <utils/rnd_generators.h>  // for shuffle method

template<class EOT>
class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent 
{

 public:
     
     using std::vector<EOT>::size;
     using std::vector<EOT>::resize;
     using std::vector<EOT>::operator[];
     using std::vector<EOT>::begin;
     using std::vector<EOT>::end;
     
     typedef typename EOT::Fitness Fitness;
        eoPop()   : std::vector<EOT>(), eoObject(), eoPersistent() {};
        
    eoPop( unsigned _popSize, eoInit<EOT>& _chromInit )
      :std::vector<EOT>() 
    {
        resize(_popSize);
          for ( unsigned i = 0; i < _popSize; i++ )
      {
                _chromInit(operator[](i));
          }
        };

    void append( unsigned _newPopSize, eoInit<EOT>& _chromInit )
    {
      unsigned oldSize = size();
      if (_newPopSize < oldSize)
        {
          throw std::runtime_error("New size smaller than old size in pop.append");
          return;
        }
      if (_newPopSize == oldSize)
        return;
      resize(_newPopSize);         // adjust the size
      for ( unsigned i = oldSize; i < _newPopSize; i++ )
        {
          _chromInit(operator[](i));
        }
    };
  
  
  eoPop( std::istream& _is ) :std::vector<EOT>() {
    readFrom( _is );
  }
  
        virtual ~eoPop() {};


      struct Ref { const EOT* operator()(const EOT& eot) { return &eot;}};
      struct Cmp {
          bool operator()(const EOT* a, const EOT* b) const
            { return b->operator<(*a); }
      };

  void sort(void)
  {
      std::sort(begin(), end(), std::greater<EOT>());
  }

  void sort(std::vector<const EOT*>& result) const
  {
      result.resize(size());

      std::transform(begin(), end(), result.begin(), Ref());

      std::sort(result.begin(), result.end(), Cmp());
  }

  void shuffle(void)
  {
    UF_random_generator<unsigned int> gen;
      std::random_shuffle(begin(), end(), gen);
  }

  void shuffle(std::vector<const EOT*>& result) const
  {
      result.resize(size());

      std::transform(begin(), end(), result.begin(), Ref());

      UF_random_generator<unsigned int> gen;
      std::random_shuffle(result.begin(), result.end(), gen);
  }

  typename eoPop<EOT>::iterator it_best_element() 
  {
    typename eoPop<EOT>::iterator it = std::max_element(begin(), end());
    return it;
  }

  const EOT & best_element() const
  {
    typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
    return (*it);
  }

  const EOT & worse_element() const
  {
    typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
    return (*it);
  }

  typename eoPop<EOT>::iterator it_worse_element()
  {
    typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
    return it;
  }

  typename eoPop<EOT>::iterator nth_element(int nth)
  {
      typename eoPop<EOT>::iterator it = begin() + nth;
      std::nth_element(begin(), it, end(), std::greater<EOT>());
      return it;
  }

  struct GetFitness { Fitness operator()(const EOT& _eo) const { return _eo.fitness(); } };
  
  Fitness nth_element_fitness(int which) const
  { // probably not the fastest way to do this, but what the heck
      
      std::vector<Fitness> fitness(size());
      std::transform(begin(), end(), fitness.begin(), GetFitness());

      typename std::vector<Fitness>::iterator it = fitness.begin() + which;
      std::nth_element(fitness.begin(), it, fitness.end(), std::greater<Fitness>());
      return *it;
  }

  void nth_element(int which, std::vector<const EOT*>& result) const
  {

      result.resize(size());
      std::transform(begin(), end(), result.begin(), Ref());
  
      typename std::vector<const EOT*>::iterator it  = result.begin() + which;

      std::nth_element(result.begin(), it, result.end(), Cmp());
  }

  void swap(eoPop<EOT>& other)
  {
      std::swap(static_cast<std::vector<EOT>& >(*this), static_cast<std::vector<EOT>& >(other));
  }
  
  virtual void sortedPrintOn(std::ostream& _os) const 
  {
    std::vector<const EOT*> result;
    sort(result);
    _os << size() << '\n';
    for (unsigned i = 0; i < size(); ++i)
      {
        _os << *result[i] << std::endl;
      }
  }

  virtual void printOn(std::ostream& _os) const 
  {
        _os << size() << '\n';
        std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") );
  }

  virtual void readFrom(std::istream& _is) 
  {
    size_t sz;
    _is >> sz;

    resize(sz);

    for (size_t i = 0; i < sz; ++i) {  
        operator[](i).readFrom( _is );
    }
  }

  virtual std::string className() const {return "eoPop";};

  virtual void invalidate()
  {
    for (unsigned i=0; i<size(); i++)
      this->operator[](i).invalidate();
  }


 protected:

};

#endif

---