eoOpContainer.h

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

//-----------------------------------------------------------------------------
// eoOpContainer.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
    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: mkeijzer@dhi.dk
             Marc.Schoenauer@polytechnique.fr
 */
//-----------------------------------------------------------------------------

#ifndef _eoOpContainer_H
#define _eoOpContainer_H

#include <eoGenOp.h>

template <class EOT>
class eoOpContainer : public eoGenOp<EOT>
{
  public :
  eoOpContainer() : max_to_produce(0) {}

  virtual ~eoOpContainer(void) {}

  virtual unsigned max_production(void)
  {
    return max_to_produce;
  }

  void add(eoOp<EOT>& _op, double _rate)
  {
    ops.push_back(&wrap_op<EOT>(_op, store));
    rates.push_back(_rate);
    max_to_produce = std::max(max_to_produce,ops.back()->max_production());
  }

  virtual std::string className() const = 0;

  protected :

  std::vector<double> rates;
  std::vector<eoGenOp<EOT>*> ops;

  private :
  eoFunctorStore store;
  unsigned max_to_produce;
};

template <class EOT>
class eoSequentialOp : public eoOpContainer<EOT>
{
public:

    using eoOpContainer<EOT>::ops;
    using eoOpContainer<EOT>::rates;

    typedef unsigned position_type;


    void apply(eoPopulator<EOT>& _pop) {
        _pop.reserve( this->max_production() );

        position_type pos = _pop.tellp();
        for (size_t i = 0; i < rates.size(); ++i) {
            _pop.seekp(pos);
            do {
                if (eo::rng.flip(rates[i])) {
                    //            try
                    //            {
                    // apply it to all the guys in the todo std::list

                    //(*ops[i])(_pop);

                    ops[i]->apply(_pop);

                    //            }
                    // check for out of individuals and do nothing with that...
                    //            catch(eoPopulator<EOT>::OutOfIndividuals&)
                    //        {
                    //          std::cout << "Warning: not enough individuals to handle\n";
                    //          return ;
                    //        }
                }

                if (!_pop.exhausted())
                    ++_pop;
            }
            while (!_pop.exhausted());
        }
    }
    virtual std::string className() const {return "SequentialOp";}

private:

    std::vector<size_t> to_apply;
    std::vector<size_t> production;
};



template <class EOT>
class eoProportionalOp : public eoOpContainer<EOT>
{
public:

    using eoOpContainer< EOT >::ops;
    using eoOpContainer< EOT >::rates;

    void apply(eoPopulator<EOT>& _pop)
    {
      unsigned i = eo::rng.roulette_wheel(rates);

      try
      {
        (*ops[i])(_pop);
        ++_pop;
      }
      catch( typename eoPopulator<EOT>::OutOfIndividuals&)
      {}
    }
  virtual std::string className() const {return "ProportionalOp";}
};


#endif