deltacostcomponent.hh

Go to the documentation of this file.

#if !defined(_DELTA_COST_COMPONENT_HH_)
#define _DELTA_COST_COMPONENT_HH_

#include <stdexcept>

#include "easylocal/helpers/costcomponent.hh"
#include "easylocal/utils/printable.hh"

namespace EasyLocal {
  
  namespace Core {
    
    template <class Input, class State, class Move, typename CFtype = int>
    class DeltaCostComponent : public Printable
    {
    public:
      
      CostComponent<Input, State, CFtype>& GetCostComponent() const { return cc; }
      
      virtual void Print(std::ostream& os = std::cout) const;
      
      bool IsHard() const { return cc.IsHard(); }
      
      bool IsSoft() const { return cc.IsSoft(); }
      
      virtual CFtype DeltaCost(const State& st, const Move& mv) const;
      
      virtual bool IsDeltaImplemented() const { return true; }
      
      const std::string name;
      
      size_t Index() const
      {
        return cc.Index();
      }
      
    protected:
      
      DeltaCostComponent(const Input& in, CostComponent<Input, State, CFtype>& cc, std::string name);
      
      virtual CFtype ComputeDeltaCost(const State& st, const Move& mv) const = 0;
      
      const Input& in;
      
      CostComponent<Input, State, CFtype>& cc;
      
    };
    
    template <class Input, class State, class Move, typename CFtype>
    DeltaCostComponent<Input, State, Move, CFtype>::DeltaCostComponent(const Input& i, CostComponent<Input, State, CFtype>& e_cc, std::string name)
    : name(name), in(i), cc(e_cc)
    {}
    
    template <class Input, class State, class Move, typename CFtype>
    void DeltaCostComponent<Input, State, Move, CFtype>::Print(std::ostream& os) const
    {
      os << "  DeltaCost Component: " + this->name << std::endl;
    }
    
    template <class Input, class State, class Move, typename CFtype>
    CFtype DeltaCostComponent<Input, State, Move, CFtype>::DeltaCost(const State& st,
                                                                     const Move& mv) const
    {
      return this->cc.Weight() * ComputeDeltaCost(st, mv);
    }
    
    template <class Input, class State, class Move, typename CFtype>
    class NeighborhoodExplorer;
    
    template <class Input, class State, class Move, typename CFtype = int>
    class DeltaCostComponentAdapter : public DeltaCostComponent<Input, State, Move, CFtype>
    {
    public:
      
      DeltaCostComponentAdapter(const Input& in, CostComponent<Input, State, CFtype>& cc, NeighborhoodExplorer<Input, State, Move, CFtype>& ne);
      
      virtual bool IsDeltaImplemented() const { return false; }
      
    protected:
      
      virtual CFtype ComputeDeltaCost(const State& st, const Move& mv) const
      {
        State new_st = st;
        ne.MakeMove(new_st, mv);
        return this->cc.ComputeCost(new_st) - this->cc.ComputeCost(st);
      }
      NeighborhoodExplorer<Input, State, Move, CFtype>& ne;
    };
    
    template <class Input, class State, class Move, typename CFtype>
    DeltaCostComponentAdapter<Input, State, Move, CFtype>::DeltaCostComponentAdapter(const Input& in, CostComponent<Input, State, CFtype>& cc, NeighborhoodExplorer<Input, State, Move, CFtype>& ne)
    : DeltaCostComponent<Input, State, Move, CFtype>(in, cc, "DeltaAdapter" + cc.name), ne(ne)
    {}
  }
}

#endif // _DELTA_COST_COMPONENT_HH_