# Couenne::CouenneProblem Class Reference

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

`#include <CouenneProblem.hpp>`

List of all members.

## 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
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 constraint, .
void | addLEConstraint (expression *, expression *=NULL)
| Add constraint, .
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 | 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 in an expression to the bounds of .
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
double | constObjVal () const
| returns constant objective value if it contains no variables
CouenneSdpCuts * | getSdpCutGen ()
| Returns pointer to sdp cut generator.
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 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< 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
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.
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_
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
double | constObjVal_
| constant value of the objective if no variable is declared in it
CouenneBTPerfIndicator * | perfIndicator_
| Performance indicator for FBBT -- to be moved away from CouenneProblem when we do it with FBBT.
std::map< const char *, std::vector < CouenneConstraint * > *, less_than_str > | ConstraintClass_
| Return particular constraint class.
CouenneSdpCuts * | sdpCutGen_
| Temporary pointer to SDP cut generator.
## Private Types
enum | fixType { UNFIXED, FIXED, CONTINUOUS }
| structure to record fixed, non-fixed, and continuous variables More...
## 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

enum Couenne::CouenneProblem::fixType`[private]`

structure to record fixed, non-fixed, and continuous variables

Enumerator:

  UNFIXED |
  FIXED |
  CONTINUOUS |

Definition at line 174 of file CouenneProblem.hpp.

enum Couenne::CouenneProblem::multiSep

Type of multilinear separation.

Enumerator:

  MulSepNone |
  MulSepSimple |
  MulSepTight |

Definition at line 179 of file CouenneProblem.hpp.

## Constructor & Destructor Documentation

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

Constructor.

Referenced by clone().

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

Copy constructor.

Couenne::CouenneProblem::~CouenneProblem | ( |  | ) |

Destructor.

## Member Function Documentation

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

initializes parameters like doOBBT

CouenneProblem* Couenne::CouenneProblem::clone | ( |  | ) | const`[inline]`

Clone method (for use within CouenneCutGenerator::clone).

Definition at line 365 of file CouenneProblem.hpp.

References CouenneProblem().

int Couenne::CouenneProblem::nObjs | ( |  | ) | const`[inline]`

Get number of objectives.

Definition at line 368 of file CouenneProblem.hpp.

References objectives_.

int Couenne::CouenneProblem::nCons | ( |  | ) | const`[inline]`

Get number of constraints.

Definition at line 369 of file CouenneProblem.hpp.

References constraints_.

int Couenne::CouenneProblem::nOrigCons | ( |  | ) | const`[inline]`

Get number of original constraints.

Definition at line 370 of file CouenneProblem.hpp.

References nOrigCons_.

int Couenne::CouenneProblem::nOrigVars | ( |  | ) | const`[inline]`

Number of orig. variables.

Definition at line 372 of file CouenneProblem.hpp.

References nOrigVars_.

int Couenne::CouenneProblem::nDefVars | ( |  | ) | const`[inline]`

Number of def'd variables.

Definition at line 373 of file CouenneProblem.hpp.

References ndefined_.

int Couenne::CouenneProblem::nOrigIntVars | ( |  | ) | const`[inline]`

Number of original integers.

Definition at line 374 of file CouenneProblem.hpp.

References nOrigIntVars_.

int Couenne::CouenneProblem::nIntVars | ( |  | ) | const`[inline]`

Number of integer variables.

Definition at line 375 of file CouenneProblem.hpp.

References nIntVars_.

int Couenne::CouenneProblem::nVars | ( |  | ) | const`[inline]`

Total number of variables.

Definition at line 376 of file CouenneProblem.hpp.

References variables_.

void Couenne::CouenneProblem::setNDefVars | ( | int | ndefined__ | ) | `[inline]`

Definition at line 378 of file CouenneProblem.hpp.

References ndefined_.

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

void Couenne::CouenneProblem::sym_setup | ( |  | ) |

void Couenne::CouenneProblem::Compute_Symmetry | ( |  | ) | const

void Couenne::CouenneProblem::Print_Orbits | ( |  | ) | const

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

bool Couenne::CouenneProblem::compare | ( | register Node & | a,
|  | register Node & | b |
| ) |  |  | const`[inline]`

Nauty* Couenne::CouenneProblem::getNtyInfo | ( |  | ) | `[inline]`

Definition at line 394 of file CouenneProblem.hpp.

References nauty_info.

void Couenne::CouenneProblem::setupSymmetry | ( |  | ) |

empty if no NTY, symmetry data structure setup otherwise

int Couenne::CouenneProblem::evalOrder | ( | int | i | ) | const`[inline]`

get evaluation order index

Definition at line 403 of file CouenneProblem.hpp.

References numbering_.

int* Couenne::CouenneProblem::evalVector | ( |  | ) | `[inline]`

get evaluation order vector (numbering_)

Definition at line 407 of file CouenneProblem.hpp.

References numbering_.

CouenneConstraint* Couenne::CouenneProblem::Con | ( | int | i | ) | const`[inline]`

i-th constraint

Definition at line 411 of file CouenneProblem.hpp.

References constraints_.

CouenneObjective* Couenne::CouenneProblem::Obj | ( | int | i | ) | const`[inline]`

i-th objective

Definition at line 412 of file CouenneProblem.hpp.

References objectives_.

exprVar* Couenne::CouenneProblem::Var | ( | int | i | ) | const`[inline]`

Return pointer to i-th variable.

Definition at line 415 of file CouenneProblem.hpp.

References variables_.

std::vector<exprVar *>& Couenne::CouenneProblem::Variables | ( |  | ) | `[inline]`

Return vector of variables (symbolic representation).

Definition at line 419 of file CouenneProblem.hpp.

References variables_.

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

Return pointer to set for comparisons.

Definition at line 423 of file CouenneProblem.hpp.

References auxSet_.

DepGraph* Couenne::CouenneProblem::getDepGraph | ( |  | ) | `[inline]`

Return pointer to dependence graph.

Definition at line 427 of file CouenneProblem.hpp.

References graph_.

Domain* Couenne::CouenneProblem::domain | ( |  | ) | const`[inline]`

return current point & bounds

Definition at line 431 of file CouenneProblem.hpp.

References domain_.

std::vector<expression *>& Couenne::CouenneProblem::commonExprs | ( |  | ) | `[inline]`

Definition at line 434 of file CouenneProblem.hpp.

References commonexprs_.

CouNumber& Couenne::CouenneProblem::X | ( | int | i | ) | const`[inline]`

Definition at line 437 of file CouenneProblem.hpp.

References domain_, and Couenne::Domain::x().

CouNumber& Couenne::CouenneProblem::Lb | ( | int | i | ) | const`[inline]`

lower bound on

Definition at line 438 of file CouenneProblem.hpp.

References domain_, and Couenne::Domain::lb().

CouNumber& Couenne::CouenneProblem::Ub | ( | int | i | ) | const`[inline]`

upper bound on

Definition at line 439 of file CouenneProblem.hpp.

References domain_, and Couenne::Domain::ub().

CouNumber* Couenne::CouenneProblem::X | ( |  | ) | const`[inline]`

Return vector of variables.

Definition at line 442 of file CouenneProblem.hpp.

References domain_, and Couenne::Domain::x().

CouNumber* Couenne::CouenneProblem::Lb | ( |  | ) | const`[inline]`

Return vector of lower bounds.

Definition at line 443 of file CouenneProblem.hpp.

References domain_, and Couenne::Domain::lb().

CouNumber* Couenne::CouenneProblem::Ub | ( |  | ) | const`[inline]`

Return vector of upper bounds.

Definition at line 444 of file CouenneProblem.hpp.

References domain_, and Couenne::Domain::ub().

CouNumber*& Couenne::CouenneProblem::bestSol | ( |  | ) | const`[inline]`

Best known solution (read from file).

Definition at line 447 of file CouenneProblem.hpp.

References optimum_.

CouNumber Couenne::CouenneProblem::bestObj | ( |  | ) | const`[inline]`

Objective of best known solution.

Definition at line 448 of file CouenneProblem.hpp.

References bestObj_.

bool*& Couenne::CouenneProblem::Commuted | ( |  | ) | `[inline]`

Get vector of commuted variables.

Definition at line 451 of file CouenneProblem.hpp.

References commuted_.

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

Add (non linear) objective function.

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

Add equality constraint .

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

Add constraint, .

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

Add constraint, .

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

Add range constraint, .

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

Add (non linear) objective function.

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

Add original variable.

Parameters:

  | isint | if true, this variable is integer, otherwise it is continuous

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

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

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

preprocess problem in order to extract linear relaxations etc.

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.

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

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

bool Couenne::CouenneProblem::doFBBT | ( |  | ) | const`[inline]`

shall we do Feasibility Based Bound Tightening?

Definition at line 498 of file CouenneProblem.hpp.

References doFBBT_, and max_fbbt_iter_.

bool Couenne::CouenneProblem::doRCBT | ( |  | ) | const`[inline]`

shall we do reduced cost Bound Tightening?

Definition at line 499 of file CouenneProblem.hpp.

References doRCBT_.

bool Couenne::CouenneProblem::doOBBT | ( |  | ) | const`[inline]`

shall we do Optimality Based Bound Tightening?

Definition at line 500 of file CouenneProblem.hpp.

References doOBBT_.

bool Couenne::CouenneProblem::doABT | ( |  | ) | const`[inline]`

shall we do Aggressive Bound Tightening?

Definition at line 501 of file CouenneProblem.hpp.

References doABT_.

int Couenne::CouenneProblem::logObbtLev | ( |  | ) | const`[inline]`

How often shall we do OBBT?

Definition at line 503 of file CouenneProblem.hpp.

References logObbtLev_.

int Couenne::CouenneProblem::logAbtLev | ( |  | ) | const`[inline]`

How often shall we do ABT?

Definition at line 504 of file CouenneProblem.hpp.

References logAbtLev_.

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

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

Parameters:

  | 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. and bounds , while if false these constraints are written in the form .

Note: if used before standardization, writes original AMPL formulation

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

Write nonlinear problem to a .gms file.

Parameters:

  | fname | Name of the .gams file to be written.

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:

  | fname | Name of the .lp file to be written

void Couenne::CouenneProblem::initAuxs | ( |  | ) | const

Initialize auxiliary variables and their bounds from original variables.

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

Get auxiliary variables from original variables.

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

tighten bounds using propagation, implied bounds and reduced costs

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

core of the bound tightening procedure

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.

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

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.

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

"Forward" bound tightening, that is, propagate bound of variable in an expression to the bounds of .

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

"Backward" bound tightening, aka implied bounds.

void Couenne::CouenneProblem::fillQuadIndices | ( |  | ) |

Look for quadratic terms to be used with SDP cuts.

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

Fill vector with coefficients of objective function.

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

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

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

Set cutoff.

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

Reset cutoff.

CouNumber Couenne::CouenneProblem::getCutOff | ( |  | ) | const

Get cutoff.

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

Get cutoff solution.

void Couenne::CouenneProblem::installCutOff | ( |  | ) | const

Make cutoff known to the problem.

ConstJnlstPtr Couenne::CouenneProblem::Jnlst | ( |  | ) | const

Provide Journalist.

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

Check if solution is MINLP feasible.

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

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

Read best known solution from file given in argument.

static void Couenne::CouenneProblem::registerOptions | ( | Ipopt::SmartPtr< Bonmin::RegisteredOptions > | roptions | ) | `[static]`

Add list of options to be read from file.

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

standardization of linear exprOp's

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

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

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

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

const std::string& Couenne::CouenneProblem::problemName | ( |  | ) | const`[inline]`

return problem name

Definition at line 654 of file CouenneProblem.hpp.

References problemName_.

void Couenne::CouenneProblem::setProblemName | ( | std::string & | problemName__ | ) | `[inline]`

Definition at line 657 of file CouenneProblem.hpp.

References problemName_.

const std::vector<std::set <int> >& Couenne::CouenneProblem::Dependence | ( |  | ) | const`[inline]`

return inverse dependence structure

Definition at line 661 of file CouenneProblem.hpp.

References dependence_.

const std::vector<CouenneObject *>& Couenne::CouenneProblem::Objects | ( |  | ) | const`[inline]`

return object vector

Definition at line 665 of file CouenneProblem.hpp.

References objects_.

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

find SOS constraints in problem

void Couenne::CouenneProblem::setMaxCpuTime | ( | double | time | ) | `[inline]`

set maximum CPU time

Definition at line 674 of file CouenneProblem.hpp.

References maxCpuTime_.

double Couenne::CouenneProblem::getMaxCpuTime | ( |  | ) | const`[inline]`

return maximum CPU time

Definition at line 678 of file CouenneProblem.hpp.

References maxCpuTime_.

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

save CouenneBase

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.

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

int* Couenne::CouenneProblem::unusedOriginalsIndices | ( |  | ) | `[inline]`

return indices of neglected redundant variables

Definition at line 696 of file CouenneProblem.hpp.

References unusedOriginalsIndices_.

int Couenne::CouenneProblem::nUnusedOriginals | ( |  | ) | `[inline]`

number of unused originals

Definition at line 700 of file CouenneProblem.hpp.

References nUnusedOriginals_.

enum multiSep Couenne::CouenneProblem::MultilinSep | ( |  | ) | const`[inline]`

return type of separator for multilinear terms

Definition at line 704 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 708 of file CouenneProblem.hpp.

References fbbtReachedIterLimit_.

bool Couenne::CouenneProblem::orbitalBranching | ( |  | ) | const`[inline]`

return true if orbital branching activated

Definition at line 712 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 718 of file CouenneProblem.hpp.

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

References checkAuxBounds_.

enum TrilinDecompType Couenne::CouenneProblem::getTrilinDecompType | ( |  | ) | `[inline]`

return type of decomposition of quadrilinear terms

Definition at line 727 of file CouenneProblem.hpp.

References trilinDecompType_.

Bonmin::BabSetupBase* Couenne::CouenneProblem::bonBase | ( |  | ) | const`[inline]`

options

Definition at line 731 of file CouenneProblem.hpp.

References bonBase_.

double Couenne::CouenneProblem::constObjVal | ( |  | ) | const`[inline]`

returns constant objective value if it contains no variables

Definition at line 734 of file CouenneProblem.hpp.

References constObjVal_.

CouenneSdpCuts* Couenne::CouenneProblem::getSdpCutGen | ( |  | ) | `[inline]`

Returns pointer to sdp cut generator.

Definition at line 737 of file CouenneProblem.hpp.

References sdpCutGen_.

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:

  | 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

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

Optimality Based Bound Tightening -- inner loop.

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]`

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]`

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

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

void Couenne::CouenneProblem::realign | ( |  | ) | `[protected]`

clear all spurious variables pointers not referring to the variables_ vector

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

fill dependence_ structure

void Couenne::CouenneProblem::fillIntegerRank | ( |  | ) | const`[protected]`

fill freeIntegers_ array

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()).

int Couenne::CouenneProblem::getLastPrioSort | ( |  | ) | const`[inline]`

Definition at line 810 of file CouenneProblem.hpp.

References lastPrioSort_.

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

CouenneRecordBestSol* Couenne::CouenneProblem::getRecordBestSol | ( |  | ) | const`[inline]`

returns recorded best solution

Definition at line 817 of file CouenneProblem.hpp.

References recBSol.

double Couenne::CouenneProblem::getFeasTol | ( |  | ) | `[inline]`

returns feasibility tolerance

Definition at line 821 of file CouenneProblem.hpp.

References feas_tolerance_.

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

Recompute objective value for sol.

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

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.

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

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

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.

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.

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 0 3) "normal": regular constraints

Definition at line 896 of file CouenneProblem.hpp.

References ConstraintClass_.

## Friends And Related Function Documentation

friend class exprMul`[friend]`

Definition at line 171 of file CouenneProblem.hpp.

## Member Data Documentation

int Couenne::CouenneProblem::minDepthPrint_

Definition at line 182 of file CouenneProblem.hpp.

int Couenne::CouenneProblem::minNodePrint_

Definition at line 185 of file CouenneProblem.hpp.

bool Couenne::CouenneProblem::doPrint_

Definition at line 188 of file CouenneProblem.hpp.

std::string Couenne::CouenneProblem::problemName_`[protected]`

problem name

Definition at line 193 of file CouenneProblem.hpp.

Referenced by problemName(), and setProblemName().

std::vector<exprVar *> Couenne::CouenneProblem::variables_`[protected]`

Variables (original, auxiliary, and defined).

Definition at line 195 of file CouenneProblem.hpp.

Referenced by nVars(), Var(), and Variables().

std::vector<CouenneObjective *> Couenne::CouenneProblem::objectives_`[protected]`

Objectives.

Definition at line 196 of file CouenneProblem.hpp.

Referenced by nObjs(), and Obj().

std::vector<CouenneConstraint *> Couenne::CouenneProblem::constraints_`[protected]`

Constraints.

Definition at line 197 of file CouenneProblem.hpp.

Referenced by Con(), and nCons().

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.

Referenced by commonExprs().

Domain Couenne::CouenneProblem::domain_`[mutable, protected]`

current point and bounds;

Definition at line 202 of file CouenneProblem.hpp.

Referenced by domain(), Lb(), 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 206 of file CouenneProblem.hpp.

Referenced by AuxSet().

int Couenne::CouenneProblem::curnvars_`[mutable, protected]`

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

Definition at line 209 of file CouenneProblem.hpp.

int Couenne::CouenneProblem::nIntVars_`[protected]`

Number of discrete variables.

Definition at line 212 of file CouenneProblem.hpp.

Referenced by nIntVars().

CouNumber* Couenne::CouenneProblem::optimum_`[mutable, protected]`

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

Definition at line 215 of file CouenneProblem.hpp.

Referenced by bestSol().

CouNumber Couenne::CouenneProblem::bestObj_`[protected]`

Best known objective function.

Definition at line 218 of file CouenneProblem.hpp.

Referenced by bestObj().

bool* Couenne::CouenneProblem::commuted_`[protected]`

Variables that have commuted to auxiliary.

Definition at line 221 of file CouenneProblem.hpp.

Referenced by Commuted().

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.

Referenced by evalOrder(), and evalVector().

int Couenne::CouenneProblem::ndefined_`[protected]`

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

Definition at line 228 of file CouenneProblem.hpp.

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

Referenced by getDepGraph().

int Couenne::CouenneProblem::nOrigVars_`[protected]`

Number of original variables.

Definition at line 237 of file CouenneProblem.hpp.

Referenced by nOrigVars().

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.

Referenced by nOrigCons().

int Couenne::CouenneProblem::nOrigIntVars_`[protected]`

Number of original integer variables.

Definition at line 244 of file CouenneProblem.hpp.

Referenced by nOrigIntVars().

GlobalCutOff* Couenne::CouenneProblem::pcutoff_`[mutable, protected]`

Pointer to a global cutoff object.

Definition at line 247 of file CouenneProblem.hpp.

bool Couenne::CouenneProblem::created_pcutoff_`[mutable, protected]`

flag indicating if this class is creator of global cutoff object

Definition at line 250 of file CouenneProblem.hpp.

bool Couenne::CouenneProblem::doFBBT_`[protected]`

do Feasibility-based bound tightening

Definition at line 252 of file CouenneProblem.hpp.

Referenced by doFBBT().

bool Couenne::CouenneProblem::doRCBT_`[protected]`

do reduced cost bound tightening

Definition at line 253 of file CouenneProblem.hpp.

Referenced by doRCBT().

bool Couenne::CouenneProblem::doOBBT_`[protected]`

do Optimality-based bound tightening

Definition at line 254 of file CouenneProblem.hpp.

Referenced by doOBBT().

bool Couenne::CouenneProblem::doABT_`[protected]`

do Aggressive bound tightening

Definition at line 255 of file CouenneProblem.hpp.

Referenced by doABT().

int Couenne::CouenneProblem::logObbtLev_`[protected]`

frequency of Optimality-based bound tightening

Definition at line 257 of file CouenneProblem.hpp.

Referenced by logObbtLev().

int Couenne::CouenneProblem::logAbtLev_`[protected]`

frequency of Aggressive bound tightening

Definition at line 258 of file CouenneProblem.hpp.

Referenced by logAbtLev().

JnlstPtr Couenne::CouenneProblem::jnlst_`[protected]`

SmartPointer to the Journalist.

Definition at line 261 of file CouenneProblem.hpp.

CouNumber Couenne::CouenneProblem::opt_window_`[protected]`

window around known optimum (for testing purposes)

Definition at line 264 of file CouenneProblem.hpp.

bool Couenne::CouenneProblem::useQuadratic_`[protected]`

Use quadratic expressions?

Definition at line 267 of file CouenneProblem.hpp.

CouNumber Couenne::CouenneProblem::feas_tolerance_`[protected]`

feasibility tolerance (to be used in checkNLP)

Definition at line 270 of file CouenneProblem.hpp.

Referenced by getFeasTol().

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.

Referenced by Dependence().

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.

Referenced by Objects().

int* Couenne::CouenneProblem::integerRank_`[mutable, protected]`

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

Definition at line 284 of file CouenneProblem.hpp.

std::vector<int> Couenne::CouenneProblem::numberInRank_`[mutable, protected]`

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

Definition at line 287 of file CouenneProblem.hpp.

double Couenne::CouenneProblem::maxCpuTime_`[protected]`

maximum cpu time

Definition at line 290 of file CouenneProblem.hpp.

Referenced by getMaxCpuTime(), and setMaxCpuTime().

Bonmin::BabSetupBase* Couenne::CouenneProblem::bonBase_`[protected]`

options

Definition at line 293 of file CouenneProblem.hpp.

Referenced by bonBase().

ASL* Couenne::CouenneProblem::asl_`[protected]`

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

Definition at line 296 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 301 of file CouenneProblem.hpp.

Referenced by unusedOriginalsIndices().

int Couenne::CouenneProblem::nUnusedOriginals_`[protected]`

number of unused originals

Definition at line 304 of file CouenneProblem.hpp.

Referenced by nUnusedOriginals().

int Couenne::CouenneProblem::lastPrioSort_`[protected]`

Definition at line 307 of file CouenneProblem.hpp.

Referenced by getLastPrioSort().

CouenneRecordBestSol* Couenne::CouenneProblem::recBSol`[protected]`

Definition at line 310 of file CouenneProblem.hpp.

Referenced by getRecordBestSol().

enum multiSep Couenne::CouenneProblem::multilinSep_`[protected]`

Type of Multilinear separation.

Definition at line 313 of file CouenneProblem.hpp.

Referenced by MultilinSep().

int Couenne::CouenneProblem::max_fbbt_iter_`[protected]`

number of FBBT iterations

Definition at line 316 of file CouenneProblem.hpp.

Referenced by doFBBT().

bool Couenne::CouenneProblem::fbbtReachedIterLimit_`[mutable, protected]`

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

Definition at line 320 of file CouenneProblem.hpp.

Referenced by fbbtReachedIterLimit().

bool Couenne::CouenneProblem::orbitalBranching_`[protected]`

use orbital branching?

Definition at line 323 of file CouenneProblem.hpp.

Referenced by orbitalBranching().

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.

Referenced by checkAuxBounds(), and setCheckAuxBounds().

enum TrilinDecompType Couenne::CouenneProblem::trilinDecompType_`[protected]`

return type of decomposition of quadrilinear terms

Definition at line 332 of file CouenneProblem.hpp.

Referenced by getTrilinDecompType().

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.

Referenced by constObjVal().

CouenneBTPerfIndicator* Couenne::CouenneProblem::perfIndicator_`[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.

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 0 3) "normal": regular constraints

Definition at line 346 of file CouenneProblem.hpp.

Referenced by ConstraintClass().

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

Referenced by getSdpCutGen().

std::vector<Node> Couenne::CouenneProblem::node_info`[mutable]`

Definition at line 383 of file CouenneProblem.hpp.

Nauty* Couenne::CouenneProblem::nauty_info`[mutable]`

Definition at line 384 of file CouenneProblem.hpp.

Referenced by getNtyInfo().

myclass0 Couenne::CouenneProblem::node_sort

Definition at line 386 of file CouenneProblem.hpp.

myclass Couenne::CouenneProblem::index_sort

Definition at line 387 of file CouenneProblem.hpp.

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

- CouenneProblem.hpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines