MAiNGO
maingo::ubp::UbpClp Class Reference

Wrapper for handling the upper bounding problems by interfacing CLP. More...

#include <ubpClp.h>

Inheritance diagram for maingo::ubp::UbpClp:
maingo::ubp::UpperBoundingSolver

Public Member Functions

 UbpClp (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 nineqSquashIn, Settings *settingsIn, Logger *loggerIn, std::vector< Constraint > *constraintPropertiesIn, UBS_USE useIn)
 Constructor, stores information on the problem and initializes the local-subsolvers used. More...
 
- Public Member Functions inherited from maingo::ubp::UpperBoundingSolver
 UpperBoundingSolver (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 nineqSquashIn, Settings *settingsIn, Logger *loggerIn, std::vector< Constraint > *constraintPropertiesIn, UBS_USE useIn)
 Constructor, stores information on the problem and constructs an own copy of the directed acyclic graph. More...
 
virtual ~UpperBoundingSolver ()
 Virtual destructor, only needed to make sure the correct destructor of the derived classes is called. More...
 
virtual SUBSOLVER_RETCODE solve (babBase::BabNode const &currentNode, double &objectiveValue, std::vector< double > &solutionPoint)
 Function called by B&B solver for solving the upper bounding problem on the current node. This calls the internal (protected) function solve_nlp that needs to be re-implemented by the derived classes. More...
 
SUBSOLVER_RETCODE multistart (babBase::BabNode const &currentNode, double &objectiveValue, std::vector< double > &solutionPoint, std::vector< SUBSOLVER_RETCODE > &feasible, std::vector< double > &optimalObjectives, bool &initialPointFeasible)
 Multistart heuristic for automatically solving the UBP from multiple starting points. More...
 
SUBSOLVER_RETCODE check_feasibility (const std::vector< double > &currentPoint, double &objectiveValue) const
 Function for checking feasibility of a point. More...
 

Private Member Functions

virtual SUBSOLVER_RETCODE _solve_nlp (const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds, double &objectiveValue, std::vector< double > &solutionPoint)
 Function for actually solving the NLP (actually, LP in this case) sub-problem. More...
 
 UbpClp (const UbpClp &)
 
UbpClpoperator= (const UbpClp &)
 

Private Attributes

Internal CLP variables
ClpSimplex _clp
 
CoinPackedMatrix _matrix
 
size_t _numrows
 
double _objectiveConstant
 
std::vector< double > _objectiveCoeffs
 
std::vector< double > _lowerRowBounds
 
std::vector< double > _upperRowBounds
 
std::vector< double > _lowerVarBounds
 
std::vector< double > _upperVarBounds
 

Additional Inherited Members

- Public Types inherited from maingo::ubp::UpperBoundingSolver
enum  UBS_USE { USE_PRE = 0, USE_BAB }
 Enum for communicating what the intended purpose of the solver is. This determines which settings are used. More...
 
- Protected Member Functions inherited from maingo::ubp::UpperBoundingSolver
void _determine_structure ()
 Function for determining the number of variables participating in each function and the type of a function (linear, bilinear, quadratic, non-linear) More...
 
void _determine_sparsity_jacobian ()
 Function for setting the information about the sparsity structure in the Jacobian. More...
 
void _determine_sparsity_hessian ()
 Function for determining the non-zero entries in the Hessian of the Lagrangian function. More...
 
std::vector< double > _generate_multistart_point (bool &usedCenter, const std::vector< double > &lowerVarBounds, const std::vector< double > &upperVarBounds)
 Function for generating a point used in multistart. More...
 
SUBSOLVER_RETCODE _check_ineq (const std::vector< double > &modelOutput) const
 Function checking if inequality constraints are fulfilled. More...
 
SUBSOLVER_RETCODE _check_ineq_squash (const std::vector< double > &modelOutput) const
 Function checking if squash inequality constraints are fulfilled (no tolerance allowed) More...
 
SUBSOLVER_RETCODE _check_eq (const std::vector< double > &modelOutput) const
 Function checking if equality constraints are fulfilled. More...
 
SUBSOLVER_RETCODE _check_bounds (const std::vector< double > &currentPoint) const
 Function checking if bounds are fulfilled. More...
 
SUBSOLVER_RETCODE _check_integrality (const std::vector< double > &currentPoint) const
 Function checking if discrete variables are indeed discrete. More...
 
- Protected Attributes inherited from maingo::ubp::UpperBoundingSolver
Settings_maingoSettings
 
Logger_logger
 
std::shared_ptr< DagObj_DAGobj
 
UBS_USE _intendedUse
 
std::vector< Constraint > * _constraintProperties
 
unsigned _nvar
 
unsigned _nineq
 
unsigned _nineqSquash
 
unsigned _neq
 
std::vector< babBase::OptimizationVariable_originalVariables
 
std::vector< double > _originalUpperBounds
 
std::vector< double > _originalLowerBounds
 
UbpStructure _structure
 

Detailed Description

Wrapper for handling the upper bounding problems by interfacing CLP.

This class constructs and solves upper bounding problems which were recognized as LP using CLP (COIN-OR project).

Constructor & Destructor Documentation

◆ UbpClp() [1/2]

UbpClp::UbpClp ( 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  nineqSquashIn,
Settings settingsIn,
Logger loggerIn,
std::vector< Constraint > *  constraintPropertiesIn,
UBS_USE  useIn 
)

Constructor, stores information on the problem and initializes the local-subsolvers used.

Parameters
[in]DAGis the directed acyclic graph constructed in MAiNGO.cpp needed to construct an own DAG for the lower bounding solver
[in]DAGvarsare the variables corresponding to the DAG
[in]DAGfunctionsare the functions corresponding to the DAG
[in]variablesis a vector containing the initial optimization variables defined in problem.h
[in]nineqInis the number of inequality constraints
[in]neqInis the number of equality constraints
[in]nineqSquashInis the number of squash inequality constraints which are to be used only if the squash node has been used
[in]settingsInis a pointer to the MAiNGO settings
[in]loggerInis a pointer to the MAiNGO logger object
[in]constraintPropertiesInis a pointer to the constraint properties determined by MAiNGO
[in]useIncommunicates what the solver is to be used for

◆ UbpClp() [2/2]

maingo::ubp::UbpClp::UbpClp ( const UbpClp )
private

default copy constructor declared private to prevent use

Member Function Documentation

◆ _solve_nlp()

SUBSOLVER_RETCODE UbpClp::_solve_nlp ( const std::vector< double > &  lowerVarBounds,
const std::vector< double > &  upperVarBounds,
double &  objectiveValue,
std::vector< double > &  solutionPoint 
)
privatevirtual

Function for actually solving the NLP (actually, LP in this case) sub-problem.

Parameters
[in]lowerVarBoundsis the vector containing the lower bounds on the variables within the current node
[in]upperVarBoundsis the vector containing the upper bounds on the variables within the current node
[out]objectiveValueis the objective value obtained for the solution point of the upper bounding problem (need not be a local optimum!)
[in,out]solutionPointis the point at which objectiveValue was achieved (can in principle be any point within the current node!); it is also used for communicating the initial point (usually the LBP solution point)
Returns
Return code, either SUBSOLVER_FEASIBLE or SUBSOLVER_INFEASIBLE, indicating whether the returned solutionPoint (!!) is feasible or not

Reimplemented from maingo::ubp::UpperBoundingSolver.

◆ operator=()

UbpClp& maingo::ubp::UbpClp::operator= ( const UbpClp )
private

default assignment operator declared private to prevent use

Member Data Documentation

◆ _clp

ClpSimplex maingo::ubp::UbpClp::_clp
private

CLP simplex object

◆ _lowerRowBounds

std::vector<double> maingo::ubp::UbpClp::_lowerRowBounds
private

lower bounds on constraints

◆ _lowerVarBounds

std::vector<double> maingo::ubp::UbpClp::_lowerVarBounds
private

lower bounds on variables

◆ _matrix

CoinPackedMatrix maingo::ubp::UbpClp::_matrix
private

CLP matrix object

◆ _numrows

size_t maingo::ubp::UbpClp::_numrows
private

total number of constraints in the LP

◆ _objectiveCoeffs

std::vector<double> maingo::ubp::UbpClp::_objectiveCoeffs
private

coefficients of variables in the LP objective

◆ _objectiveConstant

double maingo::ubp::UbpClp::_objectiveConstant
private

to account for the case where the user uses a constant in the objective

◆ _upperRowBounds

std::vector<double> maingo::ubp::UbpClp::_upperRowBounds
private

upper bounds on constraints

◆ _upperVarBounds

std::vector<double> maingo::ubp::UbpClp::_upperVarBounds
private

upper bounds on variables


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