source: stable/0.1/Bonmin/experimental/Bcp/BM.hpp @ 52

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

Added warmstart

  • Property svn:eol-style set to native
  • Property svn:keywords set to "Author Date Id Revision"
File size: 9.1 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 "BM_var.hpp"
18#include "BB_cut.hpp"
19
20//#############################################################################
21
22class BM_node : public BCP_user_data {
23public:
24    /** A counter for how many times in a row did the NLP code fail. When the
25        NLP fails we branch; hopefully it'll be OK in the children. If it
26        fails too many times in a row then we fathom the node: it's hopelessly
27        difficult. */
28    int numNlpFailed_;
29public:
30    BM_node() : numNlpFailed_(0) {}
31    BM_node(BCP_buffer& buf) : numNlpFailed_(0) {
32        buf.unpack(numNlpFailed_);
33    }
34    ~BM_node() {}
35
36    inline void pack(BCP_buffer& buf) const {
37        buf.pack(numNlpFailed_);
38    }
39};
40
41//#############################################################################
42
43enum BM_WarmStartStrategy {
44    WarmStartNone,
45    WarmStartFromRoot,
46    WarmStartFromParent
47};
48
49class BM_par {
50public:
51    enum chr_params {
52        //
53        BranchOnSos,
54        CombinedDistanceAndPriority,
55        PureBranchAndBound,
56        PrintBranchingInfo,
57        SosWithLowPriorityMoreImportant,
58        VarWithLowPriorityMoreImportant,
59        end_of_chr_params
60    };
61    enum int_params {
62        //
63        NumNlpFailureMax,
64        WarmStartStrategy,
65        end_of_int_params
66    };
67    enum dbl_params {
68        //
69        end_of_dbl_params
70    };
71    enum str_params {
72        NL_filename,
73        IpoptParamfile,
74        //
75        end_of_str_params
76    };
77    enum str_array_params {
78        //
79        end_of_str_array_params
80    };
81};
82
83//#############################################################################
84
85class BM_tm : public BCP_tm_user {
86
87public:
88
89    /**@name Private data member */
90    BCP_string ipopt_file_content;
91    BCP_string nl_file_content;
92    BCP_parameter_set<BM_par> par;
93
94public:
95
96    /**@name Constructors and destructors */
97    //@{
98    /// Default constructor
99    BM_tm() {}
100
101    /// Default destructor
102    virtual ~BM_tm() {}
103    //@}
104
105    /**@name Packing and unpacking methods */
106    //@{
107    virtual void pack_module_data(BCP_buffer& buf, BCP_process_t ptype);
108
109    virtual void pack_var_algo(const BCP_var_algo* var, BCP_buffer& buf) {
110        BM_pack_var(var, buf);
111    }
112    virtual BCP_var_algo* unpack_var_algo(BCP_buffer& buf) {
113        return BM_unpack_var(buf);
114    }
115
116    virtual void pack_cut_algo(const BCP_cut_algo* cut, BCP_buffer& buf) {
117        BB_pack_cut(cut, buf);
118    }
119    virtual BCP_cut_algo* unpack_cut_algo(BCP_buffer& buf) {
120        return BB_unpack_cut(buf);
121    }
122
123    virtual BCP_solution* unpack_feasible_solution(BCP_buffer& buf);
124
125    /// Packing of user data
126    virtual void pack_user_data(const BCP_user_data* ud, BCP_buffer& buf);
127
128    /// Unpacking of user_data
129    virtual BCP_user_data* unpack_user_data(BCP_buffer& buf);
130    //@}
131
132    /// Pass the core constraints and core variables to bcp
133    virtual void initialize_core(BCP_vec<BCP_var_core*>& vars,
134                                 BCP_vec<BCP_cut_core*>& cuts,
135                                 BCP_lp_relax*& matrix);
136
137    /** Create the set of extra variables and cuts that should be added to the
138        formulation in the root node. Also decide how variable pricing shuld be
139        done, that is, if column generation is requested in the
140        init_new_phase() method of this class then column
141        generation should be performed according to \c pricing_status.
142    */
143    virtual void
144    create_root(BCP_vec<BCP_var*>& added_vars,
145                BCP_vec<BCP_cut*>& added_cuts,
146                BCP_user_data*& user_data,
147                BCP_pricing_status& pricing_status);
148
149    /// Print a feasible solution
150    virtual void display_feasible_solution(const BCP_solution* sol);
151
152    void readIpopt();
153
154};
155
156//#############################################################################
157
158#include <OsiAuxInfo.hpp>
159#include <OsiCuts.hpp>
160#include "BCP_lp_user.hpp"
161#include "IpCbcOACutGenerator2.hpp"
162#include "BonminAmplInterface.hpp"
163class BM_lp : public BCP_lp_user
164{
165    struct BmSosInfo {
166        int length;
167        int type; // 0: type 1  ---- 1: type 2
168        int priority;
169        int *indices;
170        double *weights;
171        int first;
172        int last;
173        BmSosInfo(const TMINLP::SosInfo * sosinfo, int i);
174        ~BmSosInfo() {
175            delete[] indices;
176            delete[] weights;
177        }
178    };
179    std::vector<BmSosInfo*> sos;
180    void setSosFrom(const TMINLP::SosInfo * sosinfo);
181               
182    BCP_string ipopt_file_content;
183    BCP_string nl_file_content;
184    BCP_parameter_set<BM_par> par;
185
186    OsiBabSolver babSolver_;
187    BonminAmplInterface nlp;
188    CoinWarmStart* ws;
189
190    double lower_bound_;
191    double* primal_solution_;
192
193    /** A counter for how many times in a row did the NLP code fail. When the
194        NLP fails we branch; hopefully it'll be OK in the children. If it
195        fails too many times in a row then we fathom the node: it's hopelessly
196        difficult. */
197    int numNlpFailed_;
198
199    /** If pure branch and bound is done then for each fractional variable
200        that ought to be integer we multiply it's distance from integrality
201        with it's priority and choose the var with the highest value */
202    double* branching_priority_;
203
204    IpCbcOACutGenerator2* feasChecker_;
205    OsiCuts cuts_;
206
207public:
208    BM_lp();
209    virtual ~BM_lp();
210
211    inline int& numNlpFailed() {
212        return (dynamic_cast<BM_node*>(get_user_data()))->numNlpFailed_;
213    }
214
215    virtual void
216    unpack_module_data(BCP_buffer& buf);
217
218    virtual void pack_var_algo(const BCP_var_algo* var, BCP_buffer& buf) {
219        BM_pack_var(var, buf);
220    }
221    virtual BCP_var_algo* unpack_var_algo(BCP_buffer& buf) {
222        return BM_unpack_var(buf);
223    }
224
225    virtual void pack_cut_algo(const BCP_cut_algo* cut, BCP_buffer& buf) {
226        BB_pack_cut(cut, buf);
227    }
228    virtual BCP_cut_algo* unpack_cut_algo(BCP_buffer& buf) {
229        return BB_unpack_cut(buf);
230    }
231
232    virtual void
233    pack_feasible_solution(BCP_buffer& buf, const BCP_solution* sol);
234
235    virtual void
236    pack_user_data(const BCP_user_data* ud, BCP_buffer& buf);
237    virtual BCP_user_data*
238    unpack_user_data(BCP_buffer& buf);
239
240    virtual void
241    process_message(BCP_buffer& buf);
242
243    virtual OsiSolverInterface *
244    initialize_solver_interface();
245
246    virtual BCP_solution*
247    test_feasibility(const BCP_lp_result& lp_result,
248                     const BCP_vec<BCP_var*>& vars,
249                     const BCP_vec<BCP_cut*>& cuts);
250    virtual void
251    generate_cuts_in_lp(const BCP_lp_result& lpres,
252                        const BCP_vec<BCP_var*>& vars,
253                        const BCP_vec<BCP_cut*>& cuts,
254                        BCP_vec<BCP_cut*>& new_cuts,
255                        BCP_vec<BCP_row*>& new_rows);
256    virtual void
257    cuts_to_rows(const BCP_vec<BCP_var*>& vars, // on what to expand
258                 BCP_vec<BCP_cut*>& cuts,       // what to expand
259                 BCP_vec<BCP_row*>& rows,       // the expanded rows
260                 // things that the user can use for lifting cuts if allowed
261                 const BCP_lp_result& lpres,
262                 BCP_object_origin origin, bool allow_multiple);
263    virtual void
264    vars_to_cols(const BCP_vec<BCP_cut*>& cuts,
265                 BCP_vec<BCP_var*>& vars,
266                 BCP_vec<BCP_col*>& cols,
267                 const BCP_lp_result& lpres,
268                 BCP_object_origin origin, bool allow_multiple);
269    virtual double
270    compute_lower_bound(const double old_lower_bound,
271                        const BCP_lp_result& lpres,
272                        const BCP_vec<BCP_var*>& vars,
273                        const BCP_vec<BCP_cut*>& cuts);
274
275    virtual void 
276    initialize_new_search_tree_node(const BCP_vec<BCP_var*>& vars,
277                                    const BCP_vec<BCP_cut*>& cuts,
278                                    const BCP_vec<BCP_obj_status>& vs,
279                                    const BCP_vec<BCP_obj_status>& cs,
280                                    BCP_vec<int>& var_changed_pos,
281                                    BCP_vec<double>& var_new_bd,
282                                    BCP_vec<int>& cut_changed_pos,
283                                    BCP_vec<double>& cut_new_bd);
284
285    virtual BCP_branching_decision
286    select_branching_candidates(const BCP_lp_result& lpres,
287                                const BCP_vec<BCP_var*>& vars,
288                                const BCP_vec<BCP_cut*>& cuts,
289                                const BCP_lp_var_pool& local_var_pool,
290                                const BCP_lp_cut_pool& local_cut_pool,
291                                BCP_vec<BCP_lp_branching_object*>& cans);
292
293    virtual void
294    set_user_data_for_children(BCP_presolved_lp_brobj* best, 
295                               const int selected);
296
297    virtual void
298    modify_lp_parameters(OsiSolverInterface* lp, bool in_strong_branching);
299
300private:
301    /* There's no totalTime_ and nodeTime_. Look at the top of BM.cpp */
302    //   double totalTime_;
303    //   double nodeTime_;
304    int in_strong;
305
306};
307
308//#############################################################################
309
310#include "BCP_USER.hpp"
311
312class BM_init : public USER_initialize {
313
314public:
315
316    virtual BCP_tm_user * tm_init(BCP_tm_prob& p,
317                                  const int argnum,
318                                  const char * const * arglist);
319
320    virtual BCP_lp_user * lp_init(BCP_lp_prob& p);
321};
322
323//#############################################################################
324
325class BM_solution : public BCP_solution { 
326public:
327    double _objective;
328    BCP_vec<int> _ind;
329    BCP_vec<double> _values;
330
331public:
332    BM_solution() : _objective(0), _ind(), _values() {}
333    virtual ~BM_solution() {}
334
335    inline virtual double objective_value() const { return _objective; }
336    inline void setObjective(double obj) { _objective = obj; }
337
338    void add_entry(int i, double value) {
339        _ind.push_back(i);
340        _values.push_back(value);
341    }
342};
343
344#endif
Note: See TracBrowser for help on using the repository browser.