summaryrefslogtreecommitdiff
path: root/newstructure/thirdparty/linux/include/coin/BonLocalSolverBasedHeuristic.hpp
blob: 3f935e6621b7cf4253a3d016e70e54b54ddd7f60 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
// (C) Copyright CNRS
// This code is published under the Eclipse Public License.
//
// Authors :
// Pierre Bonami, LIF Université de la Méditérannée-CNRS
//
// Date : 06/18/2008

#ifndef BonLocalSolverBasedHeuristic_H
#define BonLocalSolverBasedHeuristic_H
#include "BonBonminSetup.hpp"
#include "CbcHeuristic.hpp"

namespace Bonmin {
  class LocalSolverBasedHeuristic : public CbcHeuristic {
  public:
    /** Default constructor.*/
    LocalSolverBasedHeuristic();

    /** Constructor with setup.*/
    LocalSolverBasedHeuristic(BonminSetup * setup);

    /** Copy constructor.*/
    LocalSolverBasedHeuristic(const LocalSolverBasedHeuristic & other);

    /** Destructor.*/
    ~LocalSolverBasedHeuristic();

    /** Virtual copy constructor.*/
    virtual CbcHeuristic * clone() const = 0;
 
  /// Assignment operator 
  LocalSolverBasedHeuristic & operator=(const LocalSolverBasedHeuristic& rhs);

#if 0
  /// update model (This is needed if cliques update matrix etc)
  virtual void setModel(CbcModel * model){throw -1;}
#endif
  /// Resets stuff if model changes
  virtual void resetModel(CbcModel * model){
   setModel(model);
  }

  /** Change setup used for heuristic.*/
  void setSetup(BonminSetup * setup){
    setup_ = setup;
    Initialize(setup_->options());
  }
  /** Performs heuristic  */
  virtual int solution(double & objectiveValue,
		       double * newSolution)=0;

  /** Performs heuristic which adds cuts  */
  virtual int solution(double & objectiveValue,
		       double * newSolution,
		       OsiCuts & cs) {return 0;}


   /** Do a local search based on setup and passed solver.*/
   int doLocalSearch(OsiTMINLPInterface * solver, 
                      double *solution, 
                      double & solValue,
                      double cutoff, std::string prefix = "local_solver.") const;

   /** Register the options common to all local search based heuristics.*/
   static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);

   /** Setup the defaults.*/
   virtual void setupDefaults(Ipopt::SmartPtr<Ipopt::OptionsList> options);

   /** Initiaize using passed options.*/
   void Initialize(Ipopt::SmartPtr<Ipopt::OptionsList> options);
   protected:
   /** Setup to use for local searches (will make copies).*/
   BonminSetup * setup_; 

   static void changeIfNotSet(Ipopt::SmartPtr<Ipopt::OptionsList> options, 
                       std::string prefix,
                       const std::string &option,
                       const std::string &value);
   
   static void changeIfNotSet(Ipopt::SmartPtr<Ipopt::OptionsList> options, 
                       std::string prefix,
                       const std::string &option,
                       const double &value);
   
   static void changeIfNotSet(Ipopt::SmartPtr<Ipopt::OptionsList> options,
                       std::string prefix,
                       const std::string &option,
                       const int &value);
   private:
    /** Time limit in local search.*/
    double time_limit_;
    /** maximal number of nodes in local search.*/
    int max_number_nodes_;
    /** Maximal number of solutions in local search.*/
    int max_number_solutions_;
  };
} /** ends namespace Bonmin.*/

#endif