MinlpBCP Class Reference

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

#include <bcp.h>

Inheritance diagram for MinlpBCP:

Inheritance graph
[legend]
Collaboration diagram for MinlpBCP:

Collaboration graph
[legend]
List of all members.

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

typedef MinlpBCP::LagSolveStatus_s LagSolveStatus
 RMP_bound
 NLP_bound
 LP_bound
 LP_RMP_bound
 stop_bound
 BranchCut
 BinSubdiv
 CostSubdivLag
 CostSubdivNewton
 BisectSubdiv
 RMPSubdiv
 ViolSubdiv
 Bound
 UnfixedDiscrete
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  { Bound, UnfixedDiscrete }

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 ()
multimap< double, Pointer<
MinlpNode > >::iterator 
select_node_bestbound ()
multimap< double, Pointer<
MinlpNode > >::iterator 
select_node_worstbound ()
multimap< double, Pointer<
MinlpNode > >::iterator 
select_node_unfixeddiscrete_bestbound ()
multimap< double, Pointer<
MinlpNode > >::iterator 
select_node_unfixeddiscrete_worstbound ()
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, bool is_root=false)
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 at the midpoint of the largest edge
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< dvectorsol_C
bool sol_C_is_solution
bool prob_is_convex
 Indicated whether original problem is convex.
Pointer< MinlpProblemquad_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< MinlpProblemsub_convex_prob
vector< Pointer< MinlpProblem > > lag_problem
 The Lagrangian Subproblems for each block.
Pointer< ColumnGeneratorcolgen
multimap< double, Pointer<
MinlpNode > > 
bb_tree
 A second Branch-and-Bound tree.
Pointer< MinlpNodecurrent_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< LagHeulagheu
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 alternate_bounds
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 max_outerapprox_iter
 Maximal number of cutgeneration rounds for each node in improve_LP_bound.
int max_outerapprox_root_iter
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< Timertimer
double max_time
bool is_maxcut
Pointer< IntervalReductionintervalreduction
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

Classes

struct  LagSolveStatus_s

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.
max outer approximation iterations options integer $ 0$ default 10 level 1 Maximal number of outer approximation iterations (cutgeneration and resolve of LP relax) for each node.
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 163 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 274 of file bcp.h.

anonymous enum [private]

Enumerator:
BranchCut 

Definition at line 281 of file bcp.h.

anonymous enum [private]

Enumerator:
BinSubdiv 
CostSubdivLag 
CostSubdivNewton 
BisectSubdiv 
RMPSubdiv 
ViolSubdiv 

Definition at line 283 of file bcp.h.

anonymous enum [private]

Enumerator:
Bound 
UnfixedDiscrete 

Definition at line 287 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]

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

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

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

multimap<double, Pointer<MinlpNode> >::iterator MinlpBCP::select_node_unfixeddiscrete_worstbound (  )  [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,
bool  is_root = false 
) [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 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 490 of file bcp.h.

References prob_is_convex.

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 start  )  [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 164 of file bcp.h.

friend class MinlpNode [friend]

Reimplemented from RelaxationSolver.

Definition at line 165 of file bcp.h.


Member Data Documentation

Pointer<dvector> MinlpBCP::sol_C [private]

Definition at line 167 of file bcp.h.

bool MinlpBCP::sol_C_is_solution [private]

Definition at line 168 of file bcp.h.

bool MinlpBCP::prob_is_convex [private]

Indicated whether original problem is convex.

Default: false.

Definition at line 173 of file bcp.h.

Referenced by set_problem_is_convex().

Pointer<MinlpProblem> MinlpBCP::quad_prob [private]

The quadratic relaxation of the problem.

Definition at line 177 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 181 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 184 of file bcp.h.

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

A pool of extreme points and columns for each block.

Definition at line 188 of file bcp.h.

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

Definition at line 190 of file bcp.h.

Pointer<MinlpProblem> MinlpBCP::sub_convex_prob [private]

Definition at line 192 of file bcp.h.

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

The Lagrangian Subproblems for each block.

Definition at line 196 of file bcp.h.

Pointer<ColumnGenerator> MinlpBCP::colgen [private]

Definition at line 198 of file bcp.h.

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

A second Branch-and-Bound tree.

Definition at line 201 of file bcp.h.

Pointer<MinlpNode> MinlpBCP::current_node [private]

The current node.

Needed by add_sol_candidate.

Definition at line 206 of file bcp.h.

double MinlpBCP::gap_tol [private]

gap tolerance

Definition at line 209 of file bcp.h.

double MinlpBCP::bound_impr_tol [private]

bound improvement tolerance

Definition at line 212 of file bcp.h.

bool MinlpBCP::intgrad_cuts [private]

Indicates, whether we use IntervalGradientCuts.

Definition at line 221 of file bcp.h.

IntervalGradientCutGenerator MinlpBCP::intgrad_cutgen [private]

Definition at line 222 of file bcp.h.

LinearizedConCutGenerator MinlpBCP::linconcutgen [private]

Definition at line 224 of file bcp.h.

bool MinlpBCP::mip_cuts [private]

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

Definition at line 228 of file bcp.h.

Pointer<LagHeu> MinlpBCP::lagheu [private]

Definition at line 240 of file bcp.h.

t_bound_type MinlpBCP::pre_bound_type [private]

Definition at line 275 of file bcp.h.

t_bound_type MinlpBCP::maj_bound_type [private]

Definition at line 276 of file bcp.h.

t_bound_type MinlpBCP::bound_type [private]

The current bound type.

Definition at line 279 of file bcp.h.

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

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

int MinlpBCP::subdiv_discrete_emphasis [private]

Definition at line 285 of file bcp.h.

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

int MinlpBCP::alternate_bounds [private]

Definition at line 288 of file bcp.h.

int MinlpBCP::upper_bound_effort_level [private]

Definition at line 290 of file bcp.h.

int MinlpBCP::pre_bb_max_iter [private]

Do a preprocessing Branch & Bound.

Definition at line 294 of file bcp.h.

bool MinlpBCP::lag_cuts [private]

Indicates, whether we should add Lagrangian cuts.

Definition at line 298 of file bcp.h.

int MinlpBCP::max_outerapprox_iter [private]

Maximal number of cutgeneration rounds for each node in improve_LP_bound.

Definition at line 302 of file bcp.h.

int MinlpBCP::max_outerapprox_root_iter [private]

Definition at line 303 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 307 of file bcp.h.

int MinlpBCP::bound_computed [private]

Definition at line 308 of file bcp.h.

double MinlpBCP::bound_time [private]

Definition at line 309 of file bcp.h.

double MinlpBCP::init_RMP_time [private]

Definition at line 310 of file bcp.h.

int MinlpBCP::lagprob_solves [private]

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

Definition at line 314 of file bcp.h.

double MinlpBCP::find_solcand_time [private]

Definition at line 316 of file bcp.h.

int MinlpBCP::nr_solcand_found [private]

Definition at line 317 of file bcp.h.

double MinlpBCP::subdiv_time [private]

Definition at line 319 of file bcp.h.

int MinlpBCP::update_ExtremePoints_count [private]

Definition at line 321 of file bcp.h.

Pointer<Timer> MinlpBCP::timer [private]

Definition at line 323 of file bcp.h.

double MinlpBCP::max_time [private]

Definition at line 324 of file bcp.h.

bool MinlpBCP::is_maxcut [private]

Definition at line 326 of file bcp.h.

Pointer<IntervalReduction> MinlpBCP::intervalreduction [private]

Definition at line 328 of file bcp.h.

int MinlpBCP::nr_subdiv_contvar [private]

number of branchings on continuous variables.

Definition at line 401 of file bcp.h.

int MinlpBCP::nr_subdiv_bisect [private]

number of subdivision by bisection.

Definition at line 404 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 441 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 444 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_last_major_val [private]

The value in the last major iteration.

Definition at line 447 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_last_val [private]

The value in the last iteration.

Definition at line 450 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_first_major_val [private]

The value in the first iteration.

Definition at line 453 of file bcp.h.

double MinlpBCP::conv_rate_cntrl_max_rel_improvement [private]

First relative improvement.

Definition at line 456 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 459 of file bcp.h.

int MinlpBCP::mem_limit [private]

Definition at line 470 of file bcp.h.


The documentation for this class was generated from the following file:
Generated on Wed Oct 22 03:13:01 2008 for LaGO by  doxygen 1.4.7