![]() |
MAiNGO
|
Base class for wrappers for handling the upper bounding problems. More...
#include <ubp.h>
Public Types | |
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... | |
Public Member Functions | |
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 ¤tNode, 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 ¤tNode, 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 > ¤tPoint, double &objectiveValue) const |
Function for checking feasibility of a point. More... | |
Protected 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 sub-problem. This needs to be re-defined in derived classes to call specific sub-solvers. More... | |
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... | |
Functions for checking feasibility of a given point | |
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 > ¤tPoint) const |
Function checking if bounds are fulfilled. More... | |
SUBSOLVER_RETCODE | _check_integrality (const std::vector< double > ¤tPoint) const |
Function checking if discrete variables are indeed discrete. More... | |
Protected Attributes | |
Pointers to several objects. Note that these are NOT const, since if we want to resolve with MAiNGO, the pointers have to change | |
Settings * | _maingoSettings |
Logger * | _logger |
std::shared_ptr< DagObj > | _DAGobj |
UBS_USE | _intendedUse |
std::vector< Constraint > * | _constraintProperties |
Internal variables for storing information on the problem | |
unsigned | _nvar |
unsigned | _nineq |
unsigned | _nineqSquash |
unsigned | _neq |
std::vector< babBase::OptimizationVariable > | _originalVariables |
std::vector< double > | _originalUpperBounds |
std::vector< double > | _originalLowerBounds |
UbpStructure | _structure |
Private Member Functions | |
UpperBoundingSolver () | |
UpperBoundingSolver (const UpperBoundingSolver &) | |
UpperBoundingSolver & | operator= (const UpperBoundingSolver &) |
Base class for wrappers for handling the upper bounding problems.
This is the base class for the upper bounding solvers that construct and solve upper bounding problems. The base class simply checks feasibility of the initial point (or midpoint if none is given). The derived classes mainly need to implement the solve method for solving the upper bounding problem, as well as the set_effort method for choosing between a high and low solution effort.
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.
[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 constraints |
[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 |
[in] | useIn | communicates what the solver is to be used for |
|
inlinevirtual |
Virtual destructor, only needed to make sure the correct destructor of the derived classes is called.
|
private |
Standard constructor prohibited
|
private |
default copy constructor declared private to prevent use
|
protected |
Function checking if bounds are fulfilled.
[in] | currentPoint | holds the values of the current point |
|
protected |
Function checking if equality constraints are fulfilled.
[in] | modelOutput | holds the values of all constraints of the model |
|
protected |
Function checking if inequality constraints are fulfilled.
[in] | modelOutput | holds the values of all constraints of the model |
|
protected |
Function checking if squash inequality constraints are fulfilled (no tolerance allowed)
[in] | modelOutput | holds the values of all constraints of the model |
|
protected |
Function checking if discrete variables are indeed discrete.
[in] | currentPoint | holds the values of the current point |
|
protected |
Function for determining the non-zero entries in the Hessian of the Lagrangian function.
|
protected |
Function for setting the information about the sparsity structure in the Jacobian.
|
protected |
Function for determining the number of variables participating in each function and the type of a function (linear, bilinear, quadratic, non-linear)
|
protected |
Function for generating a point used in multistart.
[in] | usedCenter | is a flag indicating whether the mid point has already been used |
[in] | lowerVarBounds | holds lower bounds of variables |
[in] | upperVarBounds | holds upper bounds of variables |
|
protectedvirtual |
Function for actually solving the NLP sub-problem. This needs to be re-defined in derived classes to call specific sub-solvers.
[in] | lowerVarBounds | is the vector containing the lower bounds on the variables within the current node |
[in] | upperVarBounds | is the vector containing the upper bounds on the variables within the current node |
[out] | objectiveValue | is the objective value obtained for the solution point of the upper bounding problem (need not be a local optimum!) |
[in,out] | solutionPoint | is 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) |
Reimplemented in maingo::ubp::UbpCplex, maingo::ubp::UbpClp, maingo::ubp::UbpKnitro, maingo::ubp::UbpIpopt, and maingo::ubp::UbpNLopt.
SUBSOLVER_RETCODE UpperBoundingSolver::check_feasibility | ( | const std::vector< double > & | currentPoint, |
double & | objectiveValue | ||
) | const |
Function for checking feasibility of a point.
[in] | currentPoint | is the point to be checked |
[in] | objectiveValue | is the objective value of the current point |
SUBSOLVER_RETCODE UpperBoundingSolver::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.
[in] | currentNode | is the B&B node for which the lower bounding problem should be solved |
[out] | objectiveValue | is the objective value obtained for the solution point of the upper bounding problem (need not be a local optimum!) |
[in,out] | solutionPoint | is the point at which objectiveValue was achieved (can in principle be any point within the current node!); it is also used for communicating the user-defined initial point (if any) |
[out] | feasible | is a vector containing information about which multistart runs were successful in finding a feasible point (only used if corresponding setting PRE_printEveryLocalSerach is on) |
[out] | optimalObjectives | is a vector containing the optimal objectives found (either all of them if PRE_printEveryLocalSerach is enabled, or only the ones with significant improvements) |
[out] | initialPointFeasible | states whether or not the user-specified point was found to be feasible |
|
private |
default assignment operator declared private to prevent use
|
virtual |
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.
[in] | currentNode | is the B&B node for which the lower bounding problem should be solved |
[out] | objectiveValue | is the objective value obtained for the solution point of the upper bounding problem (need not be a local optimum!) |
[in,out] | solutionPoint | is 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) |
|
protected |
pointer to constraint properties determined by MAiNGO
|
protected |
pointer to object containing DAG for upper bounding
|
protected |
object storing information about the intended use of this UpperBoundingSolver object
|
protected |
pointer to object holding MAiNGO settings
|
protected |
number of equalities
|
protected |
number of inequalities
|
protected |
number of squash inequalities
|
protected |
number of variables
|
protected |
vector of upper bounds for variables as specified in the problem definition
|
protected |
vector of upper bounds for variables as specified in the problem definition
|
protected |
original variables (i.e., original upper and lower bounds, info on which variables are binary etc., cf. structs.h)
|
protected |
struct storing information on the problem structure