moILS.h

/* 
* <moILS.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
*
* Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software.  You can  use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and  rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty  and the software's author,  the holder of the
* economic rights,  and the successive licensors  have only  limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading,  using,  modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean  that it is complicated to manipulate,  and  that  also
* therefore means  that it is reserved for developers  and  experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and,  more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/

#ifndef __moILS_h
#define __moILS_h

#include <eoEvalFunc.h>

#include "moHC.h"
#include "moTS.h"
#include "moSA.h"


template < class M > class moILS:public moAlgo < typename M::EOType >
{

  typedef typename M::EOType EOT;
  
  typedef typename EOT::Fitness Fitness;

public:


  moILS (moAlgo<EOT> &__algo, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, eoMonOp<EOT> &__perturbation, 
         eoEvalFunc<EOT> &__full_eval):
    algo(__algo), cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
  {}


  moILS (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval,
         moMoveSelect < M > &__move_select, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, 
         eoMonOp<EOT> &__perturbation, eoEvalFunc<EOT> &__full_eval):
    algo(*new moHC<M>(__move_init, __next_move, __incr_eval, __move_select, __full_eval)), cont(__continue), 
    acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
  {}


  moILS (moMoveInit <M> &__move_init, moNextMove <M> &__next_move, moMoveIncrEval <M> &__incr_eval,
         moTabuList <M> &__tabu_list, moAspirCrit <M> &__aspir_crit, moSolContinue <EOT> &__moTS_continue, 
         moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, eoMonOp<EOT> &__perturbation, 
         eoEvalFunc<EOT> &__full_eval):
    algo(*new moTS<M>(__move_init, __next_move, __incr_eval, __tabu_list, __aspir_crit, __moTS_continue, __full_eval)), 
    cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
  {}


  moILS (moRandMove<M> &__move_rand, moMoveIncrEval <M> &__incr_eval, moSolContinue <EOT> &__moSA_continue, double __init_temp,
         moCoolingSchedule & __cool_sched, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, 
         eoMonOp<EOT> &__perturbation, eoEvalFunc<EOT> &__full_eval):
    algo(*new moSA<M>(__move_rand, __incr_eval, __moSA_continue, __init_temp, __cool_sched, __full_eval)), 
    cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
  {}




  bool operator()(EOT & __sol)
  {
    EOT __sol_saved=__sol;
            
    cont.init ();

    //some code has been duplicated in order to avoid one perturbation and one evaluation without adding a test in the loop.
    // better than a do {} while; with a test in the loop.

    algo(__sol);
        
    if(acceptance_criterion(__sol, __sol_saved))
      {
        __sol_saved=__sol;
        
      }
    else
      {
        __sol=__sol_saved;
      }
    
    while (cont (__sol))
    {
      perturbation(__sol);
      full_eval(__sol);
      
      algo(__sol);
            
      if(acceptance_criterion(__sol, __sol_saved))
        {
          __sol_saved=__sol;
        }
      else
        {
          __sol=__sol_saved;
        }
    }
    
    return true;
  }

private:

  moAlgo<EOT> &algo;

  moSolContinue<EOT> &cont;

  moComparator<EOT> &acceptance_criterion;

  eoMonOp<EOT> &perturbation;
  
  eoEvalFunc<EOT> &full_eval;
};

#endif

---