#include <CouenneProblem.hpp>
Collaboration diagram for Couenne::CouenneProblem:
Public Types | |
MulSepNone | |
MulSepSimple | |
MulSepTight | |
enum | multiSep { MulSepNone, MulSepSimple, MulSepTight } |
Type of multilinear separation. More... | |
Public Member Functions | |
CouenneProblem (ASL *=NULL, Bonmin::BabSetupBase *base=NULL, JnlstPtr jnlst=NULL) | |
Constructor. | |
CouenneProblem (const CouenneProblem &) | |
Copy constructor. | |
~CouenneProblem () | |
Destructor. | |
void | initOptions (Ipopt::SmartPtr< Ipopt::OptionsList > options) |
initializes parameters like doOBBT | |
CouenneProblem * | clone () const |
Clone method (for use within CouenneCutGenerator::clone). | |
int | nObjs () const |
Get number of objectives. | |
int | nCons () const |
Get number of constraints. | |
int | nOrigCons () const |
Get number of original constraints. | |
int | nOrigVars () const |
Number of orig. variables. | |
int | nDefVars () const |
Number of def'd variables. | |
int | nOrigIntVars () const |
Number of original integers. | |
int | nIntVars () const |
Number of integer variables. | |
int | nVars () const |
Total number of variables. | |
void | setNDefVars (int ndefined__) |
std::vector< int > * | Find_Orbit (int) const |
void | sym_setup () |
void | Compute_Symmetry () const |
void | Print_Orbits () const |
void | ChangeBounds (const double *, const double *, int) const |
bool | compare (register Node &a, register Node &b) const |
Nauty * | getNtyInfo () |
void | setupSymmetry () |
empty if no NTY, symmetry data structure setup otherwise | |
int | evalOrder (int i) const |
get evaluation order index | |
int * | evalVector () |
get evaluation order vector (numbering_) | |
CouenneConstraint * | Con (int i) const |
i-th constraint | |
CouenneObjective * | Obj (int i) const |
i-th objective | |
exprVar * | Var (int i) const |
Return pointer to i-th variable. | |
std::vector< exprVar * > & | Variables () |
Return vector of variables (symbolic representation). | |
std::set< exprAux *, compExpr > *& | AuxSet () |
Return pointer to set for comparisons. | |
DepGraph * | getDepGraph () |
Return pointer to dependence graph. | |
Domain * | domain () const |
return current point & bounds | |
std::vector< expression * > & | commonExprs () |
CouNumber & | X (int i) const |
![]() | |
CouNumber & | Lb (int i) const |
lower bound on ![]() | |
CouNumber & | Ub (int i) const |
upper bound on ![]() | |
CouNumber * | X () const |
Return vector of variables. | |
CouNumber * | Lb () const |
Return vector of lower bounds. | |
CouNumber * | Ub () const |
Return vector of upper bounds. | |
CouNumber *& | bestSol () const |
Best known solution (read from file). | |
CouNumber | bestObj () const |
Objective of best known solution. | |
bool *& | Commuted () |
Get vector of commuted variables. | |
void | addObjective (expression *, const std::string &="min") |
Add (non linear) objective function. | |
void | addEQConstraint (expression *, expression *=NULL) |
Add equality constraint ![]() | |
void | addGEConstraint (expression *, expression *=NULL) |
Add ![]() ![]() | |
void | addLEConstraint (expression *, expression *=NULL) |
Add ![]() ![]() | |
void | addRNGConstraint (expression *, expression *=NULL, expression *=NULL) |
Add range constraint, ![]() | |
void | setObjective (int indObj=0, expression *=NULL, const std::string &="min") |
Add (non linear) objective function. | |
expression * | addVariable (bool isint=false, Domain *d=NULL) |
Add original variable. | |
exprAux * | addAuxiliary (expression *) |
Add auxiliary variable and associate it with expression given as argument (used in standardization). | |
void | reformulate (CouenneCutGenerator *=NULL) |
preprocess problem in order to extract linear relaxations etc. | |
bool | standardize () |
Break problem's nonlinear constraints in simple expressions to be convexified later. | |
void | print (std::ostream &=std::cout) |
Display current representation of problem: objective, linear and nonlinear constraints, and auxiliary variables. | |
bool | doFBBT () const |
shall we do Feasibility Based Bound Tightening? | |
bool | doRCBT () const |
shall we do reduced cost Bound Tightening? | |
bool | doOBBT () const |
shall we do Optimality Based Bound Tightening? | |
bool | doABT () const |
shall we do Aggressive Bound Tightening? | |
int | logObbtLev () const |
How often shall we do OBBT? | |
int | logAbtLev () const |
How often shall we do ABT? | |
void | writeAMPL (const std::string &fname, bool aux) |
Write nonlinear problem to a .mod file (with lots of defined variables). | |
void | writeGAMS (const std::string &fname) |
Write nonlinear problem to a .gms file. | |
void | initAuxs () const |
Initialize auxiliary variables and their bounds from original variables. | |
void | getAuxs (CouNumber *) const |
Get auxiliary variables from original variables. | |
bool | boundTightening (t_chg_bounds *, Bonmin::BabInfo *=NULL) const |
tighten bounds using propagation, implied bounds and reduced costs | |
bool | btCore (t_chg_bounds *chg_bds) const |
core of the bound tightening procedure | |
int | obbt (const CouenneCutGenerator *cg, const OsiSolverInterface &csi, OsiCuts &cs, const CglTreeInfo &info, Bonmin::BabInfo *babInfo, t_chg_bounds *chg_bds) |
Optimality Based Bound Tightening. | |
bool | aggressiveBT (Bonmin::OsiTMINLPInterface *nlp, t_chg_bounds *, const CglTreeInfo &info, Bonmin::BabInfo *=NULL) const |
aggressive bound tightening. | |
int | redCostBT (const OsiSolverInterface *psi, t_chg_bounds *chg_bds) const |
procedure to strengthen variable bounds. | |
int | tightenBounds (t_chg_bounds *) const |
"Forward" bound tightening, that is, propagate bound of variable ![]() ![]() ![]() | |
int | impliedBounds (t_chg_bounds *) const |
"Backward" bound tightening, aka implied bounds. | |
void | fillQuadIndices () |
Look for quadratic terms to be used with SDP cuts. | |
void | fillObjCoeff (double *&) |
Fill vector with coefficients of objective function. | |
void | auxiliarize (exprVar *, exprVar *=NULL) |
Replace all occurrences of original variable with new aux given as argument. | |
void | setCutOff (CouNumber cutoff, const CouNumber *sol=NULL) const |
Set cutoff. | |
void | resetCutOff (CouNumber value=COUENNE_INFINITY) const |
Reset cutoff. | |
CouNumber | getCutOff () const |
Get cutoff. | |
CouNumber * | getCutOffSol () const |
Get cutoff solution. | |
void | installCutOff () const |
Make cutoff known to the problem. | |
ConstJnlstPtr | Jnlst () const |
Provide Journalist. | |
bool | checkNLP (const double *solution, double &obj, bool recompute=false) const |
Check if solution is MINLP feasible. | |
int | getIntegerCandidate (const double *xFrac, double *xInt, double *lb, double *ub) const |
generate integer NLP point Y starting from fractional solution using bound tightening | |
bool | readOptimum (std::string *fname=NULL) |
Read best known solution from file given in argument. | |
exprAux * | linStandardize (bool addAux, CouNumber c0, LinMap &lmap, QuadMap &qmap) |
standardization of linear exprOp's | |
int | splitAux (CouNumber, expression *, expression *&, bool *, enum expression::auxSign &) |
split a constraint w - f(x) = c into w's index (it is returned) and rest = f(x) + c | |
void | indcoe2vector (int *indexL, CouNumber *coeff, std::vector< std::pair< exprVar *, CouNumber > > &lcoeff) |
translates pair (indices, coefficients) into vector with pointers to variables | |
void | indcoe2vector (int *indexI, int *indexJ, CouNumber *coeff, std::vector< quadElem > &qcoeff) |
translates triplet (indicesI, indicesJ, coefficients) into vector with pointers to variables | |
void | decomposeTerm (expression *term, CouNumber initCoe, CouNumber &c0, LinMap &lmap, QuadMap &qmap) |
given (expression *) element of sum, returns (coe,ind0,ind1) depending on element: | |
const std::string & | problemName () const |
return problem name | |
void | setProblemName (std::string &problemName__) |
const std::vector< std::set< int > > & | Dependence () const |
return inverse dependence structure | |
const std::vector< CouenneObject * > & | Objects () const |
return object vector | |
int | findSOS (CbcModel *CbcModelPtr, OsiSolverInterface *solver, OsiObject **objects) |
find SOS constraints in problem | |
void | setMaxCpuTime (double time) |
set maximum CPU time | |
double | getMaxCpuTime () const |
return maximum CPU time | |
void | setBase (Bonmin::BabSetupBase *base) |
save CouenneBase | |
void | createUnusedOriginals () |
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates). | |
void | restoreUnusedOriginals (CouNumber *=NULL) const |
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates). | |
int * | unusedOriginalsIndices () |
return indices of neglected redundant variables | |
int | nUnusedOriginals () |
number of unused originals | |
enum multiSep | MultilinSep () const |
return type of separator for multilinear terms | |
bool | fbbtReachedIterLimit () const |
true if latest call to FBBT terminated due to iteration limit reached | |
bool | orbitalBranching () const |
return true if orbital branching activated | |
void | setCheckAuxBounds (bool value) |
set the value for checkAuxBounds. | |
bool | checkAuxBounds () const |
return true if bounds of auxiliary variables have to be satisfied whenever a solution is tested for MINLP feasibiliry | |
enum TrilinDecompType | getTrilinDecompType () |
return type of decomposition of quadrilinear terms | |
Bonmin::BabSetupBase * | bonBase () const |
options | |
int | getLastPrioSort () const |
void | setLastPrioSort (int givenLastPS) |
CouenneRecordBestSol * | getRecordBestSol () const |
returns recorded best solution | |
double | getFeasTol () |
returns feasibility tolerance | |
double | checkObj (const CouNumber *sol, const double &precision) const |
Recompute objective value for sol. | |
bool | checkInt (const CouNumber *sol, const int from, const int upto, const std::vector< int > listInt, const bool origVarOnly, const bool stopAtFirstViol, const double precision, double &maxViol) const |
check integrality of vars in sol with index between from and upto (original vars only if origVarOnly == true); return true if all integer vars are within precision of an integer value | |
bool | checkBounds (const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const |
Check bounds; returns true iff feasible for given precision. | |
bool | checkAux (const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const |
returns true iff value of all auxilliaries are within bounds | |
bool | checkCons (const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const |
returns true iff value of all auxilliaries are within bounds | |
bool | checkNLP2 (const double *solution, const double obj, const bool careAboutObj, const bool stopAtFirstViol, const bool checkAll, const double precision) const |
if careAboutObj is set to true, then stopAtFirstViol must be set to false too. | |
Static Public Member Functions | |
static void | registerOptions (Ipopt::SmartPtr< Bonmin::RegisteredOptions > roptions) |
Add list of options to be read from file. | |
Public Attributes | |
int | minDepthPrint_ |
int | minNodePrint_ |
bool | doPrint_ |
std::vector< Node > | node_info |
Nauty * | nauty_info |
myclass0 | node_sort |
myclass | index_sort |
Protected Member Functions | |
int | fake_tighten (char direction, int index, const double *X, CouNumber *olb, CouNumber *oub, t_chg_bounds *chg_bds, t_chg_bounds *f_chg) const |
single fake tightening. | |
int | obbtInner (OsiSolverInterface *, OsiCuts &, t_chg_bounds *, Bonmin::BabInfo *) const |
Optimality Based Bound Tightening -- inner loop. | |
int | obbt_iter (OsiSolverInterface *csi, t_chg_bounds *chg_bds, const CoinWarmStart *warmstart, Bonmin::BabInfo *babInfo, double *objcoe, int sense, int index) const |
Iteration on one variable. | |
int | call_iter (OsiSolverInterface *csi, t_chg_bounds *chg_bds, const CoinWarmStart *warmstart, Bonmin::BabInfo *babInfo, double *objcoe, enum nodeType type, int sense) const |
void | analyzeSparsity (CouNumber, LinMap &, QuadMap &) |
analyze sparsity of potential exprQuad/exprGroup and change linear/quadratic maps accordingly, if necessary by adding new auxiliary variables and including them in the linear map | |
void | flattenMul (expression *mul, CouNumber &coe, std::map< int, CouNumber > &indices) |
re-organizes multiplication and stores indices (and exponents) of its variables | |
void | realign () |
clear all spurious variables pointers not referring to the variables_ vector | |
void | fillDependence (Bonmin::BabSetupBase *base, CouenneCutGenerator *=NULL) |
fill dependence_ structure | |
void | fillIntegerRank () const |
fill freeIntegers_ array | |
int | testIntFix (int index, CouNumber xFrac, enum fixType *fixed, CouNumber *xInt, CouNumber *dualL, CouNumber *dualR, CouNumber *olb, CouNumber *oub, bool patient) const |
Test fixing of an integer variable (used in getIntegerCandidate()). | |
Protected Attributes | |
std::string | problemName_ |
problem name | |
std::vector< exprVar * > | variables_ |
Variables (original, auxiliary, and defined). | |
std::vector< CouenneObjective * > | objectives_ |
Objectives. | |
std::vector< CouenneConstraint * > | constraints_ |
Constraints. | |
std::vector< expression * > | commonexprs_ |
AMPL's common expressions (read from AMPL through structures cexps and cexps1). | |
Domain | domain_ |
current point and bounds; | |
std::set< exprAux *, compExpr > * | auxSet_ |
Expression map for comparison in standardization and to count occurrences of an auxiliary. | |
int | curnvars_ |
Number of elements in the x_, lb_, ub_ arrays. | |
int | nIntVars_ |
Number of discrete variables. | |
CouNumber * | optimum_ |
Best solution known to be loaded from file -- for testing purposes. | |
CouNumber | bestObj_ |
Best known objective function. | |
int * | quadIndex_ |
Indices of variables appearing in products (used for SDP cuts). | |
bool * | commuted_ |
Variables that have commuted to auxiliary. | |
int * | numbering_ |
numbering of variables. | |
int | ndefined_ |
Number of "defined variables" (aka "common expressions"). | |
DepGraph * | graph_ |
Dependence (acyclic) graph: shows dependence of all auxiliary variables on one another and on original variables. | |
int | nOrigVars_ |
Number of original variables. | |
int | nOrigCons_ |
Number of original constraints (disregarding those that turned into auxiliary variable definition). | |
int | nOrigIntVars_ |
Number of original integer variables. | |
GlobalCutOff * | pcutoff_ |
Pointer to a global cutoff object. | |
bool | created_pcutoff_ |
flag indicating if this class is creator of global cutoff object | |
bool | doFBBT_ |
do Feasibility-based bound tightening | |
bool | doRCBT_ |
do reduced cost bound tightening | |
bool | doOBBT_ |
do Optimality-based bound tightening | |
bool | doABT_ |
do Aggressive bound tightening | |
int | logObbtLev_ |
frequency of Optimality-based bound tightening | |
int | logAbtLev_ |
frequency of Aggressive bound tightening | |
JnlstPtr | jnlst_ |
SmartPointer to the Journalist. | |
CouNumber | opt_window_ |
window around known optimum (for testing purposes) | |
bool | useQuadratic_ |
Use quadratic expressions? | |
CouNumber | feas_tolerance_ |
feasibility tolerance (to be used in checkNLP) | |
std::vector< std::set< int > > | dependence_ |
inverse dependence structure: for each variable x give set of auxiliary variables (or better, their indices) whose expression depends on x | |
std::vector< CouenneObject * > | objects_ |
vector of pointer to CouenneObjects. | |
int * | integerRank_ |
each element is true if variable is integer and, if auxiliary, depends on no integer | |
std::vector< int > | numberInRank_ |
numberInRank_ [i] is the number of integer variables in rank i | |
double | maxCpuTime_ |
maximum cpu time | |
Bonmin::BabSetupBase * | bonBase_ |
options | |
ASL * | asl_ |
AMPL structure pointer (temporary --- looking forward to embedding into OS...). | |
int * | unusedOriginalsIndices_ |
some originals may be unused due to their zero multiplicity (that happens when they are duplicates). | |
int | nUnusedOriginals_ |
number of unused originals | |
int | lastPrioSort_ |
Couenne::CouenneRecordBestSol * | recBSol |
enum multiSep | multilinSep_ |
Type of Multilinear separation. | |
int | max_fbbt_iter_ |
number of FBBT iterations | |
bool | fbbtReachedIterLimit_ |
true if FBBT exited for iteration limits as opposed to inability to further tighten bounds | |
bool | orbitalBranching_ |
use orbital branching? | |
bool | checkAuxBounds_ |
check bounds on auxiliary variables when verifying MINLP feasibility of a solution. | |
enum TrilinDecompType | trilinDecompType_ |
return type of decomposition of quadrilinear terms | |
Private Types | |
UNFIXED | |
FIXED | |
CONTINUOUS | |
enum | fixType { UNFIXED, FIXED, CONTINUOUS } |
structure to record fixed, non-fixed, and continuous variables More... | |
Friends | |
class | exprMul |
It is read from an AMPL .nl file and contains variables, AMPL's "defined variables" (aka common expressions), objective(s), and constraints in the form of expression's. Changes throughout the program occur in standardization.
Definition at line 149 of file CouenneProblem.hpp.
enum Couenne::CouenneProblem::fixType [private] |
structure to record fixed, non-fixed, and continuous variables
Definition at line 154 of file CouenneProblem.hpp.
CouenneProblem::CouenneProblem | ( | ASL * | = NULL , |
|
Bonmin::BabSetupBase * | base = NULL , |
|||
JnlstPtr | jnlst = NULL | |||
) |
Constructor.
Definition at line 43 of file CouenneProblemConstructors.cpp.
References auxSet_, doPrint_, initOptions(), Couenne::J_PROBLEM(), jnlst_, lastPrioSort_, minDepthPrint_, minNodePrint_, and recBSol.
Referenced by clone().
CouenneProblem::CouenneProblem | ( | const CouenneProblem & | ) |
Copy constructor.
Definition at line 116 of file CouenneProblemConstructors.cpp.
References clone(), Con(), constraints_, Couenne::CouenneRecordBestSol::CouenneRecordBestSol(), domain_, doPrint_, integerRank_, lastPrioSort_, minDepthPrint_, minNodePrint_, nCons(), nObjs(), numbering_, nUnusedOriginals_, nVars(), Obj(), objectives_, objects_, optimum_, realign(), recBSol, unusedOriginalsIndices_, Var(), and variables_.
CouenneProblem::~CouenneProblem | ( | ) |
Destructor.
Definition at line 205 of file CouenneProblemConstructors.cpp.
References commuted_, constraints_, created_pcutoff_, graph_, integerRank_, numbering_, nVars(), objectives_, objects_, optimum_, pcutoff_, recBSol, unusedOriginalsIndices_, and variables_.
void CouenneProblem::initOptions | ( | Ipopt::SmartPtr< Ipopt::OptionsList > | options | ) |
initializes parameters like doOBBT
Definition at line 247 of file CouenneProblemConstructors.cpp.
References Couenne::bi_tri, doABT_, doFBBT_, doOBBT_, doRCBT_, feas_tolerance_, logAbtLev_, logObbtLev_, max_fbbt_iter_, MulSepNone, MulSepSimple, MulSepTight, multilinSep_, opt_window_, orbitalBranching_, Couenne::rAI, s, Couenne::treeDecomp, Couenne::tri_bi, trilinDecompType_, and useQuadratic_.
Referenced by CouenneProblem(), and main().
CouenneProblem* Couenne::CouenneProblem::clone | ( | ) | const [inline] |
Clone method (for use within CouenneCutGenerator::clone).
Definition at line 329 of file CouenneProblem.hpp.
References CouenneProblem().
Referenced by CouenneProblem(), and splitAux().
int Couenne::CouenneProblem::nObjs | ( | ) | const [inline] |
Get number of objectives.
Definition at line 332 of file CouenneProblem.hpp.
References objectives_.
Referenced by CouenneProblem().
int Couenne::CouenneProblem::nCons | ( | ) | const [inline] |
Get number of constraints.
Definition at line 333 of file CouenneProblem.hpp.
References constraints_.
Referenced by checkCons(), checkNLP(), CouenneProblem(), reformulate(), writeAMPL(), and writeGAMS().
int Couenne::CouenneProblem::nOrigCons | ( | ) | const [inline] |
Get number of original constraints.
Definition at line 334 of file CouenneProblem.hpp.
References nOrigCons_.
int Couenne::CouenneProblem::nOrigVars | ( | ) | const [inline] |
Number of orig. variables.
Definition at line 336 of file CouenneProblem.hpp.
References nOrigVars_.
Referenced by createUnusedOriginals(), and Couenne::InitHeuristic::InitHeuristic().
int Couenne::CouenneProblem::nDefVars | ( | ) | const [inline] |
Number of def'd variables.
Definition at line 337 of file CouenneProblem.hpp.
References ndefined_.
Referenced by Couenne::CouenneAmplInterface::readnl().
int Couenne::CouenneProblem::nOrigIntVars | ( | ) | const [inline] |
Number of original integers.
Definition at line 338 of file CouenneProblem.hpp.
References nOrigIntVars_.
int Couenne::CouenneProblem::nIntVars | ( | ) | const [inline] |
Number of integer variables.
Definition at line 339 of file CouenneProblem.hpp.
References nIntVars_.
Referenced by reformulate().
int Couenne::CouenneProblem::nVars | ( | ) | const [inline] |
Total number of variables.
Definition at line 340 of file CouenneProblem.hpp.
References variables_.
Referenced by aggressiveBT(), btCore(), checkAux(), checkNLP(), checkNLP2(), Couenne::CouenneAggrProbing::CouenneAggrProbing(), CouenneProblem(), createUnusedOriginals(), fake_tighten(), Couenne::CouenneIterativeRounding::feasibilityIR(), fillDependence(), fillIntegerRank(), getAuxs(), getIntegerCandidate(), impliedBounds(), Couenne::CouenneIterativeRounding::improvementIR(), initAuxs(), Couenne::InitHeuristic::InitHeuristic(), main(), obbt(), obbt_iter(), obbtInner(), print(), Couenne::exprQuad::quadCuts(), readOptimum(), redCostBT(), reformulate(), Couenne::CouenneSolverInterface< T >::resolve(), restoreUnusedOriginals(), Couenne::CouenneChooseStrong::setupList(), Couenne::CouenneFeasPump::solution(), standardize(), testIntFix(), tightenBounds(), writeAMPL(), writeGAMS(), and ~CouenneProblem().
void Couenne::CouenneProblem::setNDefVars | ( | int | ndefined__ | ) | [inline] |
std::vector<int>* Couenne::CouenneProblem::Find_Orbit | ( | int | ) | const |
void Couenne::CouenneProblem::sym_setup | ( | ) |
Referenced by setupSymmetry().
void Couenne::CouenneProblem::Compute_Symmetry | ( | ) | const |
Referenced by setupSymmetry().
void Couenne::CouenneProblem::Print_Orbits | ( | ) | const |
Referenced by setupSymmetry().
void Couenne::CouenneProblem::ChangeBounds | ( | const double * | , | |
const double * | , | |||
int | ||||
) | const |
Nauty* Couenne::CouenneProblem::getNtyInfo | ( | ) | [inline] |
void CouenneProblem::setupSymmetry | ( | ) |
empty if no NTY, symmetry data structure setup otherwise
Definition at line 426 of file CouenneSymmetry.cpp.
References Compute_Symmetry(), orbitalBranching_, Print_Orbits(), and sym_setup().
Referenced by reformulate().
int Couenne::CouenneProblem::evalOrder | ( | int | i | ) | const [inline] |
get evaluation order index
Definition at line 367 of file CouenneProblem.hpp.
References numbering_.
Referenced by aggressiveBT(), and call_iter().
int* Couenne::CouenneProblem::evalVector | ( | ) | [inline] |
get evaluation order vector (numbering_)
Definition at line 371 of file CouenneProblem.hpp.
References numbering_.
CouenneConstraint* Couenne::CouenneProblem::Con | ( | int | i | ) | const [inline] |
i-th constraint
Definition at line 375 of file CouenneProblem.hpp.
References constraints_.
Referenced by checkCons(), checkNLP(), CouenneProblem(), and writeGAMS().
CouenneObjective* Couenne::CouenneProblem::Obj | ( | int | i | ) | const [inline] |
i-th objective
Definition at line 376 of file CouenneProblem.hpp.
References objectives_.
Referenced by aggressiveBT(), boundTightening(), checkNLP(), checkObj(), CouenneProblem(), fake_tighten(), Couenne::CouenneCutGenerator::generateCuts(), getIntegerCandidate(), obbt_iter(), Couenne::CouenneAggrProbing::probeVariable(), Couenne::CouenneAggrProbing::probeVariable2(), redCostBT(), testIntFix(), and writeGAMS().
exprVar* Couenne::CouenneProblem::Var | ( | int | i | ) | const [inline] |
Return pointer to i-th variable.
Definition at line 379 of file CouenneProblem.hpp.
References variables_.
Referenced by aggressiveBT(), analyzeSparsity(), btCore(), CouenneSolver::buildSolverInstance(), call_iter(), CouenneProblem(), decomposeTerm(), fillIntegerRank(), getIntegerCandidate(), indcoe2vector(), installCutOff(), linStandardize(), main(), obbt_iter(), redCostBT(), resetCutOff(), setCutOff(), standardize(), tightenBounds(), and writeGAMS().
std::vector<exprVar *>& Couenne::CouenneProblem::Variables | ( | ) | [inline] |
Return vector of variables (symbolic representation).
Definition at line 383 of file CouenneProblem.hpp.
References variables_.
Referenced by CouenneSolver::createCouenneExpression(), and Couenne::CouenneAggrProbing::probeVariable2().
Return pointer to set for comparisons.
Definition at line 387 of file CouenneProblem.hpp.
References auxSet_.
DepGraph* Couenne::CouenneProblem::getDepGraph | ( | ) | [inline] |
Return pointer to dependence graph.
Definition at line 391 of file CouenneProblem.hpp.
References graph_.
Domain* Couenne::CouenneProblem::domain | ( | ) | const [inline] |
return current point & bounds
Definition at line 395 of file CouenneProblem.hpp.
References domain_.
Referenced by aggressiveBT(), CouenneSolver::buildSolverInstance(), Couenne::CouenneAggrProbing::probeVariable(), and reformulate().
std::vector<expression *>& Couenne::CouenneProblem::commonExprs | ( | ) | [inline] |
CouNumber& Couenne::CouenneProblem::X | ( | int | i | ) | const [inline] |
Definition at line 401 of file CouenneProblem.hpp.
References domain_, and Couenne::Domain::x().
Referenced by Couenne::exprQuad::quadCuts().
CouNumber& Couenne::CouenneProblem::Lb | ( | int | i | ) | const [inline] |
lower bound on
Definition at line 402 of file CouenneProblem.hpp.
References domain_, and Couenne::Domain::lb().
Referenced by Couenne::CouenneChooseStrong::chooseVariable(), Couenne::CouenneChooseStrong::doStrongBranching(), Couenne::fictitiousBound(), Couenne::CouenneDisjCuts::getDisjunctions(), Couenne::CouenneAggrProbing::probeVariable(), and Couenne::exprQuad::quadCuts().
CouNumber& Couenne::CouenneProblem::Ub | ( | int | i | ) | const [inline] |
upper bound on
Definition at line 403 of file CouenneProblem.hpp.
References domain_, and Couenne::Domain::ub().
Referenced by Couenne::CouenneChooseStrong::chooseVariable(), Couenne::CouenneChooseStrong::doStrongBranching(), Couenne::CouenneDisjCuts::getDisjunctions(), Couenne::CouenneAggrProbing::probeVariable(), and Couenne::exprQuad::quadCuts().
CouNumber* Couenne::CouenneProblem::X | ( | ) | const [inline] |
Return vector of variables.
Definition at line 406 of file CouenneProblem.hpp.
References domain_, and Couenne::Domain::x().
Referenced by aggressiveBT(), checkAux(), checkNLP(), getAuxs(), getIntegerCandidate(), initAuxs(), redCostBT(), reformulate(), restoreUnusedOriginals(), writeAMPL(), and writeGAMS().
CouNumber* Couenne::CouenneProblem::Lb | ( | ) | const [inline] |
Return vector of lower bounds.
Definition at line 407 of file CouenneProblem.hpp.
References domain_, and Couenne::Domain::lb().
Referenced by aggressiveBT(), boundTightening(), btCore(), checkCons(), checkNLP(), fake_tighten(), findSOS(), getAuxs(), getIntegerCandidate(), impliedBounds(), initAuxs(), obbt_iter(), readOptimum(), redCostBT(), reformulate(), standardize(), testIntFix(), tightenBounds(), writeAMPL(), and writeGAMS().
CouNumber* Couenne::CouenneProblem::Ub | ( | ) | const [inline] |
Return vector of upper bounds.
Definition at line 408 of file CouenneProblem.hpp.
References domain_, and Couenne::Domain::ub().
Referenced by aggressiveBT(), boundTightening(), btCore(), checkCons(), checkNLP(), fake_tighten(), findSOS(), getAuxs(), getIntegerCandidate(), impliedBounds(), initAuxs(), installCutOff(), obbt_iter(), readOptimum(), redCostBT(), reformulate(), standardize(), testIntFix(), tightenBounds(), writeAMPL(), and writeGAMS().
CouNumber*& Couenne::CouenneProblem::bestSol | ( | ) | const [inline] |
Best known solution (read from file).
Definition at line 411 of file CouenneProblem.hpp.
References optimum_.
CouNumber Couenne::CouenneProblem::bestObj | ( | ) | const [inline] |
Objective of best known solution.
Definition at line 412 of file CouenneProblem.hpp.
References bestObj_.
bool*& Couenne::CouenneProblem::Commuted | ( | ) | [inline] |
Get vector of commuted variables.
Definition at line 415 of file CouenneProblem.hpp.
References commuted_.
void CouenneProblem::addObjective | ( | expression * | , | |
const std::string & | = "min" | |||
) |
Add (non linear) objective function.
Definition at line 41 of file CouenneProblem.cpp.
References objectives_.
Referenced by CouenneSolver::buildSolverInstance().
void CouenneProblem::addEQConstraint | ( | expression * | , | |
expression * | = NULL | |||
) |
Add equality constraint .
Definition at line 51 of file CouenneProblem.cpp.
References constraints_.
Referenced by CouenneSolver::buildSolverInstance().
void CouenneProblem::addGEConstraint | ( | expression * | , | |
expression * | = NULL | |||
) |
Add constraint,
.
Definition at line 58 of file CouenneProblem.cpp.
References constraints_, and COUENNE_INFINITY.
Referenced by CouenneSolver::buildSolverInstance().
void CouenneProblem::addLEConstraint | ( | expression * | , | |
expression * | = NULL | |||
) |
Add constraint,
.
Definition at line 65 of file CouenneProblem.cpp.
References constraints_, and COUENNE_INFINITY.
Referenced by CouenneSolver::buildSolverInstance().
void CouenneProblem::addRNGConstraint | ( | expression * | , | |
expression * | = NULL , |
|||
expression * | = NULL | |||
) |
Add range constraint, .
Definition at line 79 of file CouenneProblem.cpp.
References constraints_.
Referenced by CouenneSolver::buildSolverInstance().
void CouenneProblem::setObjective | ( | int | indObj = 0 , |
|
expression * | = NULL , |
|||
const std::string & | = "min" | |||
) |
Add (non linear) objective function.
Definition at line 72 of file CouenneProblem.cpp.
References objectives_.
Referenced by obbt_iter(), and obbtInner().
expression * CouenneProblem::addVariable | ( | bool | isint = false , |
|
Domain * | d = NULL | |||
) |
Add original variable.
isint | if true, this variable is integer, otherwise it is continuous |
Definition at line 89 of file CouenneProblem.cpp.
References nIntVars_, nOrigVars_, and variables_.
Referenced by CouenneSolver::buildSolverInstance(), and Couenne::CouenneAggrProbing::probeVariable2().
exprAux * CouenneProblem::addAuxiliary | ( | expression * | ) |
Add auxiliary variable and associate it with expression given as argument (used in standardization).
Definition at line 108 of file CouenneProblem.cpp.
References auxSet_, domain_, graph_, Couenne::exprAux::Unset, variables_, and w.
Referenced by analyzeSparsity(), decomposeTerm(), and linStandardize().
void CouenneProblem::reformulate | ( | CouenneCutGenerator * | = NULL |
) |
preprocess problem in order to extract linear relaxations etc.
Definition at line 32 of file reformulate.cpp.
References bonBase_, checkNLP(), checkNLP2(), constraints_, COUENNE_INFINITY, createUnusedOriginals(), Couenne::Domain::current(), domain(), domain_, fillDependence(), fillQuadIndices(), getFeasTol(), getRecordBestSol(), initAuxs(), Couenne::isInteger(), Couenne::J_COUENNE(), Couenne::J_PROBLEM(), jnlst_, Couenne::Domain::lb(), Lb(), nCons(), nIntVars(), nIntVars_, nOrigCons_, nOrigIntVars_, nOrigVars_, nVars(), objectives_, orbitalBranching_, print(), Couenne::Domain::push(), readOptimum(), realign(), recBSol, setCutOff(), Couenne::CouenneRecordBestSol::setInitDomLb(), Couenne::CouenneRecordBestSol::setInitDomUb(), Couenne::CouenneRecordBestSol::setInitIsInt(), setupSymmetry(), standardize(), THRESHOLD_OUTPUT_REFORMULATE, Ub(), Couenne::CouenneRecordBestSol::update(), variables_, X(), and x.
bool CouenneProblem::standardize | ( | ) |
Break problem's nonlinear constraints in simple expressions to be convexified later.
Return true if problem looks feasible, false if proven infeasible.
re-check integrality. This is necessary as the initial integrality check is done on some continuous variables, which may turn out to be identical to other, integer, variables. See minlplib/ex1223.nl, where x_29 = x_4^2 and x_4=x_9, with x_4 declared continuous and x_9 integer
Definition at line 33 of file standardize.cpp.
References Couenne::AUX, Couenne::expression::AUX_EQ, auxiliarize(), auxSet_, bonBase_, commuted_, Couenne::CONSTANT, constraints_, COUENNE_BOUND_PREC, COUENNE_EPS, Couenne::Domain::current(), domain_, graph_, Couenne::isInteger(), Couenne::J_PROBLEM(), Couenne::J_REFORMULATE(), jnlst_, Lb(), Couenne::Domain::lb(), n, nOrigVars_, numbering_, nVars(), objectives_, print(), Ub(), Couenne::Domain::ub(), Var(), Couenne::VAR, variables_, and Couenne::Domain::x().
Referenced by decomposeTerm(), flattenMul(), reformulate(), and splitAux().
void CouenneProblem::print | ( | std::ostream & | = std::cout |
) |
Display current representation of problem: objective, linear and nonlinear constraints, and auxiliary variables.
Definition at line 24 of file problemIO.cpp.
References Couenne::AUX, Couenne::expression::AUX_EQ, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, bestObj_, commonexprs_, constraints_, COUENNE_EPS, COUENNE_INFINITY, domain_, Couenne::isInteger(), Couenne::J_REFORMULATE(), jnlst_, Couenne::Domain::lb(), nOrigVars_, nVars(), objectives_, optimum_, Couenne::Domain::ub(), and variables_.
Referenced by auxiliarize(), checkAux(), checkCons(), checkNLP(), flattenMul(), impliedBounds(), linStandardize(), obbt_iter(), reformulate(), splitAux(), standardize(), tightenBounds(), writeAMPL(), and writeGAMS().
bool Couenne::CouenneProblem::doFBBT | ( | ) | const [inline] |
shall we do Feasibility Based Bound Tightening?
Definition at line 462 of file CouenneProblem.hpp.
References doFBBT_.
bool Couenne::CouenneProblem::doRCBT | ( | ) | const [inline] |
shall we do reduced cost Bound Tightening?
Definition at line 463 of file CouenneProblem.hpp.
References doRCBT_.
bool Couenne::CouenneProblem::doOBBT | ( | ) | const [inline] |
shall we do Optimality Based Bound Tightening?
Definition at line 464 of file CouenneProblem.hpp.
References doOBBT_.
bool Couenne::CouenneProblem::doABT | ( | ) | const [inline] |
shall we do Aggressive Bound Tightening?
Definition at line 465 of file CouenneProblem.hpp.
References doABT_.
int Couenne::CouenneProblem::logObbtLev | ( | ) | const [inline] |
How often shall we do OBBT?
Definition at line 467 of file CouenneProblem.hpp.
References logObbtLev_.
int Couenne::CouenneProblem::logAbtLev | ( | ) | const [inline] |
How often shall we do ABT?
Definition at line 468 of file CouenneProblem.hpp.
References logAbtLev_.
void CouenneProblem::writeAMPL | ( | const std::string & | fname, | |
bool | aux | |||
) |
Write nonlinear problem to a .mod file (with lots of defined variables).
fname | Name of the .mod file to be written | |
aux | controls the use of auxiliaries. If true, a problem is written with auxiliary variables written with their associated expression, i.e. ![]() ![]() ![]() |
with or without auxiliaries?
aux | name of the mod file |
Definition at line 22 of file writeAMPL.cpp.
References Couenne::AUX, constraints_, COUENNE_EPS, COUENNE_INFINITY, f, Couenne::isInteger(), Lb(), nCons(), nVars(), objectives_, print(), Ub(), variables_, and X().
void CouenneProblem::writeGAMS | ( | const std::string & | fname | ) |
Write nonlinear problem to a .gms file.
fname | Name of the .gams file to be written. |
Definition at line 24 of file writeGAMS.cpp.
References Couenne::AUX, Con(), COUENNE_EPS, COUENNE_INFINITY, f, Couenne::isInteger(), Lb(), nCons(), nVars(), Obj(), print(), problemName_, Ub(), Var(), and X().
void CouenneProblem::initAuxs | ( | ) | const |
Initialize auxiliary variables and their bounds from original variables.
Definition at line 51 of file problem.cpp.
References Couenne::AUX, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, constraints_, COUENNE_EPS, COUENNE_INFINITY, Couenne::Domain::current(), domain_, Couenne::J_PROBLEM(), Jnlst(), Lb(), nOrigVars_, numbering_, nVars(), restoreUnusedOriginals(), Ub(), variables_, and X().
Referenced by getIntegerCandidate(), and reformulate().
void CouenneProblem::getAuxs | ( | CouNumber * | ) | const |
Get auxiliary variables from original variables.
Definition at line 153 of file problem.cpp.
References Couenne::AUX, Couenne::expression::AUX_EQ, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, commonexprs_, COUENNE_EPS, domain_, Lb(), Couenne::Domain::lb(), ndefined_, nOrigVars_, numbering_, nVars(), Couenne::Domain::pop(), Couenne::Domain::push(), restoreUnusedOriginals(), Ub(), Couenne::Domain::ub(), variables_, and X().
Referenced by aggressiveBT(), checkNLP(), checkNLP2(), Couenne::InitHeuristic::InitHeuristic(), and readOptimum().
bool CouenneProblem::boundTightening | ( | t_chg_bounds * | chg_bds, | |
Bonmin::BabInfo * | babInfo = NULL | |||
) | const |
tighten bounds using propagation, implied bounds and reduced costs
Return false if problem turns out to be infeasible with given bounds, true otherwise.
Definition at line 168 of file boundTightening.cpp.
References btCore(), Couenne::t_chg_bounds::CHANGED, COUENNE_EPS, COUENNE_INFINITY, Couenne::J_BOUNDTIGHTENING(), Jnlst(), Lb(), Obj(), Couenne::t_chg_bounds::setLower(), Couenne::t_chg_bounds::setUpper(), and Ub().
bool CouenneProblem::btCore | ( | t_chg_bounds * | chg_bds | ) | const |
core of the bound tightening procedure
Definition at line 25 of file boundTightening.cpp.
References Couenne::t_chg_bounds::CHANGED, COUENNE_BOUND_PREC, COUENNE_EPS, fbbtReachedIterLimit_, impliedBounds(), installCutOff(), Couenne::J_BOUNDTIGHTENING(), Jnlst(), Lb(), MAX_BOUND, max_fbbt_iter_, maxCpuTime_, nVars(), optimum_, Couenne::t_chg_bounds::setLower(), Couenne::t_chg_bounds::setUpper(), THRES_IMPROVED, tightenBounds(), Ub(), and Var().
Referenced by boundTightening(), fake_tighten(), obbt_iter(), and testIntFix().
int CouenneProblem::obbt | ( | const CouenneCutGenerator * | cg, | |
const OsiSolverInterface & | csi, | |||
OsiCuts & | cs, | |||
const CglTreeInfo & | info, | |||
Bonmin::BabInfo * | babInfo, | |||
t_chg_bounds * | chg_bds | |||
) |
Optimality Based Bound Tightening.
OBBT has tightened, add improved bounds
Definition at line 176 of file obbt.cpp.
References doOBBT_, isWiped(), Couenne::J_BOUNDTIGHTENING(), Couenne::J_COUENNE(), jnlst_, logObbtLev_, MAX_OBBT_ATTEMPTS, MAX_OBBT_ITER, maxCpuTime_, nVars(), obbtInner(), Couenne::sparse2dense(), and THRES_NBD_CHANGED.
bool CouenneProblem::aggressiveBT | ( | Bonmin::OsiTMINLPInterface * | nlp, | |
t_chg_bounds * | , | |||
const CglTreeInfo & | info, | |||
Bonmin::BabInfo * | = NULL | |||
) | const |
aggressive bound tightening.
Fake bounds in order to cut portions of the solution space by fathoming on bounds/infeasibility
Definition at line 62 of file aggressiveBT.cpp.
References Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, COUENNE_EPS, COUENNE_INFINITY, distanceToBound(), domain(), evalOrder(), fake_tighten(), getAuxs(), Bonmin::OsiTMINLPInterface::getColSolution(), getCutOff(), getIntegerCandidate(), getMaxCpuTime(), Bonmin::OsiTMINLPInterface::getObjValue(), Couenne::J_BOUNDTIGHTENING(), Couenne::J_COUENNE(), Jnlst(), jnlst_, Lb(), MAX_ABT_ITER, maxCpuTime_, ndefined_, Couenne::CouenneInfo::NlpSolutions(), nOrigVars_, nVars(), Obj(), THRES_ABT_IMPROVED, THRES_ABT_ORIG, Ub(), Var(), variables_, x, and X().
int CouenneProblem::redCostBT | ( | const OsiSolverInterface * | psi, | |
t_chg_bounds * | chg_bds | |||
) | const |
procedure to strengthen variable bounds.
Return false if problem turns out to be infeasible with given bounds, true otherwise.
Definition at line 219 of file boundTightening.cpp.
References Couenne::t_chg_bounds::CHANGED, CLOSE_TO_BOUNDS, COUENNE_EPS, COUENNE_INFINITY, getCutOff(), Couenne::isInteger(), Couenne::J_BOUNDTIGHTENING(), jnlst_, Lb(), nVars(), Obj(), Couenne::t_chg_bounds::setLower(), Couenne::t_chg_bounds::setUpper(), Ub(), Var(), x, and X().
int CouenneProblem::tightenBounds | ( | t_chg_bounds * | ) | const |
"Forward" bound tightening, that is, propagate bound of variable in an expression
to the bounds of
.
Definition at line 21 of file tightenBounds.cpp.
References Couenne::AUX, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, Couenne::t_chg_bounds::CHANGED, COUENNE_BOUND_PREC, COUENNE_EPS, COUENNE_INFINITY, domain_, Couenne::isInteger(), Couenne::J_BOUNDTIGHTENING(), Jnlst(), Lb(), ll, numbering_, nVars(), optimum_, print(), Couenne::t_chg_bounds::setLower(), Couenne::t_chg_bounds::setUpper(), Ub(), Var(), and variables_.
Referenced by btCore().
int CouenneProblem::impliedBounds | ( | t_chg_bounds * | ) | const |
"Backward" bound tightening, aka implied bounds.
Definition at line 20 of file impliedBounds.cpp.
References Couenne::AUX, COUENNE_BOUND_PREC, COUENNE_EPS, domain_, Couenne::J_BOUNDTIGHTENING(), Jnlst(), Couenne::Domain::lb(), Lb(), numbering_, nVars(), optimum_, print(), Couenne::Domain::ub(), Ub(), and variables_.
Referenced by btCore().
void CouenneProblem::fillQuadIndices | ( | ) |
Look for quadratic terms to be used with SDP cuts.
Definition at line 15 of file fillQuadIndices.cpp.
Referenced by reformulate().
void CouenneProblem::fillObjCoeff | ( | double *& | ) |
Fill vector with coefficients of objective function.
Definition at line 230 of file problem.cpp.
References Couenne::COU_EXPRCONST, Couenne::COU_EXPRGROUP, Couenne::COU_EXPRMUL, Couenne::COU_EXPRSUB, Couenne::COU_EXPRSUM, Couenne::COU_EXPRVAR, Couenne::J_PROBLEM(), Jnlst(), n, and objectives_.
Replace all occurrences of original variable with new aux given as argument.
Definition at line 27 of file auxiliarize.cpp.
References Couenne::AUX, commonexprs_, constraints_, graph_, Couenne::J_REFORMULATE(), jnlst_, objectives_, print(), replace(), Couenne::VAR, and variables_.
Referenced by standardize().
Set cutoff.
Definition at line 315 of file problem.cpp.
References COUENNE_EPS, getCutOff(), Couenne::isInteger(), Couenne::J_PROBLEM(), Jnlst(), objectives_, pcutoff_, and Var().
Referenced by Couenne::CouenneSetup::addMilpCutGenerators(), getIntegerCandidate(), Couenne::CouenneAggrProbing::probeVariable(), reformulate(), and resetCutOff().
void CouenneProblem::resetCutOff | ( | CouNumber | value = COUENNE_INFINITY |
) | const |
Reset cutoff.
Definition at line 334 of file problem.cpp.
References COUENNE_EPS, Couenne::isInteger(), objectives_, pcutoff_, setCutOff(), and Var().
Referenced by Couenne::CouenneAggrProbing::probeVariable().
CouNumber CouenneProblem::getCutOff | ( | ) | const |
Get cutoff.
Definition at line 242 of file CouenneProblem.cpp.
References pcutoff_.
Referenced by aggressiveBT(), Couenne::CouenneInterface::extractLinearRelaxation(), fake_tighten(), Couenne::CouenneIterativeRounding::feasibilityIR(), Couenne::CouenneCutGenerator::generateCuts(), getIntegerCandidate(), Couenne::CouenneIterativeRounding::improvementIR(), installCutOff(), Couenne::CouenneAggrProbing::probeVariable(), redCostBT(), and setCutOff().
CouNumber * CouenneProblem::getCutOffSol | ( | ) | const |
Get cutoff solution.
Definition at line 246 of file CouenneProblem.cpp.
References pcutoff_.
Referenced by Couenne::CouenneAggrProbing::probeVariable().
void CouenneProblem::installCutOff | ( | ) | const |
Make cutoff known to the problem.
Definition at line 349 of file problem.cpp.
References COUENNE_EPS, COUENNE_INFINITY, getCutOff(), Couenne::isInteger(), objectives_, pcutoff_, SafeCutoff, SafeDelta, Ub(), and Var().
Referenced by btCore(), and Couenne::CouenneAggrProbing::probeVariable().
ConstJnlstPtr CouenneProblem::Jnlst | ( | ) | const |
Provide Journalist.
Definition at line 250 of file CouenneProblem.cpp.
References jnlst_.
Referenced by aggressiveBT(), boundTightening(), btCore(), checkAux(), checkBounds(), checkCons(), checkInt(), checkNLP(), checkNLP2(), checkObj(), fake_tighten(), fillObjCoeff(), impliedBounds(), initAuxs(), obbt_iter(), setCutOff(), and tightenBounds().
bool CouenneProblem::checkNLP | ( | const double * | solution, | |
double & | obj, | |||
bool | recompute = false | |||
) | const |
Check if solution is MINLP feasible.
Definition at line 24 of file checkNLP.cpp.
References Couenne::AUX, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, c, Con(), COUENNE_EPS, COUENNE_INFINITY, COUENNE_round, Couenne::Domain::current(), diff(), domain_, e, feas_tolerance_, getAuxs(), infeasible, Couenne::J_PROBLEM(), Jnlst(), Lb(), Couenne::Domain::lb(), nCons(), ndefined_, nOrigVars_, nVars(), Obj(), Couenne::Domain::pop(), print(), Couenne::Domain::push(), ratio(), Ub(), Couenne::Domain::ub(), Couenne::VAR, variables_, X(), and Couenne::Domain::x().
Referenced by Couenne::CouenneIterativeRounding::feasibilityIR(), getIntegerCandidate(), Couenne::CouenneIterativeRounding::improvementIR(), Couenne::InitHeuristic::InitHeuristic(), main(), Couenne::CouenneAggrProbing::probeVariable(), reformulate(), Couenne::CouenneSolverInterface< T >::resolve(), and Couenne::CouenneChooseStrong::setupList().
int CouenneProblem::getIntegerCandidate | ( | const double * | xFrac, | |
double * | xInt, | |||
double * | lb, | |||
double * | ub | |||
) | const |
generate integer NLP point Y starting from fractional solution using bound tightening
Generate integer NLP point xInt starting from fractional solution xFrac, using (feasibility-based, i.e. cheap) bound tightening
return -1 if the problem is infeasible
Definition at line 34 of file getIntegerCandidate.cpp.
References checkNLP(), checkNLP2(), CONTINUOUS, COUENNE_EPS, COUENNE_round, domain_, feas_tolerance_, fillIntegerRank(), FIXED, getCutOff(), Couenne::CouenneRecordBestSol::getVal(), infeasible, initAuxs(), integerRank_, Couenne::isInteger(), Couenne::J_NLPHEURISTIC(), jnlst_, Lb(), maxCpuTime_, ndefined_, nOrigVars_, numberInRank_, nVars(), Obj(), optimum_, Couenne::Domain::pop(), Couenne::Domain::push(), recBSol, restoreUnusedOriginals(), setCutOff(), testIntFix(), Ub(), UNFIXED, Couenne::CouenneRecordBestSol::update(), Var(), variables_, x, and X().
Referenced by aggressiveBT().
bool CouenneProblem::readOptimum | ( | std::string * | fname = NULL |
) |
Read best known solution from file given in argument.
Definition at line 107 of file problemIO.cpp.
References bestObj_, f, getAuxs(), Lb(), nOrigVars_, nVars(), opt_window_, optimum_, problemName_, Ub(), and variables_.
Referenced by reformulate().
void CouenneProblem::registerOptions | ( | Ipopt::SmartPtr< Bonmin::RegisteredOptions > | roptions | ) | [static] |
Add list of options to be read from file.
Definition at line 401 of file problem.cpp.
References MAX_FBBT_ITER.
Referenced by Couenne::CouenneSetup::registerAllOptions().
exprAux * CouenneProblem::linStandardize | ( | bool | addAux, | |
CouNumber | c0, | |||
LinMap & | lmap, | |||
QuadMap & | qmap | |||
) |
standardization of linear exprOp's
data for exprQuad
data for exprGroup
Definition at line 28 of file linStandardize.cpp.
References addAuxiliary(), analyzeSparsity(), COUENNE_EPS, domain_, exprMul, indcoe2vector(), Couenne::J_REFORMULATE(), jnlst_, lc, li, Couenne::LinMap::Map(), Couenne::QuadMap::Map(), print(), and Var().
int CouenneProblem::splitAux | ( | CouNumber | , | |
expression * | , | |||
expression *& | , | |||
bool * | , | |||
enum expression::auxSign & | ||||
) |
split a constraint w - f(x) = c into w's index (it is returned) and rest = f(x) + c
Definition at line 36 of file splitAux.cpp.
References Couenne::AUX, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, clone(), Couenne::CONST, Couenne::CONSTANT, Couenne::COU_EXPRGROUP, Couenne::COU_EXPROPP, Couenne::COU_EXPRQUAD, Couenne::COU_EXPRSUB, Couenne::COU_EXPRSUM, COUENNE_EPS, domain_, elementBreak(), exprMul, indcoe2vector(), Couenne::isInteger(), Couenne::J_REFORMULATE(), jnlst_, n, print(), standardize(), Couenne::TAG_AND_RECURSIVE, and Couenne::VAR.
void CouenneProblem::indcoe2vector | ( | int * | indexL, | |
CouNumber * | coeff, | |||
std::vector< std::pair< exprVar *, CouNumber > > & | lcoeff | |||
) |
translates pair (indices, coefficients) into vector with pointers to variables
Definition at line 150 of file CouenneProblem.cpp.
References Var().
Referenced by linStandardize(), and splitAux().
void CouenneProblem::indcoe2vector | ( | int * | indexI, | |
int * | indexJ, | |||
CouNumber * | coeff, | |||
std::vector< quadElem > & | qcoeff | |||
) |
translates triplet (indicesI, indicesJ, coefficients) into vector with pointers to variables
Definition at line 161 of file CouenneProblem.cpp.
References Var().
void CouenneProblem::decomposeTerm | ( | expression * | term, | |
CouNumber | initCoe, | |||
CouNumber & | c0, | |||
LinMap & | lmap, | |||
QuadMap & | qmap | |||
) |
given (expression *) element of sum, returns (coe,ind0,ind1) depending on element:
1) a * x_i ^ 2 ---> (a,i,?) return COU_EXPRPOW 2) a * x_i ---> (a,i,?) return COU_EXPRVAR 3) a * x_i * x_j ---> (a,i,j) return COU_EXPRMUL 4) a ---> (a,?,?) return COU_EXPRCONST
x_i and/or x_j may come from standardizing other (linear or quadratic operator) sub-expressions
a constant
a variable
the opposite of a term
a subtraction
a quadratic form
a linear term
a sum of (possibly) nonlinear elements
a product of n factors /////////////////////////////////////////
otherwise, simply standardize expression
Definition at line 35 of file decomposeTerm.cpp.
References addAuxiliary(), Couenne::CONST, Couenne::COU_EXPRCONST, Couenne::COU_EXPRGROUP, Couenne::COU_EXPRMUL, Couenne::COU_EXPROPP, Couenne::COU_EXPRPOW, Couenne::COU_EXPRQUAD, Couenne::COU_EXPRSUB, Couenne::COU_EXPRSUM, Couenne::COU_EXPRVAR, COUENNE_EPS, exprMul, flattenMul(), Couenne::QuadMap::insert(), Couenne::LinMap::insert(), Couenne::J_REFORMULATE(), jnlst_, n, standardize(), and Var().
const std::string& Couenne::CouenneProblem::problemName | ( | ) | const [inline] |
void Couenne::CouenneProblem::setProblemName | ( | std::string & | problemName__ | ) | [inline] |
const std::vector<std::set <int> >& Couenne::CouenneProblem::Dependence | ( | ) | const [inline] |
return inverse dependence structure
Definition at line 618 of file CouenneProblem.hpp.
References dependence_.
const std::vector<CouenneObject *>& Couenne::CouenneProblem::Objects | ( | ) | const [inline] |
int CouenneProblem::findSOS | ( | CbcModel * | CbcModelPtr, | |
OsiSolverInterface * | solver, | |||
OsiObject ** | objects | |||
) |
find SOS constraints in problem
Definition at line 28 of file CouenneSOS.cpp.
References Couenne::AUX, Couenne::expression::AUX_EQ, Couenne::COU_EXPRGROUP, COUENNE_EPS, Couenne::isInteger(), Couenne::J_COUENNE(), jnlst_, Lb(), nOrigVars_, Ub(), and variables_.
void Couenne::CouenneProblem::setMaxCpuTime | ( | double | time | ) | [inline] |
double Couenne::CouenneProblem::getMaxCpuTime | ( | ) | const [inline] |
return maximum CPU time
Definition at line 635 of file CouenneProblem.hpp.
References maxCpuTime_.
Referenced by aggressiveBT().
void CouenneProblem::setBase | ( | Bonmin::BabSetupBase * | base | ) |
void CouenneProblem::createUnusedOriginals | ( | ) |
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
This procedure creates a structure for quickly checking and restoring their value after solving.
Definition at line 19 of file CouenneRestoreUnused.cpp.
References nOrigVars(), numbering_, nUnusedOriginals_, nVars(), unusedOriginalsIndices_, and variables_.
Referenced by reformulate().
void CouenneProblem::restoreUnusedOriginals | ( | CouNumber * | = NULL |
) | const |
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
This procedure restores their value after solving
Definition at line 54 of file CouenneRestoreUnused.cpp.
References domain_, nUnusedOriginals_, nVars(), Couenne::Domain::push(), unusedOriginalsIndices_, variables_, and X().
Referenced by checkNLP2(), getAuxs(), getIntegerCandidate(), and initAuxs().
int* Couenne::CouenneProblem::unusedOriginalsIndices | ( | ) | [inline] |
return indices of neglected redundant variables
Definition at line 653 of file CouenneProblem.hpp.
References unusedOriginalsIndices_.
int Couenne::CouenneProblem::nUnusedOriginals | ( | ) | [inline] |
number of unused originals
Definition at line 657 of file CouenneProblem.hpp.
References nUnusedOriginals_.
enum multiSep Couenne::CouenneProblem::MultilinSep | ( | ) | const [inline] |
return type of separator for multilinear terms
Definition at line 661 of file CouenneProblem.hpp.
References multilinSep_.
bool Couenne::CouenneProblem::fbbtReachedIterLimit | ( | ) | const [inline] |
true if latest call to FBBT terminated due to iteration limit reached
Definition at line 665 of file CouenneProblem.hpp.
References fbbtReachedIterLimit_.
bool Couenne::CouenneProblem::orbitalBranching | ( | ) | const [inline] |
return true if orbital branching activated
Definition at line 669 of file CouenneProblem.hpp.
References orbitalBranching_.
void Couenne::CouenneProblem::setCheckAuxBounds | ( | bool | value | ) | [inline] |
set the value for checkAuxBounds.
When true, all MINLP feasible solutions will additionally be tested for feasibility with respect to auxiliary variable bounds. This is normally not needed.
Definition at line 675 of file CouenneProblem.hpp.
References checkAuxBounds_.
Referenced by Couenne::CouenneAggrProbing::probeVariable().
bool Couenne::CouenneProblem::checkAuxBounds | ( | ) | const [inline] |
return true if bounds of auxiliary variables have to be satisfied whenever a solution is tested for MINLP feasibiliry
Definition at line 680 of file CouenneProblem.hpp.
References checkAuxBounds_.
enum TrilinDecompType Couenne::CouenneProblem::getTrilinDecompType | ( | ) | [inline] |
return type of decomposition of quadrilinear terms
Definition at line 684 of file CouenneProblem.hpp.
References trilinDecompType_.
Bonmin::BabSetupBase* Couenne::CouenneProblem::bonBase | ( | ) | const [inline] |
int CouenneProblem::fake_tighten | ( | char | direction, | |
int | index, | |||
const double * | X, | |||
CouNumber * | olb, | |||
CouNumber * | oub, | |||
t_chg_bounds * | chg_bds, | |||
t_chg_bounds * | f_chg | |||
) | const [protected] |
single fake tightening.
Return
-1 if infeasible 0 if no improvement +1 if improved
direction | 0: left, 1: right |
index | index of the variable tested |
X | point round which tightening is done |
olb | cur. lower bound |
oub | cur. upper bound |
Definition at line 86 of file fake_tightening.cpp.
References btCore(), Couenne::t_chg_bounds::CHANGED, COUENNE_EPS, diff(), Couenne::exp(), fictBounds(), getCutOff(), Couenne::isInteger(), Couenne::J_BOUNDTIGHTENING(), Jnlst(), jnlst_, Lb(), Couenne::log(), MAX_ITER, nVars(), Obj(), optimum_, Couenne::t_chg_bounds::setLower(), Couenne::t_chg_bounds::setUpper(), Ub(), and variables_.
Referenced by aggressiveBT().
int CouenneProblem::obbtInner | ( | OsiSolverInterface * | , | |
OsiCuts & | , | |||
t_chg_bounds * | , | |||
Bonmin::BabInfo * | ||||
) | const [protected] |
Optimality Based Bound Tightening -- inner loop.
Definition at line 98 of file obbt.cpp.
References Couenne::AUX, call_iter(), COUENNE_INFINITY, MAX_OBBT_LP_ITERATION, nVars(), setObjective(), THRESH_OBBT_AUX, and Couenne::VAR.
Referenced by obbt().
int CouenneProblem::obbt_iter | ( | OsiSolverInterface * | csi, | |
t_chg_bounds * | chg_bds, | |||
const CoinWarmStart * | warmstart, | |||
Bonmin::BabInfo * | babInfo, | |||
double * | objcoe, | |||
int | sense, | |||
int | index | |||
) | const [protected] |
Iteration on one variable.
Definition at line 59 of file obbt_iter.cpp.
References Couenne::AUX, Couenne::expression::AUX_EQ, btCore(), Couenne::t_chg_bounds::CHANGED, COUENNE_EPS, doFBBT_, Couenne::t_chg_bounds::EXACT, Couenne::isInteger(), Couenne::J_BOUNDTIGHTENING(), Jnlst(), jnlst_, Lb(), Couenne::LINEAR, Couenne::t_chg_bounds::lower(), nVars(), obbt_updateBound(), Obj(), optimum_, print(), Couenne::t_chg_bounds::setLowerBits(), setObjective(), Couenne::t_chg_bounds::setUpperBits(), Couenne::STOP_AT_AUX, Ub(), Couenne::VAR, and Var().
Referenced by call_iter().
int CouenneProblem::call_iter | ( | OsiSolverInterface * | csi, | |
t_chg_bounds * | chg_bds, | |||
const CoinWarmStart * | warmstart, | |||
Bonmin::BabInfo * | babInfo, | |||
double * | objcoe, | |||
enum nodeType | type, | |||
int | sense | |||
) | const [protected] |
Definition at line 42 of file obbt.cpp.
References Couenne::expression::AUX_EQ, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, evalOrder(), maxCpuTime_, obbt_iter(), Couenne::VAR, and Var().
Referenced by obbtInner().
analyze sparsity of potential exprQuad/exprGroup and change linear/quadratic maps accordingly, if necessary by adding new auxiliary variables and including them in the linear map
Definition at line 31 of file analyzeSparsity.cpp.
References addAuxiliary(), exprMul, Couenne::LinMap::insert(), Couenne::J_REFORMULATE(), jnlst_, Couenne::QuadMap::Map(), MIN_DENSITY, useQuadratic_, and Var().
Referenced by linStandardize().
void CouenneProblem::flattenMul | ( | expression * | mul, | |
CouNumber & | coe, | |||
std::map< int, CouNumber > & | indices | |||
) | [protected] |
re-organizes multiplication and stores indices (and exponents) of its variables
Definition at line 21 of file flattenMul.cpp.
References Couenne::CONST, Couenne::COU_EXPRCONST, Couenne::COU_EXPRMUL, Couenne::COU_EXPROPP, Couenne::COU_EXPRPOW, Couenne::COU_EXPRSUM, Couenne::COU_EXPRVAR, Couenne::J_REFORMULATE(), jnlst_, Couenne::N_ARY, print(), and standardize().
Referenced by decomposeTerm().
void CouenneProblem::realign | ( | ) | [protected] |
clear all spurious variables pointers not referring to the variables_ vector
Definition at line 375 of file problem.cpp.
References Couenne::AUX, constraints_, domain_, objectives_, and variables_.
Referenced by CouenneProblem(), and reformulate().
void CouenneProblem::fillDependence | ( | Bonmin::BabSetupBase * | base, | |
CouenneCutGenerator * | = NULL | |||
) | [protected] |
fill dependence_ structure
Definition at line 23 of file fillDependence.cpp.
References Couenne::AUX, dependence_, jnlst_, Couenne::LINEAR, nVars(), objects_, Couenne::STOP_AT_AUX, and variables_.
Referenced by reformulate().
void CouenneProblem::fillIntegerRank | ( | ) | const [protected] |
fill freeIntegers_ array
Definition at line 173 of file CouenneProblem.cpp.
References Couenne::AUX, integerRank_, Couenne::J_PROBLEM(), jnlst_, ndefined_, nOrigVars_, numbering_, numberInRank_, nVars(), Couenne::STOP_AT_AUX, Var(), and variables_.
Referenced by getIntegerCandidate().
int CouenneProblem::testIntFix | ( | int | index, | |
CouNumber | xFrac, | |||
enum fixType * | fixed, | |||
CouNumber * | xInt, | |||
CouNumber * | dualL, | |||
CouNumber * | dualR, | |||
CouNumber * | olb, | |||
CouNumber * | oub, | |||
bool | patient | |||
) | const [protected] |
Test fixing of an integer variable (used in getIntegerCandidate()).
Definition at line 19 of file testIntFix.cpp.
References btCore(), Couenne::t_chg_bounds::CHANGED, COUENNE_EPS, FIXED, Couenne::J_NLPHEURISTIC(), jnlst_, Lb(), nVars(), Obj(), Couenne::t_chg_bounds::setLower(), Couenne::t_chg_bounds::setUpper(), Ub(), and Couenne::t_chg_bounds::UNCHANGED.
Referenced by getIntegerCandidate().
int Couenne::CouenneProblem::getLastPrioSort | ( | ) | const [inline] |
Definition at line 761 of file CouenneProblem.hpp.
References lastPrioSort_.
Referenced by Couenne::CouenneChooseStrong::gutsOfSetupList().
void CouenneProblem::setLastPrioSort | ( | int | givenLastPS | ) |
Definition at line 254 of file CouenneProblem.cpp.
References lastPrioSort_.
Referenced by Couenne::CouenneChooseStrong::gutsOfSetupList().
CouenneRecordBestSol* Couenne::CouenneProblem::getRecordBestSol | ( | ) | const [inline] |
returns recorded best solution
Definition at line 768 of file CouenneProblem.hpp.
References recBSol.
Referenced by Couenne::CouenneSetup::addMilpCutGenerators(), checkNLP2(), Couenne::CouenneInterface::extractLinearRelaxation(), Couenne::CouenneIterativeRounding::feasibilityIR(), Couenne::CouenneCutGenerator::generateCuts(), Couenne::CouenneIterativeRounding::improvementIR(), Couenne::InitHeuristic::InitHeuristic(), main(), Couenne::CouenneCutGenerator::printLineInfo(), reformulate(), Couenne::CouenneSolverInterface< T >::resolve(), Couenne::CouenneChooseStrong::setupList(), Couenne::CouenneFeasPump::solution(), and Couenne::NlpSolveHeuristic::solution().
double Couenne::CouenneProblem::getFeasTol | ( | ) | [inline] |
returns feasibility tolerance
Definition at line 772 of file CouenneProblem.hpp.
References feas_tolerance_.
Referenced by Couenne::CouenneChooseStrong::chooseVariable(), Couenne::CouenneInterface::extractLinearRelaxation(), Couenne::CouenneIterativeRounding::feasibilityIR(), Couenne::CouenneChooseVariable::feasibleSolution(), Couenne::CouenneChooseStrong::feasibleSolution(), Couenne::CouenneIterativeRounding::improvementIR(), Couenne::InitHeuristic::InitHeuristic(), main(), reformulate(), Couenne::CouenneSolverInterface< T >::resolve(), Couenne::CouenneChooseStrong::setupList(), Couenne::CouenneFeasPump::solution(), and Couenne::NlpSolveHeuristic::solution().
double CouenneProblem::checkObj | ( | const CouNumber * | sol, | |
const double & | precision | |||
) | const |
Recompute objective value for sol.
Definition at line 284 of file checkNLP.cpp.
References Couenne::CouenneObjective::Body(), Couenne::expression::Image(), Couenne::expression::Index(), Couenne::J_PROBLEM(), Jnlst(), and Obj().
Referenced by checkNLP2().
bool CouenneProblem::checkInt | ( | const CouNumber * | sol, | |
const int | from, | |||
const int | upto, | |||
const std::vector< int > | listInt, | |||
const bool | origVarOnly, | |||
const bool | stopAtFirstViol, | |||
const double | precision, | |||
double & | maxViol | |||
) | const |
check integrality of vars in sol with index between from and upto (original vars only if origVarOnly == true); return true if all integer vars are within precision of an integer value
Definition at line 322 of file checkNLP.cpp.
References COUENNE_round, domain_, feas_tolerance_, Couenne::J_PROBLEM(), Jnlst(), Couenne::Domain::lb(), Couenne::Domain::ub(), Couenne::VAR, and variables_.
Referenced by checkNLP2().
bool CouenneProblem::checkBounds | ( | const CouNumber * | sol, | |
const bool | stopAtFirstViol, | |||
const double | precision, | |||
double & | maxViol | |||
) | const |
Check bounds; returns true iff feasible for given precision.
Definition at line 376 of file checkNLP.cpp.
References domain_, Couenne::J_PROBLEM(), Jnlst(), Couenne::Domain::lb(), ndefined_, nOrigVars_, Couenne::Domain::ub(), variables_, and Couenne::Domain::x().
Referenced by checkNLP2().
bool CouenneProblem::checkAux | ( | const CouNumber * | sol, | |
const bool | stopAtFirstViol, | |||
const double | precision, | |||
double & | maxViol | |||
) | const |
returns true iff value of all auxilliaries are within bounds
Definition at line 422 of file checkNLP.cpp.
References Couenne::AUX, Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, COUENNE_EPS, COUENNE_INFINITY, feas_tolerance_, Couenne::J_PROBLEM(), Jnlst(), nVars(), print(), ratio(), variables_, and X().
Referenced by checkNLP2().
bool CouenneProblem::checkCons | ( | const CouNumber * | sol, | |
const bool | stopAtFirstViol, | |||
const double | precision, | |||
double & | maxViol | |||
) | const |
returns true iff value of all auxilliaries are within bounds
Definition at line 508 of file checkNLP.cpp.
References c, Con(), COUENNE_INFINITY, Couenne::J_PROBLEM(), Jnlst(), Lb(), nCons(), print(), and Ub().
Referenced by checkNLP2().
bool CouenneProblem::checkNLP2 | ( | const double * | solution, | |
const double | obj, | |||
const bool | careAboutObj, | |||
const bool | stopAtFirstViol, | |||
const bool | checkAll, | |||
const double | precision | |||
) | const |
if careAboutObj is set to true, then stopAtFirstViol must be set to false too.
Definition at line 607 of file checkNLP.cpp.
References Couenne::AUX, checkAux(), checkBounds(), checkCons(), checkInt(), checkObj(), Couenne::Domain::current(), Couenne::DomainPoint::Dimension(), domain_, getAuxs(), Couenne::CouenneRecordBestSol::getInitDomLb(), Couenne::CouenneRecordBestSol::getInitDomUb(), Couenne::CouenneRecordBestSol::getInitIsInt(), Couenne::CouenneRecordBestSol::getListInt(), getRecordBestSol(), Couenne::J_PROBLEM(), Jnlst(), Couenne::Domain::lb(), ndefined_, nOrigVars_, nVars(), Couenne::Domain::pop(), Couenne::Domain::push(), recBSol, restoreUnusedOriginals(), Couenne::CouenneRecordBestSol::setModSol(), Couenne::Domain::ub(), Couenne::VAR, variables_, and Couenne::Domain::x().
Referenced by Couenne::CouenneInterface::extractLinearRelaxation(), Couenne::CouenneIterativeRounding::feasibilityIR(), Couenne::CouenneChooseVariable::feasibleSolution(), Couenne::CouenneChooseStrong::feasibleSolution(), getIntegerCandidate(), Couenne::CouenneIterativeRounding::improvementIR(), Couenne::InitHeuristic::InitHeuristic(), main(), reformulate(), Couenne::CouenneSolverInterface< T >::resolve(), Couenne::CouenneChooseStrong::setupList(), Couenne::CouenneFeasPump::solution(), and Couenne::NlpSolveHeuristic::solution().
friend class exprMul [friend] |
Definition at line 151 of file CouenneProblem.hpp.
Referenced by analyzeSparsity(), decomposeTerm(), linStandardize(), and splitAux().
Definition at line 168 of file CouenneProblem.hpp.
Referenced by Couenne::CouenneChooseStrong::chooseVariable(), CouenneProblem(), Couenne::CouenneChooseStrong::doStrongBranching(), Couenne::CouenneChooseStrong::gutsOfSetupList(), Couenne::CouenneCutGenerator::printLineInfo(), and Couenne::CouenneChooseStrong::setupList().
std::string Couenne::CouenneProblem::problemName_ [protected] |
problem name
Definition at line 173 of file CouenneProblem.hpp.
Referenced by problemName(), readOptimum(), setProblemName(), and writeGAMS().
std::vector<exprVar *> Couenne::CouenneProblem::variables_ [protected] |
Variables (original, auxiliary, and defined).
Definition at line 175 of file CouenneProblem.hpp.
Referenced by addAuxiliary(), addVariable(), aggressiveBT(), auxiliarize(), checkAux(), checkBounds(), checkInt(), checkNLP(), checkNLP2(), CouenneProblem(), createUnusedOriginals(), fake_tighten(), fillDependence(), fillIntegerRank(), findSOS(), getAuxs(), getIntegerCandidate(), impliedBounds(), initAuxs(), nVars(), print(), readOptimum(), realign(), reformulate(), restoreUnusedOriginals(), standardize(), tightenBounds(), Var(), Variables(), writeAMPL(), and ~CouenneProblem().
std::vector<CouenneObjective *> Couenne::CouenneProblem::objectives_ [protected] |
Definition at line 176 of file CouenneProblem.hpp.
Referenced by addObjective(), auxiliarize(), CouenneProblem(), fillObjCoeff(), installCutOff(), nObjs(), Obj(), print(), realign(), reformulate(), resetCutOff(), setCutOff(), setObjective(), standardize(), writeAMPL(), and ~CouenneProblem().
std::vector<CouenneConstraint *> Couenne::CouenneProblem::constraints_ [protected] |
Definition at line 177 of file CouenneProblem.hpp.
Referenced by addEQConstraint(), addGEConstraint(), addLEConstraint(), addRNGConstraint(), auxiliarize(), Con(), CouenneProblem(), initAuxs(), nCons(), print(), realign(), reformulate(), standardize(), writeAMPL(), and ~CouenneProblem().
std::vector<expression *> Couenne::CouenneProblem::commonexprs_ [protected] |
AMPL's common expressions (read from AMPL through structures cexps and cexps1).
Definition at line 180 of file CouenneProblem.hpp.
Referenced by auxiliarize(), commonExprs(), getAuxs(), and print().
Domain Couenne::CouenneProblem::domain_ [mutable, protected] |
current point and bounds;
Definition at line 182 of file CouenneProblem.hpp.
Referenced by addAuxiliary(), checkBounds(), checkInt(), checkNLP(), checkNLP2(), CouenneProblem(), domain(), getAuxs(), getIntegerCandidate(), impliedBounds(), initAuxs(), Lb(), linStandardize(), print(), realign(), reformulate(), restoreUnusedOriginals(), splitAux(), standardize(), tightenBounds(), Ub(), and X().
std::set<exprAux *, compExpr>* Couenne::CouenneProblem::auxSet_ [protected] |
Expression map for comparison in standardization and to count occurrences of an auxiliary.
Definition at line 186 of file CouenneProblem.hpp.
Referenced by addAuxiliary(), AuxSet(), CouenneProblem(), and standardize().
int Couenne::CouenneProblem::curnvars_ [mutable, protected] |
int Couenne::CouenneProblem::nIntVars_ [protected] |
Number of discrete variables.
Definition at line 192 of file CouenneProblem.hpp.
Referenced by addVariable(), nIntVars(), and reformulate().
CouNumber* Couenne::CouenneProblem::optimum_ [mutable, protected] |
Best solution known to be loaded from file -- for testing purposes.
Definition at line 195 of file CouenneProblem.hpp.
Referenced by bestSol(), btCore(), CouenneProblem(), fake_tighten(), getIntegerCandidate(), impliedBounds(), obbt_iter(), print(), readOptimum(), tightenBounds(), and ~CouenneProblem().
CouNumber Couenne::CouenneProblem::bestObj_ [protected] |
Best known objective function.
Definition at line 198 of file CouenneProblem.hpp.
Referenced by bestObj(), print(), and readOptimum().
int* Couenne::CouenneProblem::quadIndex_ [protected] |
Indices of variables appearing in products (used for SDP cuts).
Definition at line 201 of file CouenneProblem.hpp.
bool* Couenne::CouenneProblem::commuted_ [protected] |
Variables that have commuted to auxiliary.
Definition at line 204 of file CouenneProblem.hpp.
Referenced by Commuted(), standardize(), and ~CouenneProblem().
int* Couenne::CouenneProblem::numbering_ [protected] |
numbering of variables.
No variable xi with associated pi(i) greater than pi(j) should be evaluated before variable xj
Definition at line 208 of file CouenneProblem.hpp.
Referenced by CouenneProblem(), createUnusedOriginals(), evalOrder(), evalVector(), fillIntegerRank(), getAuxs(), impliedBounds(), initAuxs(), standardize(), tightenBounds(), and ~CouenneProblem().
int Couenne::CouenneProblem::ndefined_ [protected] |
Number of "defined variables" (aka "common expressions").
Definition at line 211 of file CouenneProblem.hpp.
Referenced by aggressiveBT(), checkBounds(), checkNLP(), checkNLP2(), fillIntegerRank(), getAuxs(), getIntegerCandidate(), nDefVars(), and setNDefVars().
DepGraph* Couenne::CouenneProblem::graph_ [protected] |
Dependence (acyclic) graph: shows dependence of all auxiliary variables on one another and on original variables.
Used to create a numbering of all variables for evaluation and bound tightening (reverse order for implied bounds)
Definition at line 217 of file CouenneProblem.hpp.
Referenced by addAuxiliary(), auxiliarize(), getDepGraph(), standardize(), and ~CouenneProblem().
int Couenne::CouenneProblem::nOrigVars_ [protected] |
Number of original variables.
Definition at line 220 of file CouenneProblem.hpp.
Referenced by addVariable(), aggressiveBT(), checkBounds(), checkNLP(), checkNLP2(), fillIntegerRank(), findSOS(), getAuxs(), getIntegerCandidate(), initAuxs(), nOrigVars(), print(), readOptimum(), reformulate(), and standardize().
int Couenne::CouenneProblem::nOrigCons_ [protected] |
Number of original constraints (disregarding those that turned into auxiliary variable definition).
Definition at line 224 of file CouenneProblem.hpp.
Referenced by nOrigCons(), and reformulate().
int Couenne::CouenneProblem::nOrigIntVars_ [protected] |
Number of original integer variables.
Definition at line 227 of file CouenneProblem.hpp.
Referenced by nOrigIntVars(), and reformulate().
GlobalCutOff* Couenne::CouenneProblem::pcutoff_ [mutable, protected] |
Pointer to a global cutoff object.
Definition at line 230 of file CouenneProblem.hpp.
Referenced by getCutOff(), getCutOffSol(), installCutOff(), resetCutOff(), setCutOff(), and ~CouenneProblem().
bool Couenne::CouenneProblem::created_pcutoff_ [mutable, protected] |
flag indicating if this class is creator of global cutoff object
Definition at line 233 of file CouenneProblem.hpp.
Referenced by ~CouenneProblem().
bool Couenne::CouenneProblem::doFBBT_ [protected] |
do Feasibility-based bound tightening
Definition at line 235 of file CouenneProblem.hpp.
Referenced by doFBBT(), initOptions(), and obbt_iter().
bool Couenne::CouenneProblem::doRCBT_ [protected] |
do reduced cost bound tightening
Definition at line 236 of file CouenneProblem.hpp.
Referenced by doRCBT(), and initOptions().
bool Couenne::CouenneProblem::doOBBT_ [protected] |
do Optimality-based bound tightening
Definition at line 237 of file CouenneProblem.hpp.
Referenced by doOBBT(), initOptions(), and obbt().
bool Couenne::CouenneProblem::doABT_ [protected] |
do Aggressive bound tightening
Definition at line 238 of file CouenneProblem.hpp.
Referenced by doABT(), and initOptions().
int Couenne::CouenneProblem::logObbtLev_ [protected] |
frequency of Optimality-based bound tightening
Definition at line 240 of file CouenneProblem.hpp.
Referenced by initOptions(), logObbtLev(), and obbt().
int Couenne::CouenneProblem::logAbtLev_ [protected] |
frequency of Aggressive bound tightening
Definition at line 241 of file CouenneProblem.hpp.
Referenced by initOptions(), and logAbtLev().
JnlstPtr Couenne::CouenneProblem::jnlst_ [protected] |
SmartPointer to the Journalist.
Definition at line 244 of file CouenneProblem.hpp.
Referenced by aggressiveBT(), analyzeSparsity(), auxiliarize(), CouenneProblem(), decomposeTerm(), fake_tighten(), fillDependence(), fillIntegerRank(), findSOS(), flattenMul(), getIntegerCandidate(), Jnlst(), linStandardize(), obbt(), obbt_iter(), print(), redCostBT(), reformulate(), setBase(), splitAux(), standardize(), and testIntFix().
CouNumber Couenne::CouenneProblem::opt_window_ [protected] |
window around known optimum (for testing purposes)
Definition at line 247 of file CouenneProblem.hpp.
Referenced by initOptions(), and readOptimum().
bool Couenne::CouenneProblem::useQuadratic_ [protected] |
Use quadratic expressions?
Definition at line 250 of file CouenneProblem.hpp.
Referenced by analyzeSparsity(), and initOptions().
CouNumber Couenne::CouenneProblem::feas_tolerance_ [protected] |
feasibility tolerance (to be used in checkNLP)
Definition at line 253 of file CouenneProblem.hpp.
Referenced by checkAux(), checkInt(), checkNLP(), getFeasTol(), getIntegerCandidate(), and initOptions().
std::vector<std::set <int> > Couenne::CouenneProblem::dependence_ [protected] |
inverse dependence structure: for each variable x give set of auxiliary variables (or better, their indices) whose expression depends on x
Definition at line 258 of file CouenneProblem.hpp.
Referenced by Dependence(), and fillDependence().
std::vector<CouenneObject *> Couenne::CouenneProblem::objects_ [protected] |
vector of pointer to CouenneObjects.
Used by CouenneVarObjects when finding all objects related to (having as argument) a single variable
Definition at line 263 of file CouenneProblem.hpp.
Referenced by CouenneProblem(), fillDependence(), Objects(), and ~CouenneProblem().
int* Couenne::CouenneProblem::integerRank_ [mutable, protected] |
each element is true if variable is integer and, if auxiliary, depends on no integer
Definition at line 267 of file CouenneProblem.hpp.
Referenced by CouenneProblem(), fillIntegerRank(), getIntegerCandidate(), and ~CouenneProblem().
std::vector<int> Couenne::CouenneProblem::numberInRank_ [mutable, protected] |
numberInRank_ [i] is the number of integer variables in rank i
Definition at line 270 of file CouenneProblem.hpp.
Referenced by fillIntegerRank(), and getIntegerCandidate().
double Couenne::CouenneProblem::maxCpuTime_ [protected] |
maximum cpu time
Definition at line 273 of file CouenneProblem.hpp.
Referenced by aggressiveBT(), btCore(), call_iter(), getIntegerCandidate(), getMaxCpuTime(), obbt(), and setMaxCpuTime().
Bonmin::BabSetupBase* Couenne::CouenneProblem::bonBase_ [protected] |
options
Definition at line 276 of file CouenneProblem.hpp.
Referenced by bonBase(), reformulate(), setBase(), and standardize().
ASL* Couenne::CouenneProblem::asl_ [protected] |
AMPL structure pointer (temporary --- looking forward to embedding into OS...).
Definition at line 279 of file CouenneProblem.hpp.
int* Couenne::CouenneProblem::unusedOriginalsIndices_ [protected] |
some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
This array keeps track of their indices and is sorted by evaluation order
Definition at line 284 of file CouenneProblem.hpp.
Referenced by CouenneProblem(), createUnusedOriginals(), restoreUnusedOriginals(), unusedOriginalsIndices(), and ~CouenneProblem().
int Couenne::CouenneProblem::nUnusedOriginals_ [protected] |
number of unused originals
Definition at line 287 of file CouenneProblem.hpp.
Referenced by CouenneProblem(), createUnusedOriginals(), nUnusedOriginals(), and restoreUnusedOriginals().
int Couenne::CouenneProblem::lastPrioSort_ [protected] |
Definition at line 290 of file CouenneProblem.hpp.
Referenced by CouenneProblem(), getLastPrioSort(), and setLastPrioSort().
struct Couenne::CouenneRecordBestSol* Couenne::CouenneProblem::recBSol [protected] |
Definition at line 293 of file CouenneProblem.hpp.
Referenced by checkNLP2(), CouenneProblem(), getIntegerCandidate(), getRecordBestSol(), reformulate(), and ~CouenneProblem().
enum multiSep Couenne::CouenneProblem::multilinSep_ [protected] |
Type of Multilinear separation.
Definition at line 296 of file CouenneProblem.hpp.
Referenced by initOptions(), and MultilinSep().
int Couenne::CouenneProblem::max_fbbt_iter_ [protected] |
number of FBBT iterations
Definition at line 299 of file CouenneProblem.hpp.
Referenced by btCore(), and initOptions().
bool Couenne::CouenneProblem::fbbtReachedIterLimit_ [mutable, protected] |
true if FBBT exited for iteration limits as opposed to inability to further tighten bounds
Definition at line 303 of file CouenneProblem.hpp.
Referenced by btCore(), and fbbtReachedIterLimit().
bool Couenne::CouenneProblem::orbitalBranching_ [protected] |
use orbital branching?
Definition at line 306 of file CouenneProblem.hpp.
Referenced by initOptions(), orbitalBranching(), reformulate(), and setupSymmetry().
bool Couenne::CouenneProblem::checkAuxBounds_ [protected] |
check bounds on auxiliary variables when verifying MINLP feasibility of a solution.
Usually this is not needed, unless some manipulation on auxiliary variables is done before Branch-and-Bound
Definition at line 312 of file CouenneProblem.hpp.
Referenced by checkAuxBounds(), and setCheckAuxBounds().
enum TrilinDecompType Couenne::CouenneProblem::trilinDecompType_ [protected] |
return type of decomposition of quadrilinear terms
Definition at line 315 of file CouenneProblem.hpp.
Referenced by getTrilinDecompType(), and initOptions().
std::vector<Node> Couenne::CouenneProblem::node_info [mutable] |
Definition at line 347 of file CouenneProblem.hpp.
Nauty* Couenne::CouenneProblem::nauty_info [mutable] |
Definition at line 350 of file CouenneProblem.hpp.
Definition at line 351 of file CouenneProblem.hpp.