/home/coin/Bcp-1.0.0/Bcp/src/include/BCP_lp_user.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2000, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
00003 #ifndef _BCP_LP_USER_H
00004 #define _BCP_LP_USER_H
00005 
00006 // This file is fully prepared for doxygen.
00007 
00008 #include <vector>
00009 
00010 #include "OsiSolverInterface.hpp"
00011 #include "OsiAuxInfo.hpp"
00012 
00013 #include "BCP_USER.hpp"
00014 
00015 #include "BCP_buffer.hpp"
00016 #include "BCP_vector.hpp"
00017 #include "BCP_string.hpp"
00018 #include "BCP_warmstart.hpp"
00019 #include "BCP_solution.hpp"
00020 #include "BCP_var.hpp"
00021 #include "BCP_cut.hpp"
00022 #include "BCP_matrix.hpp"
00023 
00024 #include "BCP_enum.hpp"
00025 #include "BCP_enum_branch.hpp"
00026 
00027 #include "BCP_lp_param.hpp"
00028 #include "BCP_lp_result.hpp"
00029 #include "BCP_lp_pool.hpp"
00030 #include "BCP_lp_branch.hpp"
00031 
00032 //#############################################################################
00033 
00034 class BCP_lp_prob;
00035 
00036 //#############################################################################
00037 
00038 // All these functions are defined in BCP_lp_user.cpp, except for those that
00039 // have no counterparts in p.defaults, i.e., for those that have no builtin
00040 // pairs.
00041 
00042 //#############################################################################
00043 
00072 class BCP_lp_user {
00073 private:
00074     BCP_lp_user(const BCP_lp_user&);
00075     BCP_lp_user& operator=(const BCP_lp_user&);
00076 
00077 private:
00078     bool using_deprecated_set_user_data_for_children;
00079     BCP_lp_prob * p;
00080     OsiBabSolver* babSolver_;
00081 
00082 public:
00089 
00090     void setLpProblemPointer(BCP_lp_prob * ptr) { p = ptr; }
00092     BCP_lp_prob * getLpProblemPointer() { return p; }
00095     void setOsiBabSolver(OsiBabSolver* ptr) { babSolver_ = ptr; }
00096     OsiBabSolver* getOsiBabSolver() { return babSolver_; }
00097     
00100 
00101     double upper_bound() const;
00103     int current_phase() const;
00105     int current_level() const;
00107     int current_index() const;
00109     int current_iteration() const;
00112     BCP_user_data* get_user_data();
00117 
00118     char              get_param(const BCP_lp_par::chr_params key) const;
00120     int               get_param(const BCP_lp_par::int_params key) const;
00122     double            get_param(const BCP_lp_par::dbl_params key) const;
00124     const BCP_string& get_param(const BCP_lp_par::str_params key) const;
00125 
00127     void set_param(const BCP_lp_par::chr_params key, const bool val);
00129     void set_param(const BCP_lp_par::chr_params key, const char val);
00131     void set_param(const BCP_lp_par::int_params key, const int val);
00133     void set_param(const BCP_lp_par::dbl_params key, const double val);
00135     void set_param(const BCP_lp_par::str_params key, const char * val);
00140     void send_feasible_solution(const BCP_solution* sol);
00141     //=========================================================================
00144     BCP_lp_user() : p(0), babSolver_(0) {}
00147     virtual ~BCP_lp_user() {}
00150     //=========================================================================
00158     void
00159     select_nonzeros(const double * first, const double * last,
00160                     const double etol, BCP_vec<int>& nonzeros) const;
00163     void
00164     select_zeros(const double * first, const double * last,
00165                  const double etol, BCP_vec<int>& zeros) const;
00168     void
00169     select_positives(const double * first, const double * last,
00170                      const double etol, BCP_vec<int>& positives) const;
00173     void
00174     select_fractions(const double * first, const double * last,
00175                      const double etol, BCP_vec<int>& fractions) const;
00178     //=========================================================================
00187     virtual void
00188     unpack_module_data(BCP_buffer & buf);
00189 
00200     virtual void
00201     pack_warmstart(const BCP_warmstart* ws, BCP_buffer& buf);
00203     virtual BCP_warmstart*
00204     unpack_warmstart(BCP_buffer& buf);
00205     
00207     virtual void
00208     pack_var_algo(const BCP_var_algo* var, BCP_buffer& buf);
00210     virtual BCP_var_algo*
00211     unpack_var_algo(BCP_buffer& buf);
00212       
00214     virtual void
00215     pack_cut_algo(const BCP_cut_algo* cut, BCP_buffer& buf);
00217     virtual BCP_cut_algo*
00218     unpack_cut_algo(BCP_buffer& buf);
00219 
00221     virtual void
00222     pack_user_data(const BCP_user_data* ud, BCP_buffer& buf);
00224     virtual BCP_user_data*
00225     unpack_user_data(BCP_buffer& buf);
00228 
00229     //=========================================================================
00231     const BCP_proc_id* process_id() const;
00233     void
00234     send_message(const BCP_proc_id* const target, const BCP_buffer& buf);
00236     void
00237     broadcast_message(const BCP_process_t proc_type, const BCP_buffer& buf);
00240     virtual void
00241     process_message(BCP_buffer& buf);
00242     //=========================================================================
00253     virtual OsiSolverInterface *
00254     initialize_solver_interface();
00255     
00256     //=========================================================================
00274     virtual void
00275     initialize_new_search_tree_node(const BCP_vec<BCP_var*>& vars,
00276                                     const BCP_vec<BCP_cut*>& cuts,
00277                                     const BCP_vec<BCP_obj_status>& var_status,
00278                                     const BCP_vec<BCP_obj_status>& cut_status,
00279                                     BCP_vec<int>& var_changed_pos,
00280                                     BCP_vec<double>& var_new_bd,
00281                                     BCP_vec<int>& cut_changed_pos,
00282                                     BCP_vec<double>& cut_new_bd);
00283 
00284     //=========================================================================
00292     virtual void
00293     modify_lp_parameters(OsiSolverInterface* lp, bool in_strong_branching);
00294 
00295   //===========================================================================
00322     virtual void
00323     process_lp_result(const BCP_lp_result& lpres,
00324                       const BCP_vec<BCP_var*>& vars,
00325                       const BCP_vec<BCP_cut*>& cuts,
00326                       const double old_lower_bound,
00327                       double& true_lower_bound,
00328                       BCP_solution*& sol,
00329                       BCP_vec<BCP_cut*>& new_cuts,
00330                       BCP_vec<BCP_row*>& new_rows,
00331                       BCP_vec<BCP_var*>& new_vars,
00332                       BCP_vec<BCP_col*>& new_cols);
00333 
00334     //=========================================================================
00346     virtual double
00347     compute_lower_bound(const double old_lower_bound,
00348                         const BCP_lp_result& lpres,
00349                         const BCP_vec<BCP_var*>& vars,
00350                         const BCP_vec<BCP_cut*>& cuts);
00351        
00352     //=========================================================================
00373     virtual BCP_solution*
00374     test_feasibility(const BCP_lp_result& lp_result,
00375                      const BCP_vec<BCP_var*>& vars,
00376                      const BCP_vec<BCP_cut*>& cuts);
00387     BCP_solution_generic*
00388     test_binary(const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
00389                 const double etol) const;
00392     BCP_solution_generic*
00393     test_integral(const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
00394                   const double etol) const;
00397     BCP_solution_generic*
00398     test_full(const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
00399               const double etol) const;
00408     virtual BCP_solution*
00409     generate_heuristic_solution(const BCP_lp_result& lpres,
00410                                 const BCP_vec<BCP_var*>& vars,
00411                                 const BCP_vec<BCP_cut*>& cuts);
00414     //=========================================================================
00429     virtual void
00430     pack_feasible_solution(BCP_buffer& buf, const BCP_solution* sol);
00431 
00432     //-------------------------------------------------------------------------
00454     virtual void
00455     pack_primal_solution(BCP_buffer& buf,
00456                          const BCP_lp_result& lp_result,
00457                          const BCP_vec<BCP_var*>& vars,
00458                          const BCP_vec<BCP_cut*>& cuts);
00459     //-------------------------------------------------------------------------
00481     virtual void
00482     pack_dual_solution(BCP_buffer& buf,
00483                        const BCP_lp_result& lp_result,
00484                        const BCP_vec<BCP_var*>& vars,
00485                        const BCP_vec<BCP_cut*>& cuts);
00488     //=========================================================================
00509     virtual void
00510     display_lp_solution(const BCP_lp_result& lp_result,
00511                         const BCP_vec<BCP_var*>& vars,
00512                         const BCP_vec<BCP_cut*>& cuts,
00513                         const bool final_lp_solution);
00516     //=========================================================================
00517     // Functions related to indexed vars. Must be written if BCP is supposed to
00518     // track the indexed variables yet to be priced out, i.e., if the parameter
00519     // MaintainIndexedVarPricingList is set to true.
00520 
00528     // *FIXME* : A link here to the description of various variable types?
00535     virtual int
00536     next_indexed_var(int prev_index);
00543     virtual BCP_var_indexed*
00544     create_indexed_var(int index, const BCP_vec<BCP_cut*>& cuts,
00545                        BCP_col& col);
00548     //=========================================================================
00560     virtual void
00561     restore_feasibility(const BCP_lp_result& lpres,
00562                         const std::vector<double*> dual_rays,
00563                         const BCP_vec<BCP_var*>& vars,
00564                         const BCP_vec<BCP_cut*>& cuts,
00565                         BCP_vec<BCP_var*>& vars_to_add,
00566                         BCP_vec<BCP_col*>& cols_to_add);
00567 
00568     //=========================================================================
00604     virtual void
00605     cuts_to_rows(const BCP_vec<BCP_var*>& vars, // on what to expand
00606                  BCP_vec<BCP_cut*>& cuts,       // what to expand
00607                  BCP_vec<BCP_row*>& rows,       // the expanded rows
00608                  // things that the user can use for lifting cuts if allowed
00609                  const BCP_lp_result& lpres,
00610                  BCP_object_origin origin, bool allow_multiple);
00611     //-------------------------------------------------------------------------
00632     virtual void
00633     vars_to_cols(const BCP_vec<BCP_cut*>& cuts, // on what to expand
00634                  BCP_vec<BCP_var*>& vars,       // what to expand
00635                  BCP_vec<BCP_col*>& cols,       // the expanded cols
00636                  // things that the user can use for lifting vars if allowed
00637                  const BCP_lp_result& lpres,
00638                  BCP_object_origin origin, bool allow_multiple);
00641     //=========================================================================
00657     virtual void
00658     generate_cuts_in_lp(const BCP_lp_result& lpres,
00659                         const BCP_vec<BCP_var*>& vars,
00660                         const BCP_vec<BCP_cut*>& cuts,
00661                         BCP_vec<BCP_cut*>& new_cuts,
00662                         BCP_vec<BCP_row*>& new_rows);
00663     //-------------------------------------------------------------------------
00680     virtual void
00681     generate_vars_in_lp(const BCP_lp_result& lpres,
00682                         const BCP_vec<BCP_var*>& vars,
00683                         const BCP_vec<BCP_cut*>& cuts,
00684                         const bool before_fathom,
00685                         BCP_vec<BCP_var*>& new_vars,
00686                         BCP_vec<BCP_col*>& new_cols);
00687     //-------------------------------------------------------------------------
00695     virtual BCP_object_compare_result
00696     compare_cuts(const BCP_cut* c0, const BCP_cut* c1);
00697     //-------------------------------------------------------------------------
00706     virtual BCP_object_compare_result
00707     compare_vars(const BCP_var* v0, const BCP_var* v1);
00710     //=========================================================================
00711     virtual void
00712     select_vars_to_delete(const BCP_lp_result& lpres,
00713                           const BCP_vec<BCP_var*>& vars,
00714                           const BCP_vec<BCP_cut*>& cuts,
00715                           const bool before_fathom,
00716                           BCP_vec<int>& deletable);
00717     virtual void
00718     select_cuts_to_delete(const BCP_lp_result& lpres,
00719                           const BCP_vec<BCP_var*>& vars,
00720                           const BCP_vec<BCP_cut*>& cuts,
00721                           const bool before_fathom,
00722                           BCP_vec<int>& deletable);
00723     //=========================================================================
00741     virtual void
00742     logical_fixing(const BCP_lp_result& lpres,
00743                    const BCP_vec<BCP_var*>& vars,
00744                    const BCP_vec<BCP_cut*>& cuts,
00745                    const BCP_vec<BCP_obj_status>& var_status,
00746                    const BCP_vec<BCP_obj_status>& cut_status,
00747                    const int var_bound_changes_since_logical_fixing,
00748                    BCP_vec<int>& changed_pos, BCP_vec<double>& new_bd);
00753     void
00754     reduced_cost_fixing(const double* dj, const double* x, const double gap,
00755                         BCP_vec<BCP_var*>& vars, int& newly_changed);
00756 
00757     //=========================================================================
00794     virtual BCP_branching_decision
00795     select_branching_candidates(const BCP_lp_result& lpres,
00796                                 const BCP_vec<BCP_var*>& vars,
00797                                 const BCP_vec<BCP_cut*>& cuts,
00798                                 const BCP_lp_var_pool& local_var_pool,
00799                                 const BCP_lp_cut_pool& local_cut_pool,
00800                                 BCP_vec<BCP_lp_branching_object*>& cands);
00807     void
00808     branch_close_to_half(const BCP_lp_result& lpres,
00809                          const BCP_vec<BCP_var*>& vars,
00810                          const int to_be_selected,
00811                          const double etol,
00812                          BCP_vec<BCP_lp_branching_object*>& candidates);
00817     void
00818     branch_close_to_one(const BCP_lp_result& lpres,
00819                         const BCP_vec<BCP_var*>& vars,
00820                         const int to_be_selected,
00821                         const double etol,
00822                         BCP_vec<BCP_lp_branching_object*>& candidates);
00827     void
00828     append_branching_vars(const double* x,
00829                           const BCP_vec<BCP_var*>& vars,
00830                           const BCP_vec<int>& select_pos,
00831                           BCP_vec<BCP_lp_branching_object*>& candidates);
00848     virtual BCP_branching_object_relation
00849     compare_branching_candidates(BCP_presolved_lp_brobj* new_solved,
00850                                  BCP_presolved_lp_brobj* old_solved);
00870     virtual void
00871     set_actions_for_children(BCP_presolved_lp_brobj* best);
00872 
00881     virtual void
00882     set_user_data_for_children(BCP_presolved_lp_brobj* best, 
00883                                const int selected);
00887     virtual void
00888     set_user_data_for_children(BCP_presolved_lp_brobj* best);
00891     //=========================================================================
00892     // purging the slack cut pool (candidates for branching on cut)
00914     virtual void
00915     purge_slack_pool(const BCP_vec<BCP_cut*>& slack_pool,
00916                      BCP_vec<int>& to_be_purged);
00918 };
00919 
00920 //#############################################################################
00921 
00922 #endif

Generated on Wed Aug 22 03:00:53 2007 for coin-Bcp by  doxygen 1.4.7