MinlpBCP Class Reference

A branch-cut-and-price algorithm for solving a nonconvex MINLP problem. More...

#include <bcp.h>

Inheritance diagram for MinlpBCP:

[legend]

Collaboration diagram for MinlpBCP:

[legend]

List of all members.

Classes
struct	LagSolveStatus_s
Public Member Functions
	MinlpBCP (Pointer< MinlpProblem > orig_prob_, Pointer< MinlpProblem > split_prob_, Pointer< LinearRelax > linear_relax_, bool is_gams_prob=false, double closeval_tol_=0., Pointer< dvector > diam_=NULL, Pointer< Param > param_=NULL, Pointer< ostream > out_solver_p_=out_out_p, Pointer< ostream > out_solver_log_p_=out_log_p)
virtual	~MinlpBCP ()
void	set_quad_relax (Pointer< MinlpProblem > quad_prob_)
void	set_convex_prob (Pointer< MinlpProblem > convex_prob_, const Pointer< dvector > &sol_C_=NULL, bool sol_C_is_solution_=false)
void	set_reform (Pointer< Reformulation > reform_, Pointer< dvector > sol_C_, bool sol_C_is_solution_)
void	set_reform (Pointer< Reformulation > reform_)
void	set_linear_relax (Pointer< LinearRelax > linrelax_)
void	set_problem_is_convex (bool prob_is_convex_)
void	set_MINLPData (Pointer< MINLPData > minlpdata_)
void	set_timer (Pointer< Timer > timer_)
int	solve ()
	Calls the branch-cut-and-price algorithm.
int	solve (dvector &start)
	Solves the problem for a starting point.
Private Types
enum	t_bound_type { RMP_bound, NLP_bound, LP_bound, LP_RMP_bound, stop_bound }
enum	{ BranchCut }
enum	{ BinSubdiv, CostSubdivLag, CostSubdivNewton, BisectSubdiv, RMPSubdiv, ViolSubdiv }
enum	{ BestBound, UnfixedDiscrete }
typedef struct MinlpBCP::LagSolveStatus_s	LagSolveStatus
Private Member Functions
double	start_bb ()
	starts the BB-algorithm
bool	add_sol_candidate (const dvector &x)
int	find_sol_candidates (Pointer< MinlpNode > node)
	Finds solution candidates using a heuristic defined by heu_type.
int	preswitching (Pointer< MinlpNode > node)
void	init ()
	Initializes the BCP-algorithm.
void	init_block_problems ()
	Initializes the block problems.
void	clean_sub_problems ()
pair< list< ExtremePoint > ::iterator, bool >	add_ExtremePoint (const dvector &w, int k, Pointer< MinlpNode >=NULL)
	Adds a point to the RMP point pool.
int	init_ExtremePoints (Pointer< MinlpNode > node)
	Initializes the RMP of the root node.
int	primal_init_ExtremePoints (const dvector &x, Pointer< MinlpNode > node)
int	dual_init_ExtremePoints (Pointer< MinlpNode > node)
void	prune_ExtremePoints (multimap< double, Pointer< MinlpNode > > &bb_tree)
	Removes RMP points, which are not used by any node anymore.
void	project_ExtremePoints (dvector &x, Pointer< MinlpNode > node)
bool	boxreduce (Pointer< MinlpNode > node, int index, IntervalReduction::which_bound_type which_bound)
	Reducing the box and updating the relaxation after subdivision.
bool	feasibility_check (Pointer< MinlpNode > node)
	Checks by interval arithmetic whether the box in node is feasible by evaluation the constraints over the box.
multimap< double, Pointer < MinlpNode > >::iterator	select_node ()
int	set_low_bound (Pointer< MinlpNode > node)
	Computes a lower bound of the objective value according to the bound_type: RMP_bound, NLP_bound, LP_bound.
pair< bool, double >	improve_bound (Pointer< MinlpNode > node)
	Improves a lower bound without subdivision.
int	set_NLP_bound (Pointer< MinlpNode > node, bool improve=false)
int	set_RMP_bound (Pointer< MinlpNode > node)
int	set_LP_bound (Pointer< MinlpNode > node)
int	set_LP_RMP_bound (Pointer< MinlpNode > node)
int	improve_LP_bound (Pointer< MinlpNode > node)
int	update_subdiv_bound (int k, int i, Pointer< MinlpNode > node)
	Improves a lower bound after subdivision.
int	subdivide (list< Pointer< MinlpNode > > &nodes, Pointer< MinlpNode > node)
	Subdivides the feasible set into several sets according to the subdiv_type: BinSubdiv, CostSubdiv.
int	bin_subdiv (list< Pointer< MinlpNode > > &nodes, int &subdiv_var, Pointer< MinlpNode > node)
	subdivision according to violated binary constraints
void	cost_subdiv (list< Pointer< MinlpNode > > &nodes, int &subdiv_var, Pointer< MinlpNode > node)
	subdivision according to pseudo costs I
void	bisect_subdiv (list< Pointer< MinlpNode > > &nodes, int &subdiv_var, Pointer< MinlpNode > node)
	subdivision according to pseudo costs II
void	viol_subdiv (list< Pointer< MinlpNode > > &nodes, int &subdiv_var, Pointer< MinlpNode > node)
	subdivision according to constraint violation
void	rect_subdiv (list< Pointer< MinlpNode > > &nodes, Pointer< MinlpNode > node, int k, int i, double cut)
	branching at variable i of block k w.r.t the cut-value
void	init_lag_problems (Pointer< MinlpNode > node)
	Builds the Lagrangian sub-problems with empty objective function.
void	update_lag_problems (const dvector &dual_point)
	Updates the objective functions of the lagrangian subproblems.
void	update_lag_problem (int k, const dvector &a)
void	solve_lag_problem (LagSolveStatus &status, int k, Pointer< MinlpNode > node, Pointer< SepQcFunc > temp_cut=NULL)
	Solves the k-th Lagrangian sub-problem and adds Lagrangian cuts.
int	conv_rate_check (double val)
	Checks the actual iteration.
void	mem_check ()
Private Attributes
Pointer< dvector >	sol_C
bool	sol_C_is_solution
bool	prob_is_convex
	Indicated whether original problem is convex.
Pointer< MinlpProblem >	quad_prob
	The quadratic relaxation of the problem.
vector< Pointer< MinlpProblem > >	block_prob
	The original problem for each block (P_k), without objective function.
vector< Pointer< MinlpProblem > >	block_convex_prob
	The convexification for each block (C_k), without objective function.
vector< list< ExtremePoint > >	ExtremePoints
	A pool of extreme points and columns for each block.
vector< Pointer< MinlpProblem > >	block_sub_convex_prob
Pointer< MinlpProblem >	sub_convex_prob
vector< Pointer< MinlpProblem > >	lag_problem
	The Lagrangian Subproblems for each block.
Pointer< ColumnGenerator >	colgen
multimap< double, Pointer < MinlpNode > >	bb_tree
	A second Branch-and-Bound tree.
Pointer< MinlpNode >	current_node
	The current node.
double	gap_tol
	gap tolerance
double	bound_impr_tol
	bound improvement tolerance
bool	intgrad_cuts
	Indicates, whether we use IntervalGradientCuts.
IntervalGradientCutGenerator	intgrad_cutgen
LinearizedConCutGenerator	linconcutgen
bool	mip_cuts
	Indicates, whether we want to derive cuts from the LP relaxation.
Pointer< LagHeu >	lagheu
t_bound_type	pre_bound_type
t_bound_type	maj_bound_type
t_bound_type	bound_type
	The current bound type.
enum MinlpBCP:: { ... }	lagsolve_type
enum MinlpBCP:: { ... }	subdiv_type
int	subdiv_discrete_emphasis
enum MinlpBCP:: { ... }	nodeselect_type
int	upper_bound_effort_level
int	pre_bb_max_iter
	Do a preprocessing Branch & Bound.
bool	lag_cuts
	Indicates, whether we should add Lagrangian cuts.
int	bound_failed
	The number of computations of NLP-bounds or RMP-bounds, which failed, while (R[U]) was solved.
int	bound_computed
double	bound_time
double	init_RMP_time
int	lagprob_solves
	The number of lagrangian subproblems, we (tried to) solved.
double	find_solcand_time
int	nr_solcand_found
double	subdiv_time
int	update_ExtremePoints_count
Pointer< Timer >	timer
double	max_time
bool	is_maxcut
Pointer< IntervalReduction >	intervalreduction
int	nr_subdiv_contvar
	number of branchings on continuous variables.
int	nr_subdiv_bisect
	number of subdivision by bisection.
double	conv_rate_cntrl_stopping_rho
	If conv_rate_cntrl is set and improvement in last minor_iter iterations is less than stopping_rho * rel_imp1, check() breakes the solving process.
int	conv_rate_cntrl_minor_iter
	The number of minor iterations for the convergence rate control.
double	conv_rate_cntrl_last_major_val
	The value in the last major iteration.
double	conv_rate_cntrl_last_val
	The value in the last iteration.
double	conv_rate_cntrl_first_major_val
	The value in the first iteration.
double	conv_rate_cntrl_max_rel_improvement
	First relative improvement.
int	conv_rate_cntrl_improve_iter
	Counter for the number of iterations with improvements (serious steps).
int	mem_limit
Friends
class	ColumnGenerator
class	MinlpNode

Detailed Description

A branch-cut-and-price algorithm for solving a nonconvex MINLP problem.

Parameters:

	MinlpBCP	max iter options integer $ 0$ default 10000 level 2 The maximum number of Branch and Bound iterations.
	MinlpBCP	max time options double $ 0$ default 3600 level 2 The maximum amount of seconds, which can be used by the preprocessing and MinlpBCP.
	MinlpBCP	gap tol options double $ 0$ default 0.01 level 2 Gap tolerance. Stops, if gap between upper and lower bound is smaller than gap tol.
	Lagrangian	cuts options 0, 1 default 1 level 0 Indicates, whether to use Lagrangian cuts. If you use RMP bounds, you would be well advised to let them switched on.
	BCP	bound type options NLP,RMP,LP,LP-RMP,stop default LP level 1 Determines, which bounding method to use. Options other then LP or NLP are likely to fail. {itemize} NLP: Using the convex relaxation (Cext). LP: Using the linear relaxation (R). RMP: Does Lagrangian decomposition based on a $$, computed by an inner approximation. LP-RMP: Using LP bounds but constructs and solves also the inner approximation. stop: After the first BCP phase (preprocessing, RMP bounds), subdivision and bound computation is stopped, only upper bounds for the remaining nodes are computed. {itemize}
	BCP	preprocess max iter options integer $ 0$ default 0 level 0 The maximum number of BCP preprocessing iterations.
	BCP	subdiv type options Binary, Cost, Bisection, Violation default Violation level 2 The branching method. First, binary (integer) subdivision is tried. If all integers are fixed, further actions depend on the value of this parameter. {itemize} Binary: When all integer variables are fixed, no further subdivision is performed. Cost: Tries to subdivide w.r.t. a variable, for which a maximum improvement of the Lagrangian can be achieved. (not tested) Bisection: Subdivides w.r.t. a variables, which boxdiameter is maximal. Violation: Tries to subdivide w.r.t. a variable, which can minimize the violation of the reference point. If it fails to find a variable, bisection is used. {itemize}
	Subdivision	on discrete emphasis options 1, 2 default 1 level 2 If set to 1, discrete variables are only chosen for subdivision, if integer-infeasible or the subdiv type is Binary. If set to 2, discrete variables are also chosen for subdivision, if they are already integer-feasible.
	BCP	node selection typ options best bound, unfixed discrete default unfixed discrete level 2 The method that selects the next node from the branch-and-bound tree. {itemize} best bound: Selects node with lowest lower bound. unfixed discrete: Selects node which does not have all discrete variables fixed yet (and among them one with the lowest lower bound). {itemize}
	IntervalGradient	cuts options 0, 1 default 0 level 1 Enables (relaxed) IntervalGradientCuts.
	MIP	cuts options 0, 1 default 1 level 1 Indicates, whether to derive cuts from the LP relaxation by considering the binary restrictions in the original problem. Currently, MixedIntegerRoundingCuts from the Cgl are used.
	maxcut	options 0, 1 default 0 Indicates, whether the problem is a MaxCut problem.
	BCP	upper bound effort options $0, 1, 2, 3$ default 0 (2 for MaxCut) level 0 How much effort to spend in computation of upper bounds. {itemize} [$ 0$] performs just local optimization, starting from the reference point. [$ 1$] applies preswitching as well. {itemize}
	LagHeu	options first, second, second b, Simulated Annealing default none level 0 Which Lagrangian Heuristic to use to compute upper bounds. Only available, when RMP bounds are used. "first" means the first one, we implemented, "second" is the third one, also called LagHeu2, "second b" is a modification of LagHeu2.
	stopping	rho options $ 0$ default 0.1 For the convergence rate control. If the relative improvement over the last iterations falls under $$ times the first relative improvement, the convergence rate is considered as too small.
	minor	iterations options integer default 5 How many iterations to consider for the computation of one relative improvement.
	BCP	IntervalReduction level 1 options 0, 1 default 1 If we should apply boxreduction based on interval arithmetic after branching.
	Memory	limit level 2 options $ 0$ default 0 The amount of totally allocated memory (swaped and non-swaped) in Megabytes, LaGO is allowed to use. If set to 0, no limit is used. When the limit is exceeded in the Branch and Cut, nodes from the branching tree are pruned until LaGO consumes less than 95% of the limit on memory or only one node is left in the tree.

Definition at line 158 of file bcp.h.

Member Typedef Documentation

typedef struct MinlpBCP::LagSolveStatus_s MinlpBCP::LagSolveStatus [private]

Member Enumeration Documentation

enum MinlpBCP::t_bound_type [private]

Enumerator:

RMP_bound
NLP_bound
LP_bound
LP_RMP_bound
stop_bound

Definition at line 269 of file bcp.h.

anonymous enum [private]

Enumerator:

BranchCut

Definition at line 276 of file bcp.h.

anonymous enum [private]

Enumerator:

BinSubdiv
CostSubdivLag
CostSubdivNewton
BisectSubdiv
RMPSubdiv
ViolSubdiv

Definition at line 278 of file bcp.h.

anonymous enum [private]

Enumerator:

BestBound
UnfixedDiscrete

Definition at line 282 of file bcp.h.

Constructor & Destructor Documentation

MinlpBCP::MinlpBCP	(	Pointer< MinlpProblem >	orig_prob_,
		Pointer< MinlpProblem >	split_prob_,
		Pointer< LinearRelax >	linear_relax_,
		bool	is_gams_prob = `false`,
		double	closeval_tol_ = `0.`,
		Pointer< dvector >	diam_ = `NULL`,
		Pointer< Param >	param_ = `NULL`,
		Pointer< ostream >	out_solver_p_ = `out_out_p`,
		Pointer< ostream >	out_solver_log_p_ = `out_log_p`
	)

virtual MinlpBCP::~MinlpBCP ( ) [virtual]

Member Function Documentation

double MinlpBCP::start_bb ( ) [private]

starts the BB-algorithm

Parameters:

bb_tree

A Branch-and-Bound tree

bool MinlpBCP::add_sol_candidate ( const dvector & x ) [private, virtual]

Reimplemented from RelaxationSolver.

int MinlpBCP::find_sol_candidates ( Pointer< MinlpNode > node ) [private]

Finds solution candidates using a heuristic defined by heu_type.

Parameters:

	node	The MINLP node.
	sol_point	The solution point.

int MinlpBCP::preswitching ( Pointer< MinlpNode > node ) [private]

void MinlpBCP::init ( ) [private]

Initializes the BCP-algorithm.

void MinlpBCP::init_block_problems ( ) [private]

Initializes the block problems.

void MinlpBCP::clean_sub_problems ( ) [private]

Reimplemented from RelaxationSolver.

pair<list<ExtremePoint>::iterator, bool> MinlpBCP::add_ExtremePoint	(	const dvector &	w,
		int	k,
		Pointer< MinlpNode >	= `NULL`
	)			`[private]`

Adds a point to the RMP point pool.

Parameters:

	w	The RMP point.
	k	The index of the block.

Returns:: The iterator to the RMP point in the pool and true, if it was a new point. False, else.

int MinlpBCP::init_ExtremePoints ( Pointer< MinlpNode > node ) [private]

Initializes the RMP of the root node.

int MinlpBCP::primal_init_ExtremePoints	(	const dvector &	x,
		Pointer< MinlpNode >	node
	)			`[private]`

int MinlpBCP::dual_init_ExtremePoints ( Pointer< MinlpNode > node ) [private]

void MinlpBCP::prune_ExtremePoints ( multimap< double, Pointer< MinlpNode > > & bb_tree ) [private]

Removes RMP points, which are not used by any node anymore.

void MinlpBCP::project_ExtremePoints	(	dvector &	x,
		Pointer< MinlpNode >	node
	)			`[private]`

bool MinlpBCP::boxreduce	(	Pointer< MinlpNode >	node,
		int	index,
		IntervalReduction::which_bound_type	which_bound
	)			`[private]`

Reducing the box and updating the relaxation after subdivision.

bool MinlpBCP::feasibility_check ( Pointer< MinlpNode > node ) [private]

Checks by interval arithmetic whether the box in node is feasible by evaluation the constraints over the box.

multimap<double, Pointer<MinlpNode> >::iterator MinlpBCP::select_node ( ) [private]

int MinlpBCP::set_low_bound ( Pointer< MinlpNode > node ) [private]

Computes a lower bound of the objective value according to the bound_type: RMP_bound, NLP_bound, LP_bound.

If a lower bound can be computed , low_bound is updated and ref_point is set to the appropiate point. And dual_point is set.

Returns:: 0, if a bound was computed; other, if a bound could not be computed.

pair<bool, double> MinlpBCP::improve_bound ( Pointer< MinlpNode > node ) [private]

Improves a lower bound without subdivision.

Returns:: If the subproblem is still feasible, and $( v_{new}(U)- v(U))/(1+| v(U)|)$.

int MinlpBCP::set_NLP_bound	(	Pointer< MinlpNode >	node,
		bool	improve = `false`
	)			`[private]`

int MinlpBCP::set_RMP_bound ( Pointer< MinlpNode > node ) [private]

int MinlpBCP::set_LP_bound ( Pointer< MinlpNode > node ) [private]

int MinlpBCP::set_LP_RMP_bound ( Pointer< MinlpNode > node ) [private]

int MinlpBCP::improve_LP_bound ( Pointer< MinlpNode > node ) [private]

int MinlpBCP::update_subdiv_bound	(	int	k,
		int	i,
		Pointer< MinlpNode >	node
	)			`[private]`

Improves a lower bound after subdivision.

Parameters:

	k	The block number of the branching variable.
	i	The block index of the branching variable.
	node	The new node.
	1,if	Node is infeasible, 0 else.

int MinlpBCP::subdivide	(	list< Pointer< MinlpNode > > &	nodes,
		Pointer< MinlpNode >	node
	)			`[private]`

Subdivides the feasible set into several sets according to the subdiv_type: BinSubdiv, CostSubdiv.

Parameters:

	nodes	A list, where we can add the new nodes to.
	node	The node to subdivide.

Returns:: The index of the subdivision variable.

int MinlpBCP::bin_subdiv	(	list< Pointer< MinlpNode > > &	nodes,
		int &	subdiv_var,
		Pointer< MinlpNode >	node
	)			`[private]`

subdivision according to violated binary constraints

void MinlpBCP::cost_subdiv	(	list< Pointer< MinlpNode > > &	nodes,
		int &	subdiv_var,
		Pointer< MinlpNode >	node
	)			`[private]`

subdivision according to pseudo costs I

void MinlpBCP::bisect_subdiv	(	list< Pointer< MinlpNode > > &	nodes,
		int &	subdiv_var,
		Pointer< MinlpNode >	node
	)			`[private]`

subdivision according to pseudo costs II

subdivision at the midpoint of the largest edge

void MinlpBCP::viol_subdiv	(	list< Pointer< MinlpNode > > &	nodes,
		int &	subdiv_var,
		Pointer< MinlpNode >	node
	)			`[private]`

subdivision according to constraint violation

void MinlpBCP::rect_subdiv	(	list< Pointer< MinlpNode > > &	nodes,
		Pointer< MinlpNode >	node,
		int	k,
		int	i,
		double	cut
	)			`[private]`

branching at variable i of block k w.r.t the cut-value

void MinlpBCP::init_lag_problems ( Pointer< MinlpNode > node ) [private]

Builds the Lagrangian sub-problems with empty objective function.

void MinlpBCP::update_lag_problems ( const dvector & dual_point ) [private]

Updates the objective functions of the lagrangian subproblems.

Parameters:

dual_point

The new dual point to use.

void MinlpBCP::update_lag_problem	(	int	k,
		const dvector &	a
	)			`[private]`

void MinlpBCP::solve_lag_problem	(	LagSolveStatus &	status,
		int	k,
		Pointer< MinlpNode >	node,
		Pointer< SepQcFunc >	temp_cut = `NULL`
	)			`[private]`

Solves the k-th Lagrangian sub-problem and adds Lagrangian cuts.

Parameters:

	solset	A set, where we can store the solutions, we found, in.
	k	The block number.
	node	An optional node to store the new cuts in.
	temp_cut	Temporary cut.

Returns:: The solver status.

int MinlpBCP::conv_rate_check ( double val ) [private]

Checks the actual iteration.

Parameters:

val

The last value of the dual function.

Returns:: 0, if the solver should continue; 1, if convergence rate is too low

void MinlpBCP::mem_check ( ) [private]

void MinlpBCP::set_quad_relax ( Pointer< MinlpProblem > quad_prob_ )

void MinlpBCP::set_convex_prob	(	Pointer< MinlpProblem >	convex_prob_,
		const Pointer< dvector > &	sol_C_ = `NULL`,
		bool	sol_C_is_solution_ = `false`
	)

void MinlpBCP::set_reform	(	Pointer< Reformulation >	reform_,
		Pointer< dvector >	sol_C_,
		bool	sol_C_is_solution_
	)

void MinlpBCP::set_reform ( Pointer< Reformulation > reform_ ) [virtual]

Reimplemented from RelaxationSolver.

void MinlpBCP::set_linear_relax ( Pointer< LinearRelax > linrelax_ )

Reimplemented from RelaxationSolver.

void MinlpBCP::set_problem_is_convex ( bool prob_is_convex_ ) [inline]

Definition at line 475 of file bcp.h.

void MinlpBCP::set_MINLPData ( Pointer< MINLPData > minlpdata_ )

Reimplemented from RelaxationSolver.

void MinlpBCP::set_timer ( Pointer< Timer > timer_ )

int MinlpBCP::solve ( ) [virtual]

Calls the branch-cut-and-price algorithm.

Implements Solver.

int MinlpBCP::solve ( dvector & x ) [virtual]

Solves the problem for a starting point.

Sets sol_point to x. Calls solve().

Parameters:

x

The dvector to start the solver with.

See also:: solve()

Reimplemented from Solver.

Friends And Related Function Documentation

friend class ColumnGenerator [friend]

Definition at line 159 of file bcp.h.

friend class MinlpNode [friend]

Reimplemented from RelaxationSolver.

Definition at line 160 of file bcp.h.

Member Data Documentation

Pointer<dvector> MinlpBCP::sol_C [private]

Definition at line 162 of file bcp.h.

bool MinlpBCP::sol_C_is_solution [private]

Definition at line 163 of file bcp.h.

bool MinlpBCP::prob_is_convex [private]

Indicated whether original problem is convex.

Default: false.

Definition at line 168 of file bcp.h.

Pointer<MinlpProblem> MinlpBCP::quad_prob [private]

The quadratic relaxation of the problem.

Definition at line 172 of file bcp.h.

vector<Pointer<MinlpProblem> > MinlpBCP::block_prob [private]

The original problem for each block (P_k), without objective function.

Definition at line 176 of file bcp.h.

vector<Pointer<MinlpProblem> > MinlpBCP::block_convex_prob [private]

The convexification for each block (C_k), without objective function.

Definition at line 179 of file bcp.h.

vector<list<ExtremePoint> > MinlpBCP::ExtremePoints [private]

A pool of extreme points and columns for each block.

Definition at line 183 of file bcp.h.

vector<Pointer<MinlpProblem> > MinlpBCP::block_sub_convex_prob [private]

Definition at line 185 of file bcp.h.

Pointer<MinlpProblem> MinlpBCP::sub_convex_prob [private]

Definition at line 187 of file bcp.h.

vector<Pointer<MinlpProblem> > MinlpBCP::lag_problem [private]

The Lagrangian Subproblems for each block.

Definition at line 191 of file bcp.h.

Pointer<ColumnGenerator> MinlpBCP::colgen [private]

Definition at line 193 of file bcp.h.

multimap<double, Pointer<MinlpNode> > MinlpBCP::bb_tree [private]

A second Branch-and-Bound tree.

Definition at line 196 of file bcp.h.

Pointer<MinlpNode> MinlpBCP::current_node [private]

The current node.

Needed by add_sol_candidate.

Definition at line 201 of file bcp.h.

double MinlpBCP::gap_tol [private]

gap tolerance

Definition at line 204 of file bcp.h.

double MinlpBCP::bound_impr_tol [private]

bound improvement tolerance

Definition at line 207 of file bcp.h.

bool MinlpBCP::intgrad_cuts [private]

Indicates, whether we use IntervalGradientCuts.

Definition at line 216 of file bcp.h.

IntervalGradientCutGenerator MinlpBCP::intgrad_cutgen [private]

Definition at line 217 of file bcp.h.

LinearizedConCutGenerator MinlpBCP::linconcutgen [private]

Definition at line 219 of file bcp.h.

bool MinlpBCP::mip_cuts [private]

Indicates, whether we want to derive cuts from the LP relaxation.

Definition at line 223 of file bcp.h.

Pointer<LagHeu> MinlpBCP::lagheu [private]

Definition at line 235 of file bcp.h.

t_bound_type MinlpBCP::pre_bound_type [private]

Definition at line 270 of file bcp.h.

t_bound_type MinlpBCP::maj_bound_type [private]

Definition at line 271 of file bcp.h.

t_bound_type MinlpBCP::bound_type [private]

The current bound type.

Definition at line 274 of file bcp.h.

enum { ... } MinlpBCP::lagsolve_type [private]

enum { ... } MinlpBCP::subdiv_type [private]

int MinlpBCP::subdiv_discrete_emphasis [private]

Definition at line 280 of file bcp.h.

enum { ... } MinlpBCP::nodeselect_type [private]

int MinlpBCP::upper_bound_effort_level [private]

Definition at line 284 of file bcp.h.

int MinlpBCP::pre_bb_max_iter [private]

Do a preprocessing Branch & Bound.

Definition at line 288 of file bcp.h.

bool MinlpBCP::lag_cuts [private]

Indicates, whether we should add Lagrangian cuts.

Definition at line 292 of file bcp.h.

int MinlpBCP::bound_failed [private]

The number of computations of NLP-bounds or RMP-bounds, which failed, while (R[U]) was solved.

Definition at line 296 of file bcp.h.

int MinlpBCP::bound_computed [private]

Definition at line 297 of file bcp.h.

double MinlpBCP::bound_time [private]

Definition at line 298 of file bcp.h.

double MinlpBCP::init_RMP_time [private]

Definition at line 299 of file bcp.h.

int MinlpBCP::lagprob_solves [private]

The number of lagrangian subproblems, we (tried to) solved.

Definition at line 303 of file bcp.h.

double MinlpBCP::find_solcand_time [private]

Definition at line 305 of file bcp.h.

int MinlpBCP::nr_solcand_found [private]

Definition at line 306 of file bcp.h.

double MinlpBCP::subdiv_time [private]

Definition at line 308 of file bcp.h.

int MinlpBCP::update_ExtremePoints_count [private]

Definition at line 310 of file bcp.h.

Pointer<Timer> MinlpBCP::timer [private]

Definition at line 312 of file bcp.h.

double MinlpBCP::max_time [private]

Definition at line 313 of file bcp.h.

bool MinlpBCP::is_maxcut [private]

Definition at line 315 of file bcp.h.

Pointer<IntervalReduction> MinlpBCP::intervalreduction [private]

Definition at line 317 of file bcp.h.

int MinlpBCP::nr_subdiv_contvar [private]

number of branchings on continuous variables.

Definition at line 386 of file bcp.h.

int MinlpBCP::nr_subdiv_bisect [private]

number of subdivision by bisection.

Definition at line 389 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_stopping_rho [private]

If conv_rate_cntrl is set and improvement in last minor_iter iterations is less than stopping_rho * rel_imp1, check() breakes the solving process.

Definition at line 426 of file bcp.h.

int MinlpBCP::conv_rate_cntrl_minor_iter [private]

The number of minor iterations for the convergence rate control.

Definition at line 429 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_last_major_val [private]

The value in the last major iteration.

Definition at line 432 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_last_val [private]

The value in the last iteration.

Definition at line 435 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_first_major_val [private]

The value in the first iteration.

Definition at line 438 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_max_rel_improvement [private]

First relative improvement.

Definition at line 441 of file bcp.h.

int MinlpBCP::conv_rate_cntrl_improve_iter [private]

Counter for the number of iterations with improvements (serious steps).

Definition at line 444 of file bcp.h.

int MinlpBCP::mem_limit [private]

Definition at line 455 of file bcp.h.

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

bcp.h

MinlpBCP Class Reference

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation