source: branches/devel/Bonmin/experimental/Bcp/BM.hpp @ 116

Last change on this file since 116 was 116, checked in by ladanyi, 13 years ago

almost identical runs

  • Property svn:eol-style set to native
  • Property svn:keywords set to "Author Date Id Revision"
File size: 8.3 KB
Line 
1// (C) Copyright International Business Machines Corporation and Carnegie Mellon University 2006
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// Authors :
6// Laszlo Ladanyi, International Business Machines Corporation
7// Pierre Bonami, Carnegie Mellon University,
8//
9// Date : 03/15/2006
10#ifndef _BM_H
11#define _BM_H
12
13#include "BCP_USER.hpp"
14#include "BCP_tm_user.hpp"
15#include "BCP_lp_user.hpp"
16
17#include "BB_cut.hpp"
18
19//#############################################################################
20
21class BM_node : public BCP_user_data {
22public:
23    /** A counter for how many times in a row did the NLP code fail. When the
24        NLP fails we branch; hopefully it'll be OK in the children. If it
25        fails too many times in a row then we fathom the node: it's hopelessly
26        difficult. */
27    int numNlpFailed_;
28public:
29    BM_node() : numNlpFailed_(0) {}
30    BM_node(BCP_buffer& buf) : numNlpFailed_(0) {
31        buf.unpack(numNlpFailed_);
32    }
33    ~BM_node() {}
34
35    inline void pack(BCP_buffer& buf) const {
36        buf.pack(numNlpFailed_);
37    }
38};
39
40//#############################################################################
41   
42enum BM_WarmStartStrategy {
43    WarmStartNone,
44    WarmStartFromRoot,
45    WarmStartFromParent
46};
47
48enum BM_BranchingStrategy {
49    BM_OsiChooseVariable,
50    BM_OsiChooseStrong
51};
52
53class BM_par {
54public:
55    enum chr_params {
56        //
57        CombinedDistanceAndPriority,
58        PureBranchAndBound,
59        PrintBranchingInfo,
60        SosWithLowPriorityMoreImportant,
61        VarWithLowPriorityMoreImportant,
62        end_of_chr_params
63    };
64    enum int_params {
65        //
66        BranchingStrategy,
67        NumNlpFailureMax,
68        WarmStartStrategy,
69        end_of_int_params
70    };
71    enum dbl_params {
72        //
73        end_of_dbl_params
74    };
75    enum str_params {
76        NL_filename,
77        IpoptParamfile,
78        //
79        end_of_str_params
80    };
81    enum str_array_params {
82        //
83        end_of_str_array_params
84    };
85};
86
87//#############################################################################
88
89class BM_tm : public BCP_tm_user {
90
91public:
92
93    /**@name Private data member */
94    BCP_string ipopt_file_content;
95    BCP_string nl_file_content;
96    BCP_parameter_set<BM_par> par;
97
98public:
99
100    /**@name Constructors and destructors */
101    //@{
102    /// Default constructor
103    BM_tm() {}
104
105    /// Default destructor
106    virtual ~BM_tm() {}
107    //@}
108
109    /**@name Packing and unpacking methods */
110    //@{
111    virtual void pack_module_data(BCP_buffer& buf, BCP_process_t ptype);
112
113    virtual void pack_cut_algo(const BCP_cut_algo* cut, BCP_buffer& buf) {
114        BB_pack_cut(cut, buf);
115    }
116    virtual BCP_cut_algo* unpack_cut_algo(BCP_buffer& buf) {
117        return BB_unpack_cut(buf);
118    }
119
120    virtual BCP_solution* unpack_feasible_solution(BCP_buffer& buf);
121
122    /// Packing of user data
123    virtual void pack_user_data(const BCP_user_data* ud, BCP_buffer& buf);
124
125    /// Unpacking of user_data
126    virtual BCP_user_data* unpack_user_data(BCP_buffer& buf);
127    //@}
128
129    /// Pass the core constraints and core variables to bcp
130    virtual void initialize_core(BCP_vec<BCP_var_core*>& vars,
131                                 BCP_vec<BCP_cut_core*>& cuts,
132                                 BCP_lp_relax*& matrix);
133
134    /** Create the set of extra variables and cuts that should be added to the
135        formulation in the root node. Also decide how variable pricing shuld be
136        done, that is, if column generation is requested in the
137        init_new_phase() method of this class then column
138        generation should be performed according to \c pricing_status.
139    */
140    virtual void
141    create_root(BCP_vec<BCP_var*>& added_vars,
142                BCP_vec<BCP_cut*>& added_cuts,
143                BCP_user_data*& user_data);
144
145    /// Print a feasible solution
146    virtual void display_feasible_solution(const BCP_solution* sol);
147
148    void readIpopt();
149
150};
151
152//#############################################################################
153
154#include <OsiAuxInfo.hpp>
155#include <OsiCuts.hpp>
156#include "BCP_lp_user.hpp"
157#include "BonOACutGenerator2.hpp"
158#include "BonAmplInterface.hpp"
159#include "BonTMINLP.hpp"
160
161class BM_lp : public BCP_lp_user
162{
163    BCP_string ipopt_file_content;
164    BCP_string nl_file_content;
165    BCP_parameter_set<BM_par> par;
166
167    OsiBabSolver babSolver_;
168    Bonmin::AmplInterface nlp;
169    CoinWarmStart* ws;
170
171    /* FIXME: gross cheating. works only for serial mode. Store the warmstart
172       informations in the lp process, do not send them over in user data or
173       anywhere. MUST be fixed. The map is indexed by the node index. */
174    std::map<int, CoinWarmStart*> warmStart;
175
176    double lower_bound_;
177    double* primal_solution_;
178
179    /** A counter for how many times in a row did the NLP code fail. When the
180        NLP fails we branch; hopefully it'll be OK in the children. If it
181        fails too many times in a row then we fathom the node: it's hopelessly
182        difficult. */
183    int numNlpFailed_;
184
185    Bonmin::OACutGenerator2* feasChecker_;
186    OsiCuts cuts_;
187
188public:
189    BM_lp();
190    virtual ~BM_lp();
191
192    inline int& numNlpFailed() {
193        return (dynamic_cast<BM_node*>(get_user_data()))->numNlpFailed_;
194    }
195
196    virtual void
197    unpack_module_data(BCP_buffer& buf);
198
199    virtual void pack_cut_algo(const BCP_cut_algo* cut, BCP_buffer& buf) {
200        BB_pack_cut(cut, buf);
201    }
202    virtual BCP_cut_algo* unpack_cut_algo(BCP_buffer& buf) {
203        return BB_unpack_cut(buf);
204    }
205
206    virtual void
207    pack_feasible_solution(BCP_buffer& buf, const BCP_solution* sol);
208
209    virtual void
210    pack_user_data(const BCP_user_data* ud, BCP_buffer& buf);
211    virtual BCP_user_data*
212    unpack_user_data(BCP_buffer& buf);
213
214    virtual void
215    process_message(BCP_buffer& buf);
216
217    virtual OsiSolverInterface *
218    initialize_solver_interface();
219
220    virtual BCP_solution*
221    test_feasibility(const BCP_lp_result& lp_result,
222                     const BCP_vec<BCP_var*>& vars,
223                     const BCP_vec<BCP_cut*>& cuts);
224    virtual void
225    generate_cuts_in_lp(const BCP_lp_result& lpres,
226                        const BCP_vec<BCP_var*>& vars,
227                        const BCP_vec<BCP_cut*>& cuts,
228                        BCP_vec<BCP_cut*>& new_cuts,
229                        BCP_vec<BCP_row*>& new_rows);
230    virtual void
231    cuts_to_rows(const BCP_vec<BCP_var*>& vars, // on what to expand
232                 BCP_vec<BCP_cut*>& cuts,       // what to expand
233                 BCP_vec<BCP_row*>& rows,       // the expanded rows
234                 // things that the user can use for lifting cuts if allowed
235                 const BCP_lp_result& lpres,
236                 BCP_object_origin origin, bool allow_multiple);
237    virtual double
238    compute_lower_bound(const double old_lower_bound,
239                        const BCP_lp_result& lpres,
240                        const BCP_vec<BCP_var*>& vars,
241                        const BCP_vec<BCP_cut*>& cuts);
242
243    virtual void 
244    initialize_new_search_tree_node(const BCP_vec<BCP_var*>& vars,
245                                    const BCP_vec<BCP_cut*>& cuts,
246                                    const BCP_vec<BCP_obj_status>& vs,
247                                    const BCP_vec<BCP_obj_status>& cs,
248                                    BCP_vec<int>& var_changed_pos,
249                                    BCP_vec<double>& var_new_bd,
250                                    BCP_vec<int>& cut_changed_pos,
251                                    BCP_vec<double>& cut_new_bd);
252
253    virtual BCP_branching_decision
254    select_branching_candidates(const BCP_lp_result& lpres,
255                                const BCP_vec<BCP_var*>& vars,
256                                const BCP_vec<BCP_cut*>& cuts,
257                                const BCP_lp_var_pool& local_var_pool,
258                                const BCP_lp_cut_pool& local_cut_pool,
259                                BCP_vec<BCP_lp_branching_object*>& cans);
260
261    virtual void
262    set_user_data_for_children(BCP_presolved_lp_brobj* best, 
263                               const int selected);
264
265    virtual void
266    modify_lp_parameters(OsiSolverInterface* lp, bool in_strong_branching);
267
268private:
269    /* There's no totalTime_ and nodeTime_. Look at the top of BM.cpp */
270    //   double totalTime_;
271    //   double nodeTime_;
272    int in_strong;
273
274};
275
276//#############################################################################
277
278#include "BCP_USER.hpp"
279
280class BM_init : public USER_initialize {
281
282public:
283
284    virtual BCP_tm_user * tm_init(BCP_tm_prob& p,
285                                  const int argnum,
286                                  const char * const * arglist);
287
288    virtual BCP_lp_user * lp_init(BCP_lp_prob& p);
289};
290
291//#############################################################################
292
293class BM_solution : public BCP_solution { 
294public:
295    double _objective;
296    BCP_vec<int> _ind;
297    BCP_vec<double> _values;
298
299public:
300    BM_solution() : _objective(0), _ind(), _values() {}
301    virtual ~BM_solution() {}
302
303    inline virtual double objective_value() const { return _objective; }
304    inline void setObjective(double obj) { _objective = obj; }
305
306    void add_entry(int i, double value) {
307        _ind.push_back(i);
308        _values.push_back(value);
309    }
310};
311
312#endif
Note: See TracBrowser for help on using the repository browser.