#include <BM.hpp>

Inheritance diagram for BM_lp:

Collaboration diagram for BM_lp:

Public Member Functions
	BM_lp ()

virtual	~BM_lp ()

int &	numNlpFailed ()

virtual void	unpack_module_data (BCP_buffer &buf)
	Unpack the initial information sent to the LP process by the Tree Manager. More...

virtual void	process_message (BCP_buffer &buf)
	Process a message that has been sent by another process' user part to this process' user part. More...

virtual OsiSolverInterface *	initialize_solver_interface ()
	Create LP solver environment. More...

virtual void	load_problem (OsiSolverInterface &osi, BCP_problem_core *core, BCP_var_set &vars, BCP_cut_set &cuts)
	Load the problem specified by core, vars, and cuts into the solver interface. More...

virtual void	modify_lp_parameters (OsiSolverInterface *lp, bool in_strong_branching)

virtual BCP_solution *	test_feasibility (const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
	Evaluate and return MIP feasibility of the current solution. More...

BCP_solution *	test_feasibility_BB (const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars)

BCP_solution *	test_feasibility_hybrid (const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)

virtual void	generate_cuts_in_lp (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, BCP_vec< BCP_cut * > &new_cuts, BCP_vec< BCP_row * > &new_rows)
	Generate cuts within the LP process. More...

virtual void	cuts_to_rows (const BCP_vec< BCP_var * > &vars, BCP_vec< BCP_cut * > &cuts, BCP_vec< BCP_row * > &rows, const BCP_lp_result &lpres, BCP_object_origin origin, bool allow_multiple)
	Convert (and possibly lift) a set of cuts into corresponding rows for the current LP relaxation. More...

virtual double	compute_lower_bound (const double old_lower_bound, const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
	Compute a true lower bound for the subproblem. More...

virtual void	initialize_new_search_tree_node (const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const BCP_vec< BCP_obj_status > &vs, const BCP_vec< BCP_obj_status > &cs, BCP_vec< int > &var_changed_pos, BCP_vec< double > &var_new_bd, BCP_vec< int > &cut_changed_pos, BCP_vec< double > &cut_new_bd)
	Initializing a new search tree node. More...

virtual BCP_branching_decision	select_branching_candidates (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const BCP_lp_var_pool &local_var_pool, const BCP_lp_cut_pool &local_cut_pool, BCP_vec< BCP_lp_branching_object * > &cans, bool force_branch=false)
	Decide whether to branch or not and select a set of branching candidates if branching is decided upon. More...

BCP_branching_decision	bbBranch (OsiBranchingInformation &brInfo, BCP_vec< BCP_lp_branching_object * > &cands)

BCP_branching_decision	hybridBranch ()

void	send_pseudo_cost_update (OsiBranchingInformation &branchInfo)
	Methods invoked from bbBranch() More...

void	unpack_pseudo_costs (BCP_buffer &buf)

int	sort_objects (OsiBranchingInformation &branchInfo, Bonmin::BonChooseVariable *choose, int &branchNum)

void	clear_SB_results ()

void	collect_branch_data (OsiBranchingInformation &branchInfo, OsiSolverInterface solver, const int branchNum, BM_BranchData branchData)

void	do_distributed_SB (OsiBranchingInformation &branchInfo, OsiSolverInterface solver, const CoinWarmStart cws, const int branchNum, const int *pids, const int pidNum)

bool	isBranchFathomable (int status, double obj)

int	process_SB_results (OsiBranchingInformation &branchInfo, OsiSolverInterface solver, Bonmin::BonChooseVariable choose, OsiBranchingObject *&branchObject)

int	try_to_branch (OsiBranchingInformation &branchInfo, OsiSolverInterface solver, Bonmin::BonChooseVariable choose, OsiBranchingObject *&branchObject, bool allowVarFix)

virtual void	set_user_data_for_children (BCP_presolved_lp_brobj *best, const int selected)
	For each child create a user data object and put it into the appropriate entry in `best->user_data()`. More...

Public Member Functions inherited from BCP_lp_user
void	setOsiBabSolver (OsiBabSolver *ptr)

OsiBabSolver *	getOsiBabSolver ()

void	print (const bool ifprint, const char *format,...) const
	A method to print a message with the process id. More...

int	process_id () const
	What is the process id of the current process. More...

int	parent () const
	the process id of the parent More...

void	send_message (const int target, const BCP_buffer &buf, BCP_message_tag tag=BCP_Msg_User)
	Send a message to a particular process. More...

void	receive_message (const int sender, BCP_buffer &buf, BCP_message_tag tag=BCP_Msg_User)
	Wait for a message and receive it. More...

void	broadcast_message (const BCP_process_t proc_type, const BCP_buffer &buf)
	Broadcast the message to all processes of the given type. More...

virtual void	initialize_int_and_sos_list (std::vector< OsiObject * > &intAndSosObjects)
	Create the list of objects that can be used for branching (simple integer vars and SOS sets). More...

virtual void	modify_lp_parameters (OsiSolverInterface *lp, const int changeType, bool in_strong_branching)
	Modify parameters of the LP solver before optimization. More...

virtual void	process_lp_result (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const double old_lower_bound, double &true_lower_bound, BCP_solution &sol, BCP_vec< BCP_cut > &new_cuts, BCP_vec< BCP_row * > &new_rows, BCP_vec< BCP_var * > &new_vars, BCP_vec< BCP_col * > &new_cols)
	Process the result of an iteration. More...

virtual BCP_solution *	generate_heuristic_solution (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
	Try to generate a heuristic solution (or return one generated during cut/variable generation. More...

virtual void	restore_feasibility (const BCP_lp_result &lpres, const std::vector< double * > dual_rays, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, BCP_vec< BCP_var * > &vars_to_add, BCP_vec< BCP_col * > &cols_to_add)
	Restoring feasibility. More...

virtual void	select_vars_to_delete (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool before_fathom, BCP_vec< int > &deletable)

virtual void	select_cuts_to_delete (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool before_fathom, BCP_vec< int > &deletable)

void	reduced_cost_fixing (const double dj, const double x, const double gap, BCP_vec< BCP_var * > &vars, int &newly_changed)
	Reduced cost fixing. More...

virtual BCP_branching_object_relation	compare_branching_candidates (BCP_presolved_lp_brobj new_solved, BCP_presolved_lp_brobj old_solved)
	Decide which branching object is preferred for branching. More...

virtual void	set_actions_for_children (BCP_presolved_lp_brobj *best)
	Decide what to do with the children of the selected branching object. More...

virtual void	set_user_data_for_children (BCP_presolved_lp_brobj *best)
	Deprecated version of the previos method (it does not pass the index of the selected branching candidate). More...

void	setLpProblemPointer (BCP_lp_prob *ptr)
	Set the pointer. More...

BCP_lp_prob *	getLpProblemPointer ()
	Get the pointer. More...

double	upper_bound () const
	Return what is the best known upper bound (might be BCP_DBL_MAX) More...

bool	over_ub (double lb) const
	Return true / false depending on whether the lb argument is over the current upper bound or not. More...

int	current_phase () const
	Return the phase the algorithm is in. More...

int	current_level () const
	Return the level of the search tree node being processed. More...

int	current_index () const
	Return the internal index of the search tree node being processed. More...

int	current_iteration () const
	Return the iteration count within the search tree node being processed. More...

double	start_time () const
	Return when the LP process started. More...

BCP_user_data *	get_user_data ()
	Return a pointer to the BCP_user_data structure the user (may have) stored in this node. More...

char	get_param (const BCP_lp_par::chr_params key) const

int	get_param (const BCP_lp_par::int_params key) const

double	get_param (const BCP_lp_par::dbl_params key) const

const BCP_string &	get_param (const BCP_lp_par::str_params key) const

void	set_param (const BCP_lp_par::chr_params key, const bool val)

void	set_param (const BCP_lp_par::chr_params key, const char val)

void	set_param (const BCP_lp_par::int_params key, const int val)

void	set_param (const BCP_lp_par::dbl_params key, const double val)

void	set_param (const BCP_lp_par::str_params key, const char *val)

void	send_feasible_solution (const BCP_solution *sol)

	BCP_lp_user ()
	Being virtual, the destructor invokes the destructor for the real type of the object being deleted. More...

virtual	~BCP_lp_user ()
	Being virtual, the destructor invokes the destructor for the real type of the object being deleted. More...

void	select_nonzeros (const double first, const double last, const double etol, BCP_vec< int > &nonzeros) const
	Select all nonzero entries. More...

void	select_zeros (const double first, const double last, const double etol, BCP_vec< int > &zeros) const
	Select all zero entries. More...

void	select_positives (const double first, const double last, const double etol, BCP_vec< int > &positives) const
	Select all positive entries. More...

void	select_fractions (const double first, const double last, const double etol, BCP_vec< int > &fractions) const
	Select all fractional entries. More...

BCP_solution_generic *	test_binary (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const double etol) const
	Test whether all variables are 0/1. More...

BCP_solution_generic *	test_integral (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const double etol) const
	Test whether all variables are integer. More...

BCP_solution_generic *	test_full (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const double etol) const
	Test whether the variables specified as integers are really integer. More...

virtual void	pack_feasible_solution (BCP_buffer &buf, const BCP_solution *sol)
	Pack a MIP feasible solution into a buffer. More...

virtual void	pack_primal_solution (BCP_buffer &buf, const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
	Pack the information necessary for cut generation into the buffer. More...

virtual void	pack_dual_solution (BCP_buffer &buf, const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
	Pack the information necessary for variable generation into the buffer. More...

virtual void	display_lp_solution (const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool final_lp_solution)
	Display the result of most recent LP optimization. More...

virtual void	vars_to_cols (const BCP_vec< BCP_cut * > &cuts, BCP_vec< BCP_var * > &vars, BCP_vec< BCP_col * > &cols, const BCP_lp_result &lpres, BCP_object_origin origin, bool allow_multiple)
	Convert a set of variables into corresponding columns for the current LP relaxation. More...

virtual void	generate_vars_in_lp (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool before_fathom, BCP_vec< BCP_var * > &new_vars, BCP_vec< BCP_col * > &new_cols)
	Generate variables within the LP process. More...

virtual BCP_object_compare_result	compare_cuts (const BCP_cut c0, const BCP_cut c1)
	Compare two generated cuts. More...

virtual BCP_object_compare_result	compare_vars (const BCP_var v0, const BCP_var v1)
	Compare two generated variables. More...

virtual void	logical_fixing (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const BCP_vec< BCP_obj_status > &var_status, const BCP_vec< BCP_obj_status > &cut_status, const int var_bound_changes_since_logical_fixing, BCP_vec< int > &changed_pos, BCP_vec< double > &new_bd)
	This method provides an opportunity for the user to tighten the bounds of variables. More...

virtual int	try_to_branch (OsiBranchingInformation &branchInfo, OsiSolverInterface solver, OsiChooseVariable choose, OsiBranchingObject *&branchObject, bool allowVarFix)
	Select the "close-to-half" variables for strong branching. More...

void	branch_close_to_half (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const int to_be_selected, const double etol, BCP_vec< BCP_lp_branching_object * > &candidates)
	Select the "close-to-half" variables for strong branching. More...

void	branch_close_to_one (const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const int to_be_selected, const double etol, BCP_vec< BCP_lp_branching_object * > &candidates)
	Select the "close-to-one" variables for strong branching. More...

void	append_branching_vars (const double x, const BCP_vec< BCP_var > &vars, const BCP_vec< int > &select_pos, BCP_vec< BCP_lp_branching_object * > &candidates)
	This helper method creates branching variable candidates and appends them to `cans`. More...

virtual void	purge_slack_pool (const BCP_vec< BCP_cut * > &slack_pool, BCP_vec< int > &to_be_purged)
	Selectively purge the list of slack cuts. More...

Public Member Functions inherited from BCP_user_class
virtual	~BCP_user_class ()

Private Attributes
int	in_strong

BCP_string	ipopt_file_content

BCP_string	nl_file_content

BCP_parameter_set< BM_par >	par

BCP_buffer	bm_buf

Bonmin::BonminAmplSetup	bonmin_
	This contains the setup for running Bonmin in particular nlp solver, continuous solver, cut generators,... More...

double	integerTolerance_

int	numNlpFailed_
	A counter for how many times in a row did the NLP code fail. More...

OsiCuts	cuts_

int *	objInd_
	These are the indices of the integral (i.e., things that can be branched on) objects in the solver, sorted based on the priority of the corresponding objects. More...

int	objNum_

int *	infInd_
	Every time when branching decisions are to be made, we create 6 arrays, 3 for those objects that are infeasible and 3 for those that are feasible. More...

double *	infUseful_

int	infNum_

int *	feasInd_

double *	feasUseful_

int	feasNum_

BM_SB_result *	sbResult_
	This is where we keep the results in case of distributed strong branching. More...

BM_SB_result *	bestSbResult_
	A pointer to the entry that got selected. More...

double	node_start_time
	The time when we started to process the node. More...

BM_stats	bm_stats
	Class for collecting statistics. More...

Detailed Description

Definition at line 273 of file BM.hpp.

Constructor & Destructor Documentation

BM_lp::BM_lp ( )

Definition at line 30 of file BM_lp.cpp.

BM_lp::~BM_lp ( )

virtual

Definition at line 49 of file BM_lp.cpp.

Member Function Documentation

int& BM_lp::numNlpFailed ( )

inline

Definition at line 336 of file BM.hpp.

void BM_lp::unpack_module_data ( BCP_buffer & buf )

virtual

Unpack the initial information sent to the LP process by the Tree Manager.

This information was packed by the method BCP_tm_user::pack_module_data() invoked with BCP_ProcessType_LP as the third (target process type) argument.

Default: empty method.

update getting options directly from setup and store them in vars local to the BM_lp object

Reimplemented from BCP_lp_user.

Definition at line 35 of file BM_pack.cpp.

void BM_lp::process_message ( BCP_buffer & buf )

virtual

Process a message that has been sent by another process' user part to this process' user part.

Reimplemented from BCP_lp_user.

Definition at line 1008 of file BM_lp_branch.cpp.

OsiSolverInterface * BM_lp::initialize_solver_interface ( )

virtual

Create LP solver environment.

Create the LP solver class that will be used for solving the LP relaxations. The default implementation picks up which COIN_USE_XXX is defined and initializes an lp solver of that type. This is probably OK for most users. The only reason to override this method is to be able to choose at runtime which lp solver to instantiate (maybe even different solvers on different processors). In this case she should probably also override the pack_warmstart() and unpack_warmstart() methods in this class and in the BCP_tm_user class.

Reimplemented from BCP_lp_user.

Definition at line 62 of file BM_lp.cpp.

void BM_lp::load_problem	(	OsiSolverInterface &	osi,
		BCP_problem_core *	core,
		BCP_var_set &	vars,
		BCP_cut_set &	cuts
	)

virtual

Load the problem specified by core, vars, and cuts into the solver interface.

If the solver is an LP solver then the default is fine. If it's an NLP then the user has to do this herself.

Reimplemented from BCP_lp_user.

Definition at line 136 of file BM_lp.cpp.

void BM_lp::modify_lp_parameters	(	OsiSolverInterface *	lp,
		bool	in_strong_branching
	)

virtual

Definition at line 153 of file BM_lp.cpp.

BCP_solution * BM_lp::test_feasibility	(	const BCP_lp_result &	lp_result,
		const BCP_vec< BCP_var * > &	vars,
		const BCP_vec< BCP_cut * > &	cuts
	)

virtual

Evaluate and return MIP feasibility of the current solution.

If the solution is MIP feasible, return a solution object otherwise return a NULL pointer. The useris also welcome to heuristically generate a solution and return a pointer to that solution (although the user will have another chance (after cuts and variables are generated) to return/create heuristically generated solutions. (After all, it's quite possible that solutions are generated during cut/variable generation.)

Default: test feasibility based on the FeeasibilityTest parameter in BCP_lp_par which defults to BCP_FullTest_Feasible.

Parameters

lp_result	the result of the most recent LP optimization
vars	variables currently in the formulation
cuts	variables currently in the formulation

Reimplemented from BCP_lp_user.

Definition at line 165 of file BM_lp.cpp.

BCP_solution * BM_lp::test_feasibility_BB	(	const BCP_lp_result &	lp_result,
		const BCP_vec< BCP_var * > &	vars
	)

Definition at line 181 of file BM_lp.cpp.

BCP_solution * BM_lp::test_feasibility_hybrid	(	const BCP_lp_result &	lp_result,
		const BCP_vec< BCP_var * > &	vars,
		const BCP_vec< BCP_cut * > &	cuts
	)

Definition at line 201 of file BM_lp.cpp.

void BM_lp::generate_cuts_in_lp	(	const BCP_lp_result &	lpres,
		const BCP_vec< BCP_var * > &	vars,
		const BCP_vec< BCP_cut * > &	cuts,
		BCP_vec< BCP_cut * > &	new_cuts,
		BCP_vec< BCP_row * > &	new_rows
	)

virtual

Generate cuts within the LP process.

Sometimes too much information would need to be transmitted for cut generation (e.g., the full tableau for Gomory cuts) or the cut generation is so fast that transmitting the info would take longer than generating the cuts. In such cases it might better to generate the cuts locally. This routine provides the opportunity.
Default: empty for now. To be interfaced to Cgl.

Parameters

lpres	solution to the current LP relaxation (IN)
vars	the variabless currently in the relaxation (IN)
cuts	the cuts currently in the relaxation (IN)
new_cuts	the vector of generated cuts (OUT)
new_rows	the correspontding rows(OUT)

Reimplemented from BCP_lp_user.

Definition at line 248 of file BM_lp.cpp.

void BM_lp::cuts_to_rows	(	const BCP_vec< BCP_var * > &	vars,
		BCP_vec< BCP_cut * > &	cuts,
		BCP_vec< BCP_row * > &	rows,
		const BCP_lp_result &	lpres,
		BCP_object_origin	origin,
		bool	allow_multiple
	)

virtual

Convert (and possibly lift) a set of cuts into corresponding rows for the current LP relaxation.

Converting means computing for each cut the coefficients corresponding to each variable and creating BCP_row objects that can be added to the formulation.

This method has different purposes depending on the value of the last argument. If multiple expansion is not allowed then the user must generate a unique row for each cut. This unique row must always be the same for any given cut. This kind of operation is needed so that an LP relaxation can be exactly recreated.

On the other hand if multiple expansion is allowed then the user has (almost) free reign over what she returns. She can delete some of the cuts or append new ones (e.g., lifted ones) to the end. The result of the LP relaxation and the origin of the cuts are there to help her to make a decision about what to do. For example, she might want to lift cuts coming from the Cut Generator, but not those coming from the Cut Pool. The only requirement is that when this method returns the number of cuts and rows must be the same and the i-th row must be the unique row corresponding to the i-th cut.

Parameters

vars	the variables currently in the relaxation (IN)
cuts	the cuts to be converted (IN/OUT)
rows	the rows into which the cuts are converted (OUT)
lpres	solution to the current LP relaxation (IN)
origin	where the cuts come from (IN)
allow_multiple	whether multiple expansion, i.e., lifting, is allowed (IN)

Default: throw an exception (if this method is invoked then the user must have generated cuts and BCP has no way to know how to convert them).

Reimplemented from BCP_lp_user.

Definition at line 291 of file BM_lp.cpp.

double BM_lp::compute_lower_bound	(	const double	old_lower_bound,
		const BCP_lp_result &	lpres,
		const BCP_vec< BCP_var * > &	vars,
		const BCP_vec< BCP_cut * > &	cuts
	)

virtual

Compute a true lower bound for the subproblem.

In case column generation is done the lower bound for the subproblem might not be the same as the objective value of the current LP relaxation. Here the user has an option to return a true lower bound.
The default implementation returns the objective value of the current LP relaxation if no column generation is done, otherwise returns the current (somehow previously computed) true lower bound.

Reimplemented from BCP_lp_user.

Definition at line 313 of file BM_lp.cpp.

void BM_lp::initialize_new_search_tree_node	(	const BCP_vec< BCP_var * > &	vars,
		const BCP_vec< BCP_cut * > &	cuts,
		const BCP_vec< BCP_obj_status > &	var_status,
		const BCP_vec< BCP_obj_status > &	cut_status,
		BCP_vec< int > &	var_changed_pos,
		BCP_vec< double > &	var_new_bd,
		BCP_vec< int > &	cut_changed_pos,
		BCP_vec< double > &	cut_new_bd
	)

virtual

Initializing a new search tree node.

This method serves as hook for the user to do some preprocessing on a search tree node before the node is processed. Also, logical fixing results can be returned in the last four parameters. This might be very useful if the branching implies significant tightening.
Default: empty method.

Parameters

vars	(IN) The variables in the current formulation
cuts	(IN) The cuts in the current formulation
var_status	(IN) The stati of the variables
cut_status	(IN) The stati of the cuts
var_changed_pos	(OUT) The positions of the variables whose bounds should be tightened
var_new_bd	(OUT) The new lb/ub of those variables
cut_changed_pos	(OUT) The positions of the cuts whose bounds should be tightened
cut_new_bd	(OUT) The new lb/ub of those cuts

Reimplemented from BCP_lp_user.

Definition at line 89 of file BM_lp.cpp.

BCP_branching_decision BM_lp::select_branching_candidates	(	const BCP_lp_result &	lpres,
		const BCP_vec< BCP_var * > &	vars,
		const BCP_vec< BCP_cut * > &	cuts,
		const BCP_lp_var_pool &	local_var_pool,
		const BCP_lp_cut_pool &	local_cut_pool,
		BCP_vec< BCP_lp_branching_object * > &	cands,
		bool	force_branch = `false`
	)

virtual

Decide whether to branch or not and select a set of branching candidates if branching is decided upon.

The return value indicates what should be done: branching, continuing with the same node or abandoning the node completely.

Default: Branch if both local pools are empty. If branching is done then several (based on the StrongBranch_CloseToHalfNum and StrongBranch_CloseToOneNum parameters in BCP_lp_par) variables are selected for strong branching.

"Close-to-half" variables are those that should be integer and are at a fractional level. The measure of their fractionality is their distance from the closest integer. The most fractional variables will be selected, i.e., those that are close to half. If there are too many such variables then those with higher objective value have priority.

"Close-to-on" is interpreted in a more literal sense. It should be used only if the integer variables are binary as it select those fractional variables which are away from 1 but are still close. If there are too many such variables then those with lower objective value have priority.

Parameters

lpres	the result of the most recent LP optimization.
vars	the variables in the current formulation.
cuts	the cuts in the current formulation.
local_var_pool	the local pool that holds variables with negative reduced cost. In case of continuing with the node the best so many variables will be added to the formulation (those with the most negative reduced cost).
local_cut_pool	the local pool that holds violated cuts. In case of continuing with the node the best so many cuts will be added to the formulation (the most violated ones).
cands	the generated branching candidates.
force_branch	indicate whether to force branching regardless of the size of the local cut/var pools

Pseudo Shadow Price mode 0 - off 1 - use and multiply by strong info 2 - use

Reimplemented from BCP_lp_user.

Definition at line 31 of file BM_lp_branch.cpp.

BCP_branching_decision BM_lp::bbBranch	(	OsiBranchingInformation &	brInfo,
		BCP_vec< BCP_lp_branching_object * > &	cands
	)

Definition at line 824 of file BM_lp_branch.cpp.

BCP_branching_decision BM_lp::hybridBranch ( )

Definition at line 93 of file BM_lp_branch.cpp.

void BM_lp::send_pseudo_cost_update ( OsiBranchingInformation & branchInfo )

Methods invoked from bbBranch()

Definition at line 123 of file BM_lp_branch.cpp.

void BM_lp::unpack_pseudo_costs ( BCP_buffer & buf )

Definition at line 102 of file BM_lp_branch.cpp.

int BM_lp::sort_objects	(	OsiBranchingInformation &	branchInfo,
		Bonmin::BonChooseVariable *	choose,
		int &	branchNum
	)

Definition at line 171 of file BM_lp_branch.cpp.

void BM_lp::clear_SB_results ( )

Definition at line 312 of file BM_lp_branch.cpp.

void BM_lp::collect_branch_data	(	OsiBranchingInformation &	branchInfo,
		OsiSolverInterface *	solver,
		const int	branchNum,
		BM_BranchData *	branchData
	)

Definition at line 323 of file BM_lp_branch.cpp.

void BM_lp::do_distributed_SB	(	OsiBranchingInformation &	branchInfo,
		OsiSolverInterface *	solver,
		const CoinWarmStart *	cws,
		const int	branchNum,
		const int *	pids,
		const int	pidNum
	)

Definition at line 445 of file BM_lp_branch.cpp.

bool BM_lp::isBranchFathomable	(	int	status,
		double	obj
	)

Definition at line 537 of file BM_lp_branch.cpp.

int BM_lp::process_SB_results	(	OsiBranchingInformation &	branchInfo,
		OsiSolverInterface *	solver,
		Bonmin::BonChooseVariable *	choose,
		OsiBranchingObject *&	branchObject
	)

Definition at line 546 of file BM_lp_branch.cpp.

int BM_lp::try_to_branch	(	OsiBranchingInformation &	branchInfo,
		OsiSolverInterface *	solver,
		Bonmin::BonChooseVariable *	choose,
		OsiBranchingObject *&	branchObject,
		bool	allowVarFix
	)

Definition at line 746 of file BM_lp_branch.cpp.

void BM_lp::set_user_data_for_children	(	BCP_presolved_lp_brobj *	best,
		const int	selected
	)

virtual

For each child create a user data object and put it into the appropriate entry in best->user_data().

When this function is called the best->user_data() vector is already the right size and is filled will 0 pointers. The second argument is usefule if strong branching was done. It is the index of the branching candidate that was selected for branching (the one that's the source of best.

Reimplemented from BCP_lp_user.

Definition at line 993 of file BM_lp_branch.cpp.

Member Data Documentation

int BM_lp::in_strong

private

Definition at line 278 of file BM.hpp.

BCP_string BM_lp::ipopt_file_content

private

Definition at line 280 of file BM.hpp.

BCP_string BM_lp::nl_file_content

private

Definition at line 281 of file BM.hpp.

BCP_parameter_set<BM_par> BM_lp::par

private

Definition at line 282 of file BM.hpp.

BCP_buffer BM_lp::bm_buf

private

Definition at line 283 of file BM.hpp.

Bonmin::BonminAmplSetup BM_lp::bonmin_

private

This contains the setup for running Bonmin in particular nlp solver, continuous solver, cut generators,...

Definition at line 287 of file BM.hpp.

double BM_lp::integerTolerance_

private

Definition at line 289 of file BM.hpp.

int BM_lp::numNlpFailed_

private

A counter for how many times in a row did the NLP code fail.

When the NLP fails we branch; hopefully it'll be OK in the children. If it fails too many times in a row then we fathom the node: it's hopelessly difficult.

Definition at line 295 of file BM.hpp.

OsiCuts BM_lp::cuts_

private

Definition at line 297 of file BM.hpp.

int* BM_lp::objInd_

private

These are the indices of the integral (i.e., things that can be branched on) objects in the solver, sorted based on the priority of the corresponding objects.

Definition at line 302 of file BM.hpp.

int BM_lp::objNum_

private

Definition at line 303 of file BM.hpp.

int* BM_lp::infInd_

private

Every time when branching decisions are to be made, we create 6 arrays, 3 for those objects that are infeasible and 3 for those that are feasible.

infInd_ contains the indices of the objects (into the objects_ array of objects) that are not feasible, infUseful_ cointains their usefulness and infNum_ their number. They are ordered by their priority and within that by their usefulness (that depends on their pseudocosts, etc.). feasXXX_ contains the same for objects that are feasible, except that SOS objects are not listed there, nor variables that are fixed.

Definition at line 313 of file BM.hpp.

double* BM_lp::infUseful_

private

Definition at line 314 of file BM.hpp.

int BM_lp::infNum_

private

Definition at line 315 of file BM.hpp.

int* BM_lp::feasInd_

private

Definition at line 316 of file BM.hpp.

double* BM_lp::feasUseful_

private

Definition at line 317 of file BM.hpp.

int BM_lp::feasNum_

private

Definition at line 318 of file BM.hpp.

BM_SB_result* BM_lp::sbResult_

private

This is where we keep the results in case of distributed strong branching.

The length of the array is objNum_

Definition at line 322 of file BM.hpp.

BM_SB_result* BM_lp::bestSbResult_

private

A pointer to the entry that got selected.

Definition at line 324 of file BM.hpp.

double BM_lp::node_start_time

private

The time when we started to process the node.

Definition at line 327 of file BM.hpp.

BM_stats BM_lp::bm_stats

private

Class for collecting statistics.

Definition at line 330 of file BM.hpp.

The documentation for this class was generated from the following files:

/tmp/OS-2.10.2/Bonmin/experimental/Bcp/BM.hpp
/tmp/OS-2.10.2/Bonmin/experimental/Bcp/BM_lp.cpp
/tmp/OS-2.10.2/Bonmin/experimental/Bcp/BM_lp_branch.cpp
/tmp/OS-2.10.2/Bonmin/experimental/Bcp/BM_pack.cpp

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation