![]() |
MAiNGO
|
Wrapper for handling the lower bounding problems by interfacing CLP. More...
#include <lbpClp.h>
Public Member Functions | |
LbpClp (mc::FFGraph &DAG, const std::vector< mc::FFVar > &DAGvars, const std::vector< mc::FFVar > &DAGfunctions, const std::vector< babBase::OptimizationVariable > &variables, const unsigned nineqIn, const unsigned neqIn, const unsigned nineqRelaxationOnlyIn, const unsigned neqRelaxationOnlyIn, const unsigned nineqSquashIn, Settings *settingsIn, Logger *loggerIn, std::vector< Constraint > *constraintPropertiesIn) | |
Constructor, stores information on the problem and initializes the CLP problem and solver instances. More... | |
~LbpClp () | |
Destructor. More... | |
void | activate_more_scaling () |
Function called by the B&B solver to heuristically activate more scaling in the LBS. More... | |
![]() | |
LowerBoundingSolver (mc::FFGraph &DAG, const std::vector< mc::FFVar > &DAGvars, const std::vector< mc::FFVar > &DAGfunctions, const std::vector< babBase::OptimizationVariable > &variables, const unsigned nineqIn, const unsigned neqIn, const unsigned nineqRelaxationOnlyIn, const unsigned neqRelaxationOnlyIn, const unsigned nineqSquashIn, Settings *settingsIn, Logger *loggerIn, std::vector< Constraint > *constraintPropertiesIn) | |
Constructor, stores information on the problem and constructs an own copy of the directed acyclic graph. More... | |
virtual | ~LowerBoundingSolver () |
Virtual destructor, only needed to make sure the correct destructor of the derived classes is called. More... | |
SUBSOLVER_RETCODE | solve_LBP (const babBase::BabNode ¤tNode, double &lowerBound, std::vector< double > &solutionPoint, LbpDualInfo &dualInfo) |
Function called by B&B solver for solving the lower bounding problem on the current node. More... | |
TIGHTENING_RETCODE | solve_OBBT (babBase::BabNode ¤tNode, const double currentUBD, const OBBT reductionType) |
Function called by B&B solver for optimality-based range reduction (cf., e.g., Gleixner et al., J. Glob. Optim. 67 (2017) 731) More... | |
virtual TIGHTENING_RETCODE | do_constraint_propagation (babBase::BabNode ¤tNode, const double currentUBD, const unsigned pass=3) |
Function called by B&B solver for constraint propagation. This function is virtual as it may be overwritten for certain LBD solvers. The defaults for constraint propagation are 10 rounds and at least 1% improvement. More... | |
TIGHTENING_RETCODE | do_dbbt_and_probing (babBase::BabNode ¤tNode, const std::vector< double > &lbpSolutionPoint, const LbpDualInfo &dualInfo, const double currentUBD) |
Function called by B&B solver for DBBT and probing (for each variable depending on where the LBD solution lies) More... | |
void | update_incumbent_LBP (const std::vector< double > &incumbentBAB) |
Function called by the B&B solver to update the incumbent and the ID of the node currently holding it, which is needed by some linearization heuristics. More... | |
void | preprocessor_check_options (const babBase::BabNode &rootNode) |
Function called by the B&B in preprocessing in order to check the need for specific options, currently for subgradient intervals & CPLEX no large values. More... | |
Protected Member Functions | |
void | _set_variable_bounds (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
Function for setting the bounds of variables. More... | |
void | _update_LP_obj (const MC &resultRelaxation, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin, unsigned const &iObj) |
Auxiliary function for updating LP objective, i.e., processing the linearization of the objective function. More... | |
void | _update_LP_ineq (const MC &resultRelaxation, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin, unsigned const &iIneq) |
Auxiliary function for updating LP inequalities, i.e., processing the linearization of the inequality. More... | |
void | _update_LP_eq (const MC &resultRelaxationCv, const MC &resultRelaxationCc, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin, unsigned const &iEq) |
Auxiliary function for updating LP equalities, i.e., processing the linearization of the equality. More... | |
void | _update_LP_ineqRelaxationOnly (const MC &resultRelaxation, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin, unsigned const &iIneqRelaxationOnly) |
Auxiliary function for updating LP relaxation only inequalities, i.e., processing the linearization of the relaxation only inequality. More... | |
void | _update_LP_eqRelaxationOnly (const MC &resultRelaxationCv, const MC &resultRelaxationCc, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin, unsigned const &iEqRelaxationOnly) |
Auxiliary function for updating LP relaxation only equalities, i.e., processing the linearization of the relaxation only equality. More... | |
void | _update_LP_ineq_squash (const MC &resultRelaxation, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin, unsigned const &iIneqSquash) |
Auxiliary function for updating LP squash inequalities, i.e., processing the linearization of the squash inequality No tolerances are allowed for squash inequalities! More... | |
void | _update_LP_obj (const vMC &resultRelaxationVMC, const std::vector< std::vector< double >> &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iObj) |
Auxiliary function for updating LP objective, i.e., processing the linearization of the objective function for vector McCormick relaxations. More... | |
void | _update_LP_ineq (const vMC &resultRelaxationVMC, const std::vector< std::vector< double >> &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iIneq) |
Auxiliary function for updating LP inequalities, i.e., processing the linearization of the inequality for vector McCormick relaxations. More... | |
void | _update_LP_eq (const vMC &resultRelaxationCvVMC, const vMC &resultRelaxationCcVMC, const std::vector< std::vector< double >> &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iEq) |
Auxiliary function for updating LP equalities, i.e., processing the linearization of the equality for vector McCormick relaxations. More... | |
void | _update_LP_ineqRelaxationOnly (const vMC &resultRelaxationVMC, const std::vector< std::vector< double >> &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iIneqRelaxationOnly) |
Auxiliary function for updating LP relaxation only inequalities, i.e., processing the linearization of the relaxation only inequality for vector McCormick relaxations. More... | |
void | _update_LP_eqRelaxationOnly (const vMC &resultRelaxationCvVMC, const vMC &resultRelaxationCcVMC, const std::vector< std::vector< double >> &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iEqRelaxationOnly) |
Auxiliary function for updating LP relaxation only equalities, i.e., processing the linearization of the relaxation only equality for vector McCormick relaxations. More... | |
void | _update_LP_ineq_squash (const vMC &resultRelaxationVMC, const std::vector< std::vector< double >> &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iIneqSquash) |
Auxiliary function for updating LP squash inequalities, i.e., processing the linearization of the squash inequality for vector McCormick relaxations No tolerances are allowed for squash inequalities! More... | |
void | _solve_LP (const babBase::BabNode ¤tNode) |
Function for solving the currently constructed linear program. More... | |
LP_RETCODE | _get_LP_status () |
Function returning the current status of the lastly solved linear program. More... | |
void | _get_solution_point (std::vector< double > &solution, double &etaVal) |
Function for setting the solution to the solution point of the lastly solved LP. More... | |
double | _get_objective_value_solver () |
Function returning the objective value of the lastly solved LP. More... | |
void | _get_multipliers (std::vector< double > &multipliers) |
Function for setting the multipliers of the lastly solved LP. More... | |
void | _deactivate_objective_function_for_OBBT () |
Function deactivating all objective rows in the LP for feasibility OBBT. More... | |
void | _modify_LP_for_feasopt_OBBT (const double ¤tUBD, std::list< unsigned > &toTreatMax, std::list< unsigned > &toTreatMin) |
Function modifying the LP for feasibility-optimality OBBT. More... | |
void | _set_optimization_sense_of_variable (const unsigned &iVar, const int &optimizationSense) |
Function for setting the optimization sense of variable iVar in OBBT. More... | |
void | _fix_variable (const unsigned &iVar, const bool fixToLowerBound) |
Function for fixing a variable to one of its bounds. More... | |
void | _restore_LP_coefficients_after_OBBT () |
Function for restoring proper coefficients and options in the LP after OBBT. More... | |
bool | _check_if_LP_really_infeasible () |
Function for checking if the current linear program is really infeasible by, e.g., resolving it with different algorithms. More... | |
void | _turn_off_specific_options () |
Function for checking if a specific option has to be turned off for a given lower bounding solver. We don't have to turn anything off for CLP. More... | |
SUBSOLVER_RETCODE | _check_infeasibility (const babBase::BabNode ¤tNode) |
Function for checking if the solution point returned CLP is really infeasible using Farkas' Lemma. More... | |
SUBSOLVER_RETCODE | _check_feasibility (const std::vector< double > &solution) |
Function for checking if the solution point returned by CLP solver is really feasible. More... | |
SUBSOLVER_RETCODE | _check_optimality (const babBase::BabNode ¤tNode, const double newLBD, const std::vector< double > &solution, const double etaVal, const std::vector< double > &multipliers) |
Function for checking if the solution point returned by CLP solver is really optimal using strong duality. More... | |
![]() | |
virtual LINEARIZATION_RETCODE | _update_LP (const babBase::BabNode ¤tNode) |
Calls the proper function for computing linearization points and modifying the coefficients of the LP problem The function is virtual, since other solver types, e.g., an interval solver does not need to always compute McCormick relaxations. More... | |
void | _update_whole_LP_at_linpoint (const std::vector< MC > &resultRelaxation, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, unsigned const &iLin) |
Virtual auxiliary function for updating whole LP at once. More... | |
void | _update_whole_LP_at_vector_linpoints (const std::vector< vMC > &resultRelaxationVMC, const std::vector< std::vector< double >> &linearizationPoints, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
Virtual auxiliary function for updating whole LP at once. More... | |
double | _equilibrate_and_relax (std::vector< double > &coefficients, double &rhs, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
Function for equilibrating a line in an LP. More... | |
double | _get_objective_value () |
Virtual function returning the objective value of the lastly solved LP. More... | |
void | _linearize_functions_at_linpoint (std::vector< MC > &resultRelaxation, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, mc::FFSubgraph &subgraph, std::vector< mc::FFVar > &functions) |
Auxiliary function for calling the proper function to linearize functions at chosen linearization point. More... | |
void | _linearize_functions_at_preset_vector_linpoint (std::vector< vMC > &resultRelaxationVMC, const std::vector< std::vector< double >> &linearizationPoints, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, mc::FFSubgraph &subgraph, std::vector< mc::FFVar > &functions) |
Auxiliary function for calling the proper function to linearize functions at precomputed vector linearization point. The precomputed vector linearization point has to be saved in _DAGobj.vMcPoint. More... | |
LINEARIZATION_RETCODE | _linearize_model_at_midpoint (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
This function linearizes each function of the model at the middle point of the underlying box. More... | |
LINEARIZATION_RETCODE | _linearize_model_at_incumbent (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, const bool holdsIncumbent) |
This function linearizes each function of the model at the incumbent if it is contained in the current node. Otherwise each function is linearized at the middle point of the underlying box. More... | |
LINEARIZATION_RETCODE | _linearization_points_Kelley (const babBase::BabNode ¤tNode) |
This function adds linearizations to LP with the use of an adapted version of Kelley's algorithm. The number of points equals at most _nvar+2. This function requires the solution of auxiliary LPs. Linear functions will be computed only once, since McCormick returns envelopes. Superfluous rows in the resulting LP will be set to 0. More... | |
LINEARIZATION_RETCODE | _linearization_points_Simplex (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
This function linearizes each function of the model at (_nvar+2)/2 points (except for the linear ones). The points are computed by using the precomputed simplex vertices from _compute_and_rotate_simplex. More... | |
LINEARIZATION_RETCODE | _linearization_points_random (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
This function linearizes each function of the model at (_nvar+2)/2 random points (except for the linear ones) More... | |
LINEARIZATION_RETCODE | _linearization_points_Kelley_Simplex (const babBase::BabNode ¤tNode) |
This function adds linearizations to LP with the use of an adapted version of Kelley's algorithm. The number of points equals at most the size of the chosen linpoints vector +3. This function requires the solution of auxiliary LPs. Linear functions will be computed only once, since McCormick returns envelopes. Superfluous rows in the resulting LP will be set to 0. More... | |
void | _update_LP_nonlinear_linear (const std::vector< vMC > &resultRelaxationVMCNonlinear, const std::vector< MC > &resultRelaxationLinear, const std::vector< double > &linearizationPoint, const std::vector< std::vector< double >> &scaledPoints, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
This function properly builds the LP using previously determined nonlinear and linear functions. More... | |
void | _update_LP_nonlinear (const std::vector< MC > &resultRelaxationNonlinear, const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, const unsigned iLin) |
This function properly builds the LP using previously determined nonlinear functions. More... | |
void | _reset_LP (const std::vector< double > &linearizationPoint, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
The function resets the LP, meaning it sets all rhs to 1e19 and coefficients to 0. Eta coefficients are -1. More... | |
void | _compute_and_rotate_simplex (const unsigned int dim, const double angleIn, const double sphereRadius, std::vector< std::vector< double >> &simplexPoints) |
Function for the computation of simplex points lying on a sphere with radius sphereRadius rotated by angleIn. More... | |
void | _choose_good_lin_points (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, bool firstTime=true) |
Heuristical determination of good linearization points. This function is in testing phasing and is not used. More... | |
virtual SUBSOLVER_RETCODE | _fallback_to_intervals (double &newLBD) |
Virtual function for checking if a given node is feasible with the use of interval arithmetics. It is needed in cases where the LBD solver may return something misleading, e.g., says sth is optimal but it can't be verified. More... | |
void | _truncate_value (double &value, const double tolerance) |
Function used for truncation of value digits which are not guaranteed to be correct. More... | |
void | _print_LP (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds) |
Function for printing the current LP stored in _MatrixA, _MatrixA_eqs, _rhsB, _rhsB_eqs. More... | |
Private Member Functions | |
void | _terminate_Clp () |
Function for taking care of memory management by terminating CLP (either called from destructor or when an exception is thrown) More... | |
void | _initialize_matrix () |
Function for initializing the CLP-internal matrix. More... | |
Private Attributes | |
Internal CLP variables | |
ClpSimplex | _clp |
CoinPackedMatrix | _matrix |
unsigned | _numrows |
unsigned | _numcolumns |
double * | _objective |
double * | _lowerRowBounds |
double * | _upperRowBounds |
double | _eta |
double | _etaCoeff |
std::vector< std::vector< double > > | _dualValsObj |
std::vector< std::vector< double > > | _dualValsIneq |
std::vector< std::vector< double > > | _dualValsEq1 |
std::vector< std::vector< double > > | _dualValsEq2 |
std::vector< std::vector< double > > | _dualValsIneqRelaxationOnly |
std::vector< std::vector< double > > | _dualValsEqRelaxationOnly1 |
std::vector< std::vector< double > > | _dualValsEqRelaxationOnly2 |
std::vector< std::vector< double > > | _dualValsIneqSquash |
Additional Inherited Members | |
![]() | |
std::vector< double > | _incumbent |
std::vector< std::vector< double > > | _objectiveScalingFactors |
std::vector< std::vector< std::vector< double > > > | _matrixObj |
std::vector< std::vector< std::vector< double > > > | _matrixIneq |
std::vector< std::vector< std::vector< double > > > | _matrixEq1 |
std::vector< std::vector< std::vector< double > > > | _matrixEq2 |
std::vector< std::vector< std::vector< double > > > | _matrixIneqRelaxationOnly |
std::vector< std::vector< std::vector< double > > > | _matrixEqRelaxationOnly1 |
std::vector< std::vector< std::vector< double > > > | _matrixEqRelaxationOnly2 |
std::vector< std::vector< std::vector< double > > > | _matrixIneqSquash |
std::vector< std::vector< double > > | _rhsObj |
std::vector< std::vector< double > > | _rhsIneq |
std::vector< std::vector< double > > | _rhsEq1 |
std::vector< std::vector< double > > | _rhsEq2 |
std::vector< std::vector< double > > | _rhsIneqRelaxationOnly |
std::vector< std::vector< double > > | _rhsEqRelaxationOnly1 |
std::vector< std::vector< double > > | _rhsEqRelaxationOnly2 |
std::vector< std::vector< double > > | _rhsIneqSquash |
std::shared_ptr< DagObj > | _DAGobj |
Settings * | _maingoSettings |
Logger * | _logger |
std::vector< Constraint > * | _constraintProperties |
std::vector< unsigned > | _nLinObj |
std::vector< unsigned > | _nLinIneq |
std::vector< unsigned > | _nLinEq |
std::vector< unsigned > | _nLinIneqRelaxationOnly |
std::vector< unsigned > | _nLinEqRelaxationOnly |
std::vector< unsigned > | _nLinIneqSquash |
unsigned | _maxnParticipatingVariables |
const unsigned | _nvar |
const unsigned | _nineq |
const unsigned | _neq |
const unsigned | _nineqRelaxationOnly |
const unsigned | _neqRelaxationOnly |
const unsigned | _nineqSquash |
std::vector< babBase::OptimizationVariable > | _originalVariables |
double | _objectiveValue |
std::vector< double > | _solutionPoint |
std::vector< double > | _multipliers |
std::vector< double > | _lowerVarBounds |
std::vector< double > | _upperVarBounds |
LP_RETCODE | _LPstatus |
double | _computationTol |
bool | _differentNumberOfLins = false |
Wrapper for handling the lower bounding problems by interfacing CLP.
This class constructs and solves lower bounding problems using CLP (COIN-OR project).
LbpClp::LbpClp | ( | mc::FFGraph & | DAG, |
const std::vector< mc::FFVar > & | DAGvars, | ||
const std::vector< mc::FFVar > & | DAGfunctions, | ||
const std::vector< babBase::OptimizationVariable > & | variables, | ||
const unsigned | nineqIn, | ||
const unsigned | neqIn, | ||
const unsigned | nineqRelaxationOnlyIn, | ||
const unsigned | neqRelaxationOnlyIn, | ||
const unsigned | nineqSquashIn, | ||
Settings * | settingsIn, | ||
Logger * | loggerIn, | ||
std::vector< Constraint > * | constraintPropertiesIn | ||
) |
Constructor, stores information on the problem and initializes the CLP problem and solver instances.
[in] | DAG | is the directed acyclic graph constructed in MAiNGO.cpp needed to construct an own DAG for the lower bounding solver |
[in] | DAGvars | are the variables corresponding to the DAG |
[in] | DAGfunctions | are the functions corresponding to the DAG |
[in] | variables | is a vector containing the initial optimization variables defined in problem.h |
[in] | nineqIn | is the number of inequality constraints |
[in] | neqIn | is the number of equality |
[in] | nineqRelaxationOnlyIn | is the number of inequality for use only in the relaxed problem |
[in] | neqRelaxationOnlyIn | is the number of equality constraints for use only in the relaxed problem |
[in] | nineqSquashIn | is the number of squash inequality constraints which are to be used only if the squash node has been used |
[in] | settingsIn | is a pointer to the MAiNGO settings |
[in] | loggerIn | is a pointer to the MAiNGO logger object |
[in] | constraintPropertiesIn | is a pointer to the constraint properties determined by MAiNGO |
LbpClp::~LbpClp | ( | ) |
Destructor.
|
protectedvirtual |
Function for checking if the solution point returned by CLP solver is really feasible.
[in] | solution | is holding the solution point to check |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for checking if the current linear program is really infeasible by, e.g., resolving it with different algorithms.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for checking if the solution point returned CLP is really infeasible using Farkas' Lemma.
[in] | currentNode | is holding the current node in the branch-and-bound tree |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for checking if the solution point returned by CLP solver is really optimal using strong duality.
[in] | currentNode | is holding the current node in the branch-and-bound tree |
[in] | newLBD | is the value of the solution point to check |
[in] | solution | is holding the solution point to check |
[in] | etaVal | is holding the value of eta at the solution point |
[in] | multipliers | is holding the dual multipliers of the solution |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function deactivating all objective rows in the LP for feasibility OBBT.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for fixing a variable to one of its bounds.
[in] | iVar | is the number of variable which will be fixed. |
[in] | fixToLowerBound | describes whether the variable shall be fixed to its lower or upper bound. |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function returning the current status of the lastly solved linear program.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for setting the multipliers of the lastly solved LP.
[in] | multipliers | is modified to hold the reduced costs of the lastly solved LP |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function returning the objective value of the lastly solved LP.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for setting the solution to the solution point of the lastly solved LP.
[in] | solution | is modified to hold the solution point of the lastly solved LP |
[in] | etaVal | is modified to hold the value of eta variable of the lastly solved LP |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
private |
Function for initializing the CLP-internal matrix.
|
protectedvirtual |
Function modifying the LP for feasibility-optimality OBBT.
[in] | currentUBD | is the current upper bound |
[in,out] | toTreatMax | is the list holding variables indices for maximization |
[in,out] | toTreatMin | is the list holding variables indices for minimization |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for restoring proper coefficients and options in the LP after OBBT.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for setting the optimization sense of variable iVar in OBBT.
[in] | iVar | is the number of variable of which the optimization sense will be changed. |
[in] | optimizationSense | describes whether the variable shall be maximized or minimized 1: minimize, 0: ignore, -1: maximize. |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for setting the bounds of variables.
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Function for solving the currently constructed linear program.
[in] | currentNode | is the currentNode, needed for throwing exceptions or obtaining the lower and upper bounds of variables |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
private |
Function for taking care of memory management by terminating CLP (either called from destructor or when an exception is thrown)
|
inlineprotectedvirtual |
Function for checking if a specific option has to be turned off for a given lower bounding solver. We don't have to turn anything off for CLP.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP equalities, i.e., processing the linearization of the equality.
[in] | resultRelaxationCv | is the McCormick object holding relaxation of equality iEq at linearizationPoint used for the convex part |
[in] | resultRelaxationCc | is the McCormick object holding relaxation of equality iEq at linearizationPoint used for the concave part |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iLin | is the number of the linearization point |
[in] | iEq | is the number of the equality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP equalities, i.e., processing the linearization of the equality for vector McCormick relaxations.
[in] | resultRelaxationCvVMC | is the vector McCormick object holding relaxation of equality iEq at linearizationPoint used for the convex part |
[in] | resultRelaxationCcVMC | is the vector McCormick object holding relaxation of equality iEq at linearizationPoint used for the concave part |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iEq | is the number of the equality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP relaxation only equalities, i.e., processing the linearization of the relaxation only equality.
[in] | resultRelaxationCv | is the McCormick object holding relaxation of relaxation only equality iEqRelaxationOnly at linearizationPoint used for the convex part |
[in] | resultRelaxationCc | is the McCormick object holding relaxation of relaxation only equality iEqRelaxationOnly at linearizationPoint used for the concave part |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iLin | is the number of the linearization point |
[in] | iEqRelaxationOnly | is the number of the relaxation only equality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP relaxation only equalities, i.e., processing the linearization of the relaxation only equality for vector McCormick relaxations.
[in] | resultRelaxationCvVMC | is the vector McCormick object holding relaxation of relaxation only equality iEqRelaxationOnly at linearizationPoint used for the convex part |
[in] | resultRelaxationCcVMC | is the vector McCormick object holding relaxation of relaxation only equality iEqRelaxationOnly at linearizationPoint used for the concave part |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iEqRelaxationOnly | is the number of the relaxation only equality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP inequalities, i.e., processing the linearization of the inequality.
[in] | resultRelaxation | is the McCormick object holding relaxation of inequality iIneq at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iLin | is the number of the linearization point |
[in] | iIneq | is the number of the inequality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP inequalities, i.e., processing the linearization of the inequality for vector McCormick relaxations.
[in] | resultRelaxationVMC | is the vector McCormick object holding relaxation of inequality iIneq at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iIneq | is the number of the inequality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP squash inequalities, i.e., processing the linearization of the squash inequality No tolerances are allowed for squash inequalities!
[in] | resultRelaxation | is the McCormick object holding relaxation of inequality iIneqSquash at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iLin | is the number of the linearization point |
[in] | iIneqSquash | is the number of the inequality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP squash inequalities, i.e., processing the linearization of the squash inequality for vector McCormick relaxations No tolerances are allowed for squash inequalities!
[in] | resultRelaxationVMC | is the vector McCormick object holding relaxation of inequality iIneqSquash at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iIneqSquash | is the number of the inequality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP relaxation only inequalities, i.e., processing the linearization of the relaxation only inequality.
[in] | resultRelaxation | is the McCormick object holding relaxation of relaxation only inequality iIneqRelaxationOnly at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iLin | is the number of the linearization point |
[in] | iIneqRelaxationOnly | is the number of the relaxation only inequality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP relaxation only inequalities, i.e., processing the linearization of the relaxation only inequality for vector McCormick relaxations.
[in] | resultRelaxationVMC | is the vector McCormick object holding relaxation of relaxation only inequality iIneqRelaxationOnly at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iIneqRelaxationOnly | is the number of the relaxation only inequality function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP objective, i.e., processing the linearization of the objective function.
[in] | resultRelaxation | is the McCormick object holding relaxation of objective iObj at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iLin | is the number of the linearization point |
[in] | iObj | is the number of the objective function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
protectedvirtual |
Auxiliary function for updating LP objective, i.e., processing the linearization of the objective function for vector McCormick relaxations.
[in] | resultRelaxationVMC | is the vector McCormick object holding relaxation of objective iObj at linearizationPoint |
[in] | linearizationPoint | is the vector holding the linearization point |
[in] | lowerVarBounds | is the vector holding the lower bounds of the variables |
[in] | upperVarBounds | is the vector holding the upper bounds of the variables |
[in] | iObj | is the number of the objective function |
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
virtual |
Function called by the B&B solver to heuristically activate more scaling in the LBS.
Reimplemented from maingo::lbp::LowerBoundingSolver.
|
private |
CLP solver object
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary variable for optimality check
|
private |
auxiliary objective variable
|
private |
current coefficient of eta in the LP, needed for equilibration
|
private |
lower bounds on matrix rows (-inf)
|
private |
CLP internal matrix representation
|
private |
number of matrix columns
|
private |
number of matrix rows
|
private |
coefficients in objective function
|
private |
upper bounds on matrix rows