Couenne 0.5.8
Loading...
Searching...
No Matches
Couenne::CouenneProblem Class Reference

Class for MINLP problems with symbolic information. More...

#include <CouenneProblem.hpp>

+ Collaboration diagram for Couenne::CouenneProblem:

Public Types

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
 
CouenneProblemclone () 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
 
NautygetNtyInfo ()
 
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_)
 
CouenneConstraintCon (int i) const
 i-th constraint
 
CouenneObjectiveObj (int i) const
 i-th objective
 
exprVarVar (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.
 
DepGraphgetDepGraph ()
 Return pointer to dependence graph.
 
Domaindomain () const
 return current point & bounds
 
std::vector< expression * > & commonExprs ()
 
CouNumberX (int i) const
 $x_i$
 
CouNumberLb (int i) const
 lower bound on $x_i$
 
CouNumberUb (int i) const
 upper bound on $x_i$
 
CouNumberX () const
 Return vector of variables.
 
CouNumberLb () const
 Return vector of lower bounds.
 
CouNumberUb () 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 $ h(x) = b$.
 
void addGEConstraint (expression *, expression *=NULL)
 Add $\ge$ constraint, $h(x)\ge b$.
 
void addLEConstraint (expression *, expression *=NULL)
 Add $\le$ constraint, $h(x)\le b$.
 
void addRNGConstraint (expression *, expression *=NULL, expression *=NULL)
 Add range constraint, $a\le h(x)\le b$.
 
void setObjective (int indObj=0, expression *=NULL, const std::string &="min")
 Add (non linear) objective function.
 
expressionaddVariable (bool isint=false, Domain *d=NULL)
 Add original variable.
 
exprAuxaddAuxiliary (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 writeLP (const std::string &fname)
 Write nonlinear problem to a .lp 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 *, const CglTreeInfo info, 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 $x$ in an expression $w = f(x)$ to the bounds of $w$.
 
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.
 
CouNumbergetCutOffSol () 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.
 
exprAuxlinStandardize (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::BabSetupBasebonBase () const
 options
 
double constObjVal () const
 returns constant objective value if it contains no variables
 
CouenneSdpCutsgetSdpCutGen ()
 Returns pointer to sdp cut generator.
 
int getLastPrioSort () const
 
void setLastPrioSort (int givenLastPS)
 
CouenneRecordBestSolgetRecordBestSol () 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 auxiliaries are within bounds
 
bool checkCons (const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const
 returns true iff value of all auxiliaries are within bounds
 
bool checkNLP2 (const double *solution, const double obj, const bool careAboutObj, const bool stopAtFirstViol, const bool checkAll, const double precision) const
 Return true if either solution or recomputed_solution obtained using getAuxs() from the original variables in solution is feasible within precision (the solution with minimum violation is then stored in recBSol->modSol, as well as its value and violation); return false otherwise.
 
bool checkNLP0 (const double *solution, double &obj, bool recompute_obj=false, const bool careAboutObj=false, const bool stopAtFirstViol=true, const bool checkAll=false, const double precision=-1) const
 And finally a method to get both.
 
std::vector< CouenneConstraint * > * ConstraintClass (const char *str)
 return particular constraint class.
 

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< Nodenode_info
 
Nautynauty_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
 
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.
 
CouNumberoptimum_
 Best solution known to be loaded from file – for testing purposes.
 
CouNumber bestObj_
 Best known objective function.
 
bool * commuted_
 Variables that have commuted to auxiliary.
 
int * numbering_
 numbering of variables.
 
int ndefined_
 Number of "defined variables" (aka "common expressions")
 
DepGraphgraph_
 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.
 
GlobalCutOffpcutoff_
 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::BabSetupBasebonBase_
 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_
 
CouenneRecordBestSolrecBSol
 
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
 
double constObjVal_
 constant value of the objective if no variable is declared in it
 
CouenneBTPerfIndicatorFBBTperfIndicator_
 Performance indicator for FBBT – to be moved away from CouenneProblem when we do it with FBBT.
 
CouenneBTPerfIndicatorOBBTperfIndicator_
 Performance indicator for OBBT – to be moved away from CouenneProblem.
 
std::map< const char *, std::vector< CouenneConstraint * > *, less_than_strConstraintClass_
 Return particular constraint class.
 
CouenneSdpCutssdpCutGen_
 Temporary pointer to SDP cut generator.
 

Friends

class exprMul
 

Detailed Description

Class for MINLP problems with symbolic information.

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 169 of file CouenneProblem.hpp.

Member Enumeration Documentation

◆ multiSep

Type of multilinear separation.

Enumerator
MulSepNone 
MulSepSimple 
MulSepTight 

Definition at line 179 of file CouenneProblem.hpp.

Constructor & Destructor Documentation

◆ CouenneProblem() [1/2]

Couenne::CouenneProblem::CouenneProblem ( ASL * = NULL,
Bonmin::BabSetupBase * base = NULL,
JnlstPtr jnlst = NULL )

Constructor.

◆ CouenneProblem() [2/2]

Couenne::CouenneProblem::CouenneProblem ( const CouenneProblem & )

Copy constructor.

◆ ~CouenneProblem()

Couenne::CouenneProblem::~CouenneProblem ( )

Destructor.

Member Function Documentation

◆ initOptions()

void Couenne::CouenneProblem::initOptions ( Ipopt::SmartPtr< Ipopt::OptionsList > options)

initializes parameters like doOBBT

◆ clone()

CouenneProblem * Couenne::CouenneProblem::clone ( ) const
inline

Clone method (for use within CouenneCutGenerator::clone)

Definition at line 369 of file CouenneProblem.hpp.

◆ nObjs()

int Couenne::CouenneProblem::nObjs ( ) const
inline

Get number of objectives.

Definition at line 372 of file CouenneProblem.hpp.

◆ nCons()

int Couenne::CouenneProblem::nCons ( ) const
inline

Get number of constraints.

Definition at line 373 of file CouenneProblem.hpp.

◆ nOrigCons()

int Couenne::CouenneProblem::nOrigCons ( ) const
inline

Get number of original constraints.

Definition at line 374 of file CouenneProblem.hpp.

◆ nOrigVars()

int Couenne::CouenneProblem::nOrigVars ( ) const
inline

Number of orig. variables.

Definition at line 376 of file CouenneProblem.hpp.

◆ nDefVars()

int Couenne::CouenneProblem::nDefVars ( ) const
inline

Number of def'd variables.

Definition at line 377 of file CouenneProblem.hpp.

◆ nOrigIntVars()

int Couenne::CouenneProblem::nOrigIntVars ( ) const
inline

Number of original integers.

Definition at line 378 of file CouenneProblem.hpp.

◆ nIntVars()

int Couenne::CouenneProblem::nIntVars ( ) const
inline

Number of integer variables.

Definition at line 379 of file CouenneProblem.hpp.

◆ nVars()

int Couenne::CouenneProblem::nVars ( ) const
inline

Total number of variables.

Definition at line 380 of file CouenneProblem.hpp.

◆ setNDefVars()

void Couenne::CouenneProblem::setNDefVars ( int ndefined__)
inline

Definition at line 382 of file CouenneProblem.hpp.

◆ Find_Orbit()

std::vector< int > * Couenne::CouenneProblem::Find_Orbit ( int ) const

◆ sym_setup()

void Couenne::CouenneProblem::sym_setup ( )

◆ Compute_Symmetry()

void Couenne::CouenneProblem::Compute_Symmetry ( ) const

◆ Print_Orbits()

void Couenne::CouenneProblem::Print_Orbits ( ) const

◆ ChangeBounds()

void Couenne::CouenneProblem::ChangeBounds ( const double * ,
const double * ,
int  ) const

◆ compare()

bool Couenne::CouenneProblem::compare ( register Node & a,
register Node & b ) const
inline

◆ getNtyInfo()

Nauty * Couenne::CouenneProblem::getNtyInfo ( )
inline

Definition at line 398 of file CouenneProblem.hpp.

◆ setupSymmetry()

void Couenne::CouenneProblem::setupSymmetry ( )

empty if no NTY, symmetry data structure setup otherwise

◆ evalOrder()

int Couenne::CouenneProblem::evalOrder ( int i) const
inline

get evaluation order index

Definition at line 407 of file CouenneProblem.hpp.

◆ evalVector()

int * Couenne::CouenneProblem::evalVector ( )
inline

get evaluation order vector (numbering_)

Definition at line 411 of file CouenneProblem.hpp.

◆ Con()

CouenneConstraint * Couenne::CouenneProblem::Con ( int i) const
inline

i-th constraint

Definition at line 415 of file CouenneProblem.hpp.

◆ Obj()

CouenneObjective * Couenne::CouenneProblem::Obj ( int i) const
inline

i-th objective

Definition at line 416 of file CouenneProblem.hpp.

◆ Var()

exprVar * Couenne::CouenneProblem::Var ( int i) const
inline

Return pointer to i-th variable.

Definition at line 419 of file CouenneProblem.hpp.

◆ Variables()

std::vector< exprVar * > & Couenne::CouenneProblem::Variables ( )
inline

Return vector of variables (symbolic representation)

Definition at line 423 of file CouenneProblem.hpp.

◆ AuxSet()

std::set< exprAux *, compExpr > *& Couenne::CouenneProblem::AuxSet ( )
inline

Return pointer to set for comparisons.

Definition at line 427 of file CouenneProblem.hpp.

◆ getDepGraph()

DepGraph * Couenne::CouenneProblem::getDepGraph ( )
inline

Return pointer to dependence graph.

Definition at line 431 of file CouenneProblem.hpp.

◆ domain()

Domain * Couenne::CouenneProblem::domain ( ) const
inline

return current point & bounds

Definition at line 435 of file CouenneProblem.hpp.

◆ commonExprs()

std::vector< expression * > & Couenne::CouenneProblem::commonExprs ( )
inline

Definition at line 438 of file CouenneProblem.hpp.

◆ X() [1/2]

CouNumber & Couenne::CouenneProblem::X ( int i) const
inline

$x_i$

Definition at line 441 of file CouenneProblem.hpp.

◆ Lb() [1/2]

CouNumber & Couenne::CouenneProblem::Lb ( int i) const
inline

lower bound on $x_i$

Definition at line 442 of file CouenneProblem.hpp.

◆ Ub() [1/2]

CouNumber & Couenne::CouenneProblem::Ub ( int i) const
inline

upper bound on $x_i$

Definition at line 443 of file CouenneProblem.hpp.

◆ X() [2/2]

CouNumber * Couenne::CouenneProblem::X ( ) const
inline

Return vector of variables.

Definition at line 446 of file CouenneProblem.hpp.

◆ Lb() [2/2]

CouNumber * Couenne::CouenneProblem::Lb ( ) const
inline

Return vector of lower bounds.

Definition at line 447 of file CouenneProblem.hpp.

◆ Ub() [2/2]

CouNumber * Couenne::CouenneProblem::Ub ( ) const
inline

Return vector of upper bounds.

Definition at line 448 of file CouenneProblem.hpp.

◆ bestSol()

CouNumber *& Couenne::CouenneProblem::bestSol ( ) const
inline

Best known solution (read from file)

Definition at line 451 of file CouenneProblem.hpp.

◆ bestObj()

CouNumber Couenne::CouenneProblem::bestObj ( ) const
inline

Objective of best known solution.

Definition at line 452 of file CouenneProblem.hpp.

◆ Commuted()

bool *& Couenne::CouenneProblem::Commuted ( )
inline

Get vector of commuted variables.

Definition at line 455 of file CouenneProblem.hpp.

◆ addObjective()

void Couenne::CouenneProblem::addObjective ( expression * ,
const std::string & = "min" )

Add (non linear) objective function.

◆ addEQConstraint()

void Couenne::CouenneProblem::addEQConstraint ( expression * ,
expression * = NULL )

Add equality constraint $ h(x) = b$.

◆ addGEConstraint()

void Couenne::CouenneProblem::addGEConstraint ( expression * ,
expression * = NULL )

Add $\ge$ constraint, $h(x)\ge b$.

◆ addLEConstraint()

void Couenne::CouenneProblem::addLEConstraint ( expression * ,
expression * = NULL )

Add $\le$ constraint, $h(x)\le b$.

◆ addRNGConstraint()

void Couenne::CouenneProblem::addRNGConstraint ( expression * ,
expression * = NULL,
expression * = NULL )

Add range constraint, $a\le h(x)\le b$.

◆ setObjective()

void Couenne::CouenneProblem::setObjective ( int indObj = 0,
expression * = NULL,
const std::string & = "min" )

Add (non linear) objective function.

◆ addVariable()

expression * Couenne::CouenneProblem::addVariable ( bool isint = false,
Domain * d = NULL )

Add original variable.

Parameters
isintif true, this variable is integer, otherwise it is continuous

◆ addAuxiliary()

exprAux * Couenne::CouenneProblem::addAuxiliary ( expression * )

Add auxiliary variable and associate it with expression given as argument (used in standardization)

◆ reformulate()

void Couenne::CouenneProblem::reformulate ( CouenneCutGenerator * = NULL)

preprocess problem in order to extract linear relaxations etc.

◆ standardize()

bool Couenne::CouenneProblem::standardize ( )

Break problem's nonlinear constraints in simple expressions to be convexified later.

Return true if problem looks feasible, false if proven infeasible.

◆ print()

void Couenne::CouenneProblem::print ( std::ostream & = std::cout)

Display current representation of problem: objective, linear and nonlinear constraints, and auxiliary variables.

◆ doFBBT()

bool Couenne::CouenneProblem::doFBBT ( ) const
inline

shall we do Feasibility Based Bound Tightening?

Definition at line 502 of file CouenneProblem.hpp.

◆ doRCBT()

bool Couenne::CouenneProblem::doRCBT ( ) const
inline

shall we do reduced cost Bound Tightening?

Definition at line 503 of file CouenneProblem.hpp.

◆ doOBBT()

bool Couenne::CouenneProblem::doOBBT ( ) const
inline

shall we do Optimality Based Bound Tightening?

Definition at line 504 of file CouenneProblem.hpp.

◆ doABT()

bool Couenne::CouenneProblem::doABT ( ) const
inline

shall we do Aggressive Bound Tightening?

Definition at line 505 of file CouenneProblem.hpp.

◆ logObbtLev()

int Couenne::CouenneProblem::logObbtLev ( ) const
inline

How often shall we do OBBT?

Definition at line 507 of file CouenneProblem.hpp.

◆ logAbtLev()

int Couenne::CouenneProblem::logAbtLev ( ) const
inline

How often shall we do ABT?

Definition at line 508 of file CouenneProblem.hpp.

◆ writeAMPL()

void Couenne::CouenneProblem::writeAMPL ( const std::string & fname,
bool aux )

Write nonlinear problem to a .mod file (with lots of defined variables)

Parameters
fnameName of the .mod file to be written
auxcontrols the use of auxiliaries. If true, a problem is written with auxiliary variables written with their associated expression, i.e. $w_i = h_i(x,y,w)$ and bounds $l_i \le w_i \le u_i$, while if false these constraints are written in the form $l_i \le h_i (x,y) \le u_i$.

Note: if used before standardization, writes original AMPL formulation

◆ writeGAMS()

void Couenne::CouenneProblem::writeGAMS ( const std::string & fname)

Write nonlinear problem to a .gms file.

Parameters
fnameName of the .gams file to be written.

◆ writeLP()

void Couenne::CouenneProblem::writeLP ( const std::string & fname)

Write nonlinear problem to a .lp file.

Note: only works with MIQCQPs (and MISOCPs in the future)

Parameters
fnameName of the .lp file to be written

◆ initAuxs()

void Couenne::CouenneProblem::initAuxs ( ) const

Initialize auxiliary variables and their bounds from original variables.

◆ getAuxs()

void Couenne::CouenneProblem::getAuxs ( CouNumber * ) const

Get auxiliary variables from original variables.

◆ boundTightening()

bool Couenne::CouenneProblem::boundTightening ( t_chg_bounds * ,
const CglTreeInfo info,
Bonmin::BabInfo * = NULL ) const

tighten bounds using propagation, implied bounds and reduced costs

◆ btCore()

bool Couenne::CouenneProblem::btCore ( t_chg_bounds * chg_bds) const

core of the bound tightening procedure

◆ obbt()

int Couenne::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.

◆ aggressiveBT()

bool Couenne::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

◆ redCostBT()

int Couenne::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.

◆ tightenBounds()

int Couenne::CouenneProblem::tightenBounds ( t_chg_bounds * ) const

"Forward" bound tightening, that is, propagate bound of variable $x$ in an expression $w = f(x)$ to the bounds of $w$.

◆ impliedBounds()

int Couenne::CouenneProblem::impliedBounds ( t_chg_bounds * ) const

"Backward" bound tightening, aka implied bounds.

◆ fillQuadIndices()

void Couenne::CouenneProblem::fillQuadIndices ( )

Look for quadratic terms to be used with SDP cuts.

◆ fillObjCoeff()

void Couenne::CouenneProblem::fillObjCoeff ( double *& )

Fill vector with coefficients of objective function.

◆ auxiliarize()

void Couenne::CouenneProblem::auxiliarize ( exprVar * ,
exprVar * = NULL )

Replace all occurrences of original variable with new aux given as argument.

◆ setCutOff()

void Couenne::CouenneProblem::setCutOff ( CouNumber cutoff,
const CouNumber * sol = NULL ) const

Set cutoff.

◆ resetCutOff()

void Couenne::CouenneProblem::resetCutOff ( CouNumber value = COUENNE_INFINITY) const

Reset cutoff.

◆ getCutOff()

CouNumber Couenne::CouenneProblem::getCutOff ( ) const

Get cutoff.

◆ getCutOffSol()

CouNumber * Couenne::CouenneProblem::getCutOffSol ( ) const

Get cutoff solution.

◆ installCutOff()

void Couenne::CouenneProblem::installCutOff ( ) const

Make cutoff known to the problem.

◆ Jnlst()

ConstJnlstPtr Couenne::CouenneProblem::Jnlst ( ) const

Provide Journalist.

◆ checkNLP()

bool Couenne::CouenneProblem::checkNLP ( const double * solution,
double & obj,
bool recompute = false ) const

Check if solution is MINLP feasible.

◆ getIntegerCandidate()

int Couenne::CouenneProblem::getIntegerCandidate ( const double * xFrac,
double * xInt,
double * lb,
double * ub ) const

generate integer NLP point Y starting from fractional solution using bound tightening

◆ readOptimum()

bool Couenne::CouenneProblem::readOptimum ( std::string * fname = NULL)

Read best known solution from file given in argument.

◆ registerOptions()

static void Couenne::CouenneProblem::registerOptions ( Ipopt::SmartPtr< Bonmin::RegisteredOptions > roptions)
static

Add list of options to be read from file.

◆ linStandardize()

exprAux * Couenne::CouenneProblem::linStandardize ( bool addAux,
CouNumber c0,
LinMap & lmap,
QuadMap & qmap )

standardization of linear exprOp's

◆ splitAux()

int Couenne::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

◆ indcoe2vector() [1/2]

void Couenne::CouenneProblem::indcoe2vector ( int * indexL,
CouNumber * coeff,
std::vector< std::pair< exprVar *, CouNumber > > & lcoeff )

translates pair (indices, coefficients) into vector with pointers to variables

◆ indcoe2vector() [2/2]

void Couenne::CouenneProblem::indcoe2vector ( int * indexI,
int * indexJ,
CouNumber * coeff,
std::vector< quadElem > & qcoeff )

translates triplet (indicesI, indicesJ, coefficients) into vector with pointers to variables

◆ decomposeTerm()

void Couenne::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

◆ problemName()

const std::string & Couenne::CouenneProblem::problemName ( ) const
inline

return problem name

Definition at line 658 of file CouenneProblem.hpp.

◆ setProblemName()

void Couenne::CouenneProblem::setProblemName ( std::string & problemName__)
inline

Definition at line 661 of file CouenneProblem.hpp.

◆ Dependence()

const std::vector< std::set< int > > & Couenne::CouenneProblem::Dependence ( ) const
inline

return inverse dependence structure

Definition at line 665 of file CouenneProblem.hpp.

◆ Objects()

const std::vector< CouenneObject * > & Couenne::CouenneProblem::Objects ( ) const
inline

return object vector

Definition at line 669 of file CouenneProblem.hpp.

◆ findSOS()

int Couenne::CouenneProblem::findSOS ( CbcModel * CbcModelPtr,
OsiSolverInterface * solver,
OsiObject ** objects )

find SOS constraints in problem

◆ setMaxCpuTime()

void Couenne::CouenneProblem::setMaxCpuTime ( double time)
inline

set maximum CPU time

Definition at line 678 of file CouenneProblem.hpp.

◆ getMaxCpuTime()

double Couenne::CouenneProblem::getMaxCpuTime ( ) const
inline

return maximum CPU time

Definition at line 682 of file CouenneProblem.hpp.

◆ setBase()

void Couenne::CouenneProblem::setBase ( Bonmin::BabSetupBase * base)

save CouenneBase

◆ createUnusedOriginals()

void Couenne::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.

◆ restoreUnusedOriginals()

void Couenne::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

◆ unusedOriginalsIndices()

int * Couenne::CouenneProblem::unusedOriginalsIndices ( )
inline

return indices of neglected redundant variables

Definition at line 700 of file CouenneProblem.hpp.

◆ nUnusedOriginals()

int Couenne::CouenneProblem::nUnusedOriginals ( )
inline

number of unused originals

Definition at line 704 of file CouenneProblem.hpp.

◆ MultilinSep()

enum multiSep Couenne::CouenneProblem::MultilinSep ( ) const
inline

return type of separator for multilinear terms

Definition at line 708 of file CouenneProblem.hpp.

◆ fbbtReachedIterLimit()

bool Couenne::CouenneProblem::fbbtReachedIterLimit ( ) const
inline

true if latest call to FBBT terminated due to iteration limit reached

Definition at line 712 of file CouenneProblem.hpp.

◆ orbitalBranching()

bool Couenne::CouenneProblem::orbitalBranching ( ) const
inline

return true if orbital branching activated

Definition at line 716 of file CouenneProblem.hpp.

◆ setCheckAuxBounds()

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 722 of file CouenneProblem.hpp.

◆ checkAuxBounds()

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 727 of file CouenneProblem.hpp.

◆ getTrilinDecompType()

enum TrilinDecompType Couenne::CouenneProblem::getTrilinDecompType ( )
inline

return type of decomposition of quadrilinear terms

Definition at line 731 of file CouenneProblem.hpp.

◆ bonBase()

Bonmin::BabSetupBase * Couenne::CouenneProblem::bonBase ( ) const
inline

options

Definition at line 735 of file CouenneProblem.hpp.

◆ constObjVal()

double Couenne::CouenneProblem::constObjVal ( ) const
inline

returns constant objective value if it contains no variables

Definition at line 738 of file CouenneProblem.hpp.

◆ getSdpCutGen()

CouenneSdpCuts * Couenne::CouenneProblem::getSdpCutGen ( )
inline

Returns pointer to sdp cut generator.

Definition at line 741 of file CouenneProblem.hpp.

◆ fake_tighten()

int Couenne::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

Parameters
direction0: left, 1: right
indexindex of the variable tested
Xpoint round which tightening is done
olbcur. lower bound
oubcur. upper bound

◆ obbtInner()

int Couenne::CouenneProblem::obbtInner ( OsiSolverInterface * ,
OsiCuts & ,
t_chg_bounds * ,
Bonmin::BabInfo *  ) const
protected

Optimality Based Bound Tightening – inner loop.

◆ obbt_iter()

int Couenne::CouenneProblem::obbt_iter ( OsiSolverInterface * csi,
t_chg_bounds * chg_bds,
const CoinWarmStart * warmstart,
Bonmin::BabInfo * babInfo,
double * objcoe,
int sense,
int index ) const
protected

◆ call_iter()

int Couenne::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

◆ analyzeSparsity()

void Couenne::CouenneProblem::analyzeSparsity ( CouNumber ,
LinMap & ,
QuadMap &  )
protected

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

◆ flattenMul()

void Couenne::CouenneProblem::flattenMul ( expression * mul,
CouNumber & coe,
std::map< int, CouNumber > & indices )
protected

re-organizes multiplication and stores indices (and exponents) of its variables

◆ realign()

void Couenne::CouenneProblem::realign ( )
protected

clear all spurious variables pointers not referring to the variables_ vector

◆ fillDependence()

void Couenne::CouenneProblem::fillDependence ( Bonmin::BabSetupBase * base,
CouenneCutGenerator * = NULL )
protected

fill dependence_ structure

◆ fillIntegerRank()

void Couenne::CouenneProblem::fillIntegerRank ( ) const
protected

fill freeIntegers_ array

◆ testIntFix()

int Couenne::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())

◆ getLastPrioSort()

int Couenne::CouenneProblem::getLastPrioSort ( ) const
inline

Definition at line 814 of file CouenneProblem.hpp.

◆ setLastPrioSort()

void Couenne::CouenneProblem::setLastPrioSort ( int givenLastPS)

◆ getRecordBestSol()

CouenneRecordBestSol * Couenne::CouenneProblem::getRecordBestSol ( ) const
inline

returns recorded best solution

Definition at line 821 of file CouenneProblem.hpp.

◆ getFeasTol()

double Couenne::CouenneProblem::getFeasTol ( )
inline

returns feasibility tolerance

Definition at line 825 of file CouenneProblem.hpp.

◆ checkObj()

double Couenne::CouenneProblem::checkObj ( const CouNumber * sol,
const double & precision ) const

Recompute objective value for sol.

◆ checkInt()

bool Couenne::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

◆ checkBounds()

bool Couenne::CouenneProblem::checkBounds ( const CouNumber * sol,
const bool stopAtFirstViol,
const double precision,
double & maxViol ) const

Check bounds; returns true iff feasible for given precision.

◆ checkAux()

bool Couenne::CouenneProblem::checkAux ( const CouNumber * sol,
const bool stopAtFirstViol,
const double precision,
double & maxViol ) const

returns true iff value of all auxiliaries are within bounds

◆ checkCons()

bool Couenne::CouenneProblem::checkCons ( const CouNumber * sol,
const bool stopAtFirstViol,
const double precision,
double & maxViol ) const

returns true iff value of all auxiliaries are within bounds

◆ checkNLP2()

bool Couenne::CouenneProblem::checkNLP2 ( const double * solution,
const double obj,
const bool careAboutObj,
const bool stopAtFirstViol,
const bool checkAll,
const double precision ) const

Return true if either solution or recomputed_solution obtained using getAuxs() from the original variables in solution is feasible within precision (the solution with minimum violation is then stored in recBSol->modSol, as well as its value and violation); return false otherwise.

If stopAtFirstViol == true, recBSol->modSol is meaningless upon return. If stopAtFirstViol == false, recBSol->modSol contains the solution with minimum violation, although this violation might be larger than precision. This is useful for cases where the current solution must be considered valid (e.g., because Cbc is going to accept it anyway), although it violates precision requirements. Value of obj matters only if careAboutObj == true; the code then tries to balance violation of constraints and value of objective. if checkAll = false, check only integrality/bounds for original vars and constraints; consider only recomputed_sol if checkAll == true, check also integrality/bounds on auxs; consider both recomputed_sol and solution if careAboutObj is set to true, then stopAtFirstViol must be set to false too.

◆ checkNLP0()

bool Couenne::CouenneProblem::checkNLP0 ( const double * solution,
double & obj,
bool recompute_obj = false,
const bool careAboutObj = false,
const bool stopAtFirstViol = true,
const bool checkAll = false,
const double precision = -1 ) const

And finally a method to get both.

◆ ConstraintClass()

std::vector< CouenneConstraint * > * Couenne::CouenneProblem::ConstraintClass ( const char * str)
inline

return particular constraint class.

Classes:

1) "convex": convex constraints; 2) "PSDcon": constraints of the form X \succeq 0 3) "normal": regular constraints

Definition at line 900 of file CouenneProblem.hpp.

Friends And Related Symbol Documentation

◆ exprMul

friend class exprMul
friend

Definition at line 171 of file CouenneProblem.hpp.

Member Data Documentation

◆ minDepthPrint_

int Couenne::CouenneProblem::minDepthPrint_

Definition at line 182 of file CouenneProblem.hpp.

◆ minNodePrint_

int Couenne::CouenneProblem::minNodePrint_

Definition at line 185 of file CouenneProblem.hpp.

◆ doPrint_

bool Couenne::CouenneProblem::doPrint_

Definition at line 188 of file CouenneProblem.hpp.

◆ problemName_

std::string Couenne::CouenneProblem::problemName_
protected

problem name

Definition at line 193 of file CouenneProblem.hpp.

◆ variables_

std::vector<exprVar *> Couenne::CouenneProblem::variables_
protected

Variables (original, auxiliary, and defined)

Definition at line 195 of file CouenneProblem.hpp.

◆ objectives_

std::vector<CouenneObjective *> Couenne::CouenneProblem::objectives_
protected

Objectives.

Definition at line 196 of file CouenneProblem.hpp.

◆ constraints_

std::vector<CouenneConstraint *> Couenne::CouenneProblem::constraints_
protected

Constraints.

Definition at line 197 of file CouenneProblem.hpp.

◆ commonexprs_

std::vector<expression *> Couenne::CouenneProblem::commonexprs_
protected

AMPL's common expressions (read from AMPL through structures cexps and cexps1)

Definition at line 200 of file CouenneProblem.hpp.

◆ domain_

Domain Couenne::CouenneProblem::domain_
mutableprotected

current point and bounds;

Definition at line 202 of file CouenneProblem.hpp.

◆ auxSet_

std::set<exprAux *, compExpr>* Couenne::CouenneProblem::auxSet_
protected

Expression map for comparison in standardization and to count occurrences of an auxiliary.

Definition at line 206 of file CouenneProblem.hpp.

◆ curnvars_

int Couenne::CouenneProblem::curnvars_
mutableprotected

Number of elements in the x_, lb_, ub_ arrays.

Definition at line 209 of file CouenneProblem.hpp.

◆ nIntVars_

int Couenne::CouenneProblem::nIntVars_
protected

Number of discrete variables.

Definition at line 212 of file CouenneProblem.hpp.

◆ optimum_

CouNumber* Couenne::CouenneProblem::optimum_
mutableprotected

Best solution known to be loaded from file – for testing purposes.

Definition at line 215 of file CouenneProblem.hpp.

◆ bestObj_

CouNumber Couenne::CouenneProblem::bestObj_
protected

Best known objective function.

Definition at line 218 of file CouenneProblem.hpp.

◆ commuted_

bool* Couenne::CouenneProblem::commuted_
protected

Variables that have commuted to auxiliary.

Definition at line 221 of file CouenneProblem.hpp.

◆ numbering_

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 225 of file CouenneProblem.hpp.

◆ ndefined_

int Couenne::CouenneProblem::ndefined_
protected

Number of "defined variables" (aka "common expressions")

Definition at line 228 of file CouenneProblem.hpp.

◆ graph_

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 234 of file CouenneProblem.hpp.

◆ nOrigVars_

int Couenne::CouenneProblem::nOrigVars_
protected

Number of original variables.

Definition at line 237 of file CouenneProblem.hpp.

◆ nOrigCons_

int Couenne::CouenneProblem::nOrigCons_
protected

Number of original constraints (disregarding those that turned into auxiliary variable definition)

Definition at line 241 of file CouenneProblem.hpp.

◆ nOrigIntVars_

int Couenne::CouenneProblem::nOrigIntVars_
protected

Number of original integer variables.

Definition at line 244 of file CouenneProblem.hpp.

◆ pcutoff_

GlobalCutOff* Couenne::CouenneProblem::pcutoff_
mutableprotected

Pointer to a global cutoff object.

Definition at line 247 of file CouenneProblem.hpp.

◆ created_pcutoff_

bool Couenne::CouenneProblem::created_pcutoff_
mutableprotected

flag indicating if this class is creator of global cutoff object

Definition at line 250 of file CouenneProblem.hpp.

◆ doFBBT_

bool Couenne::CouenneProblem::doFBBT_
protected

do Feasibility-based bound tightening

Definition at line 252 of file CouenneProblem.hpp.

◆ doRCBT_

bool Couenne::CouenneProblem::doRCBT_
protected

do reduced cost bound tightening

Definition at line 253 of file CouenneProblem.hpp.

◆ doOBBT_

bool Couenne::CouenneProblem::doOBBT_
protected

do Optimality-based bound tightening

Definition at line 254 of file CouenneProblem.hpp.

◆ doABT_

bool Couenne::CouenneProblem::doABT_
protected

do Aggressive bound tightening

Definition at line 255 of file CouenneProblem.hpp.

◆ logObbtLev_

int Couenne::CouenneProblem::logObbtLev_
protected

frequency of Optimality-based bound tightening

Definition at line 257 of file CouenneProblem.hpp.

◆ logAbtLev_

int Couenne::CouenneProblem::logAbtLev_
protected

frequency of Aggressive bound tightening

Definition at line 258 of file CouenneProblem.hpp.

◆ jnlst_

JnlstPtr Couenne::CouenneProblem::jnlst_
protected

SmartPointer to the Journalist.

Definition at line 261 of file CouenneProblem.hpp.

◆ opt_window_

CouNumber Couenne::CouenneProblem::opt_window_
protected

window around known optimum (for testing purposes)

Definition at line 264 of file CouenneProblem.hpp.

◆ useQuadratic_

bool Couenne::CouenneProblem::useQuadratic_
protected

Use quadratic expressions?

Definition at line 267 of file CouenneProblem.hpp.

◆ feas_tolerance_

CouNumber Couenne::CouenneProblem::feas_tolerance_
protected

feasibility tolerance (to be used in checkNLP)

Definition at line 270 of file CouenneProblem.hpp.

◆ dependence_

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 275 of file CouenneProblem.hpp.

◆ objects_

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 280 of file CouenneProblem.hpp.

◆ integerRank_

int* Couenne::CouenneProblem::integerRank_
mutableprotected

each element is true if variable is integer and, if auxiliary, depends on no integer

Definition at line 284 of file CouenneProblem.hpp.

◆ numberInRank_

std::vector<int> Couenne::CouenneProblem::numberInRank_
mutableprotected

numberInRank_ [i] is the number of integer variables in rank i

Definition at line 287 of file CouenneProblem.hpp.

◆ maxCpuTime_

double Couenne::CouenneProblem::maxCpuTime_
protected

maximum cpu time

Definition at line 290 of file CouenneProblem.hpp.

◆ bonBase_

Bonmin::BabSetupBase* Couenne::CouenneProblem::bonBase_
protected

options

Definition at line 293 of file CouenneProblem.hpp.

◆ asl_

ASL* Couenne::CouenneProblem::asl_
protected

AMPL structure pointer (temporary — looking forward to embedding into OS...)

Definition at line 296 of file CouenneProblem.hpp.

◆ unusedOriginalsIndices_

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 301 of file CouenneProblem.hpp.

◆ nUnusedOriginals_

int Couenne::CouenneProblem::nUnusedOriginals_
protected

number of unused originals

Definition at line 304 of file CouenneProblem.hpp.

◆ lastPrioSort_

int Couenne::CouenneProblem::lastPrioSort_
protected

Definition at line 307 of file CouenneProblem.hpp.

◆ recBSol

CouenneRecordBestSol* Couenne::CouenneProblem::recBSol
protected

Definition at line 310 of file CouenneProblem.hpp.

◆ multilinSep_

enum multiSep Couenne::CouenneProblem::multilinSep_
protected

Type of Multilinear separation.

Definition at line 313 of file CouenneProblem.hpp.

◆ max_fbbt_iter_

int Couenne::CouenneProblem::max_fbbt_iter_
protected

number of FBBT iterations

Definition at line 316 of file CouenneProblem.hpp.

◆ fbbtReachedIterLimit_

bool Couenne::CouenneProblem::fbbtReachedIterLimit_
mutableprotected

true if FBBT exited for iteration limits as opposed to inability to further tighten bounds

Definition at line 320 of file CouenneProblem.hpp.

◆ orbitalBranching_

bool Couenne::CouenneProblem::orbitalBranching_
protected

use orbital branching?

Definition at line 323 of file CouenneProblem.hpp.

◆ checkAuxBounds_

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 329 of file CouenneProblem.hpp.

◆ trilinDecompType_

enum TrilinDecompType Couenne::CouenneProblem::trilinDecompType_
protected

return type of decomposition of quadrilinear terms

Definition at line 332 of file CouenneProblem.hpp.

◆ constObjVal_

double Couenne::CouenneProblem::constObjVal_
protected

constant value of the objective if no variable is declared in it

Definition at line 335 of file CouenneProblem.hpp.

◆ FBBTperfIndicator_

CouenneBTPerfIndicator* Couenne::CouenneProblem::FBBTperfIndicator_
protected

Performance indicator for FBBT – to be moved away from CouenneProblem when we do it with FBBT.

Definition at line 339 of file CouenneProblem.hpp.

◆ OBBTperfIndicator_

CouenneBTPerfIndicator* Couenne::CouenneProblem::OBBTperfIndicator_
protected

Performance indicator for OBBT – to be moved away from CouenneProblem.

Definition at line 343 of file CouenneProblem.hpp.

◆ ConstraintClass_

std::map<const char *, std::vector <CouenneConstraint *> *, less_than_str> Couenne::CouenneProblem::ConstraintClass_
protected

Return particular constraint class.

Classes:

1) "convex": convex constraints; 2) "PSDcon": constraints of the form X \succeq 0 3) "normal": regular constraints

Definition at line 350 of file CouenneProblem.hpp.

◆ sdpCutGen_

CouenneSdpCuts* Couenne::CouenneProblem::sdpCutGen_
protected

Temporary pointer to SDP cut generator.

A little dirty as it is generated DURING standardization, but necessary to avoid meddling with different spaces

Definition at line 355 of file CouenneProblem.hpp.

◆ node_info

std::vector<Node> Couenne::CouenneProblem::node_info
mutable

Definition at line 387 of file CouenneProblem.hpp.

◆ nauty_info

Nauty* Couenne::CouenneProblem::nauty_info
mutable

Definition at line 388 of file CouenneProblem.hpp.

◆ node_sort

myclass0 Couenne::CouenneProblem::node_sort

Definition at line 390 of file CouenneProblem.hpp.

◆ index_sort

myclass Couenne::CouenneProblem::index_sort

Definition at line 391 of file CouenneProblem.hpp.


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