Couenne  0.5.8
CouenneProblem.hpp
Go to the documentation of this file.
1 /* $Id: CouenneProblem.hpp 1255 2018-08-27 22:56:09Z pbelotti $
2  *
3  * Name: CouenneProblem.hpp
4  * Author: Pietro Belotti, Lehigh University
5  * Andreas Waechter, IBM
6  * Purpose: define the class CouenneProblem
7  *
8  * (C) Carnegie-Mellon University, 2006-11.
9  * This file is licensed under the Eclipse Public License (EPL)
10  */
11 
12 #ifndef COUENNE_PROBLEM_HPP
13 #define COUENNE_PROBLEM_HPP
14 
15 #define FM_TRACE_OPTSOL
16 #define FM_CHECKNLP2
17 
18 #include <vector>
19 #include <map>
20 #include <string.h>
21 
22 #include "CouenneConfig.h"
23 
24 #include "CouenneTypes.hpp"
25 #include "CouenneExpression.hpp"
26 
27 #include "CouenneJournalist.hpp"
28 #include "CouenneDomain.hpp"
29 
30 namespace Ipopt {
31  template <class T> class SmartPtr;
32  class OptionsList;
33  class Journalist;
34 }
35 
36 namespace Bonmin {
37  class RegisteredOptions;
38  class BabInfo;
39  class OsiTMINLPInterface;
40  class BabSetupBase;
41 }
42 
43 struct ASL;
44 struct expr;
45 
46 class CglTreeInfo;
47 class CbcModel;
48 class OsiObject;
49 class CoinWarmStart;
50 
51 class Nauty;
52 
53  class Node{
54  int index;
55  double coeff;
56  double lb;
57  double ub;
58  int color;
59  int code;
60  int sign;
61  public:
62  void node(int, double, double, double, int, int);
63  inline void color_vertex (register int k) {color = k;}
64  inline int get_index () const {return index;}
65  inline double get_coeff () const {return coeff;}
66  inline double get_lb () const {return lb;}
67  inline double get_ub () const {return ub;}
68  inline int get_color () const {return color;}
69  inline int get_code () const {return code;}
70  inline int get_sign () const {return sign;}
71  inline void bounds(register double a, register double b){ lb = a; ub = b;}
72  };
73 
74 #define COUENNE_EPS_SYMM 1e-8
75 
76  struct myclass0 {
77  inline bool operator() (register const Node &a, register const Node &b) {
78 
79  return (( a.get_code () < b.get_code ()) ||
80  (( a.get_code () == b.get_code () &&
81  (( a.get_coeff () < b.get_coeff () - COUENNE_EPS_SYMM) ||
82  (( fabs (a.get_coeff () - b.get_coeff ()) < COUENNE_EPS_SYMM) &&
83  (( a.get_lb () < b.get_lb () - COUENNE_EPS_SYMM) ||
84  (( fabs (a.get_lb () - b.get_lb ()) < COUENNE_EPS_SYMM) &&
85  (( a.get_ub () < b.get_ub () - COUENNE_EPS_SYMM) ||
86  (( fabs (a.get_ub () - b.get_ub ()) < COUENNE_EPS_SYMM) &&
87  (( a.get_index () < b.get_index ())))))))))));
88 
89  // bool is_less = 0;
90  // if(a.get_code() < b.get_code() )
91  // is_less = 1;
92  // else {
93  // if(a.get_code() == b.get_code() ) {
94  // if(a.get_coeff() < b.get_coeff() )
95  // is_less = 1;
96  // else{
97  // if(a.get_coeff() == b.get_coeff() ) {
98  // if(a.get_lb() < b.get_lb())
99  // is_less = 1;
100  // else{
101  // if(a.get_lb() == b.get_lb()) {
102  // if(a.get_ub() < b.get_ub())
103  // is_less = 1;
104  // else{
105  // if(a.get_ub() == b.get_ub()) {
106  // if(a.get_index() < b.get_index())
107  // is_less = 1;
108  // }
109  // }
110  // }
111  // }
112  // }
113  // }
114  // }
115  // }
116  // return is_less;
117 
118  }
119  } ;
120 
121 
122  struct myclass {
123  inline bool operator() (register const Node &a, register const Node &b) {
124  return (a.get_index() < b.get_index() );
125  }
126  };
127 
129  inline bool operator() (register const char *a, register const char *b) const
130  {return strcmp (a, b) < 0;}
131 };
132 
133 
134 namespace Couenne {
135 
137 
138  class exprVar;
139  class exprAux;
140  class DepGraph;
141  class CouenneObject;
142  class CouenneCutGenerator;
143  class quadElem;
144  class LinMap;
145  class QuadMap;
146  class CouenneConstraint;
147  class CouenneObjective;
148  class GlobalCutOff;
149  class CouenneBTPerfIndicator;
150  class CouenneRecordBestSol;
151  class CouenneSdpCuts;
152 
155 
156  struct compExpr;
157 
158 // default tolerance for checking feasibility (and integrality) of NLP solutions
160 
170 
171  friend class exprMul;
172 
174  enum fixType {UNFIXED, FIXED, CONTINUOUS};
175 
176  public:
177 
180 
181  // min depth for strong branching output
183 
184  // min number of nodes for strong branching output
186 
187  // indicate if strong branching output should be printed
188  bool doPrint_;
189 
190  protected:
191 
193  std::string problemName_;
194 
195  std::vector <exprVar *> variables_;
196  std::vector <CouenneObjective *> objectives_;
197  std::vector <CouenneConstraint *> constraints_;
198 
200  std::vector <expression *> commonexprs_;
201 
202  mutable Domain domain_;
203 
206  std::set <exprAux *, compExpr> *auxSet_;
207 
209  mutable int curnvars_;
210 
213 
215  mutable CouNumber *optimum_;
216 
219 
221  bool *commuted_;
222 
226 
229 
235 
238 
242 
245 
248 
250  mutable bool created_pcutoff_;
251 
252  bool doFBBT_;
253  bool doRCBT_;
254  bool doOBBT_;
255  bool doABT_;
256 
259 
262 
265 
268 
271 
275  std::vector <std::set <int> > dependence_;
276 
280  std::vector <CouenneObject *> objects_;
281 
284  mutable int *integerRank_;
285 
287  mutable std::vector <int> numberInRank_;
288 
290  double maxCpuTime_;
291 
294 
296  ASL *asl_;
297 
302 
305 
306  // to speedup sorting operations in strong branching
308 
309  // to record best solution found
311 
313  enum multiSep multilinSep_;
314 
317 
320  mutable bool fbbtReachedIterLimit_;
321 
324 
330 
333 
335  double constObjVal_;
336 
340 
344 
350  std::map <const char *, std::vector <CouenneConstraint *> *, less_than_str> ConstraintClass_;
351 
356 
357  public:
358 
359  CouenneProblem (ASL * = NULL,
360  Bonmin::BabSetupBase *base = NULL,
361  JnlstPtr jnlst = NULL);
364 
367 
370  {return new CouenneProblem (*this);}
371 
372  int nObjs () const {return (int) objectives_. size ();}
373  int nCons () const {return (int) constraints_. size ();}
374  int nOrigCons () const {return nOrigCons_;}
375 
376  inline int nOrigVars () const {return nOrigVars_;}
377  inline int nDefVars () const {return ndefined_;}
378  inline int nOrigIntVars () const {return nOrigIntVars_;}
379  inline int nIntVars () const {return nIntVars_;}
380  inline int nVars () const {return (int) variables_. size ();}
381 
382  void setNDefVars (int ndefined__) {ndefined_ = ndefined__;}
383 
384  // Symmetry Info
385 
386  std::vector<int> *Find_Orbit(int) const;
387  mutable std::vector<Node> node_info;
388  mutable Nauty *nauty_info;
389 
392 
393  void sym_setup();
394  void Compute_Symmetry() const;
395  void Print_Orbits() const;
396  void ChangeBounds (const double * , const double *, int ) const;
397  inline bool compare (register Node &a, register Node &b) const;
399 
400  // bool node_sort ( Node a, Node b);
401  // bool index_sort ( Node a, Node b);
402 
404  void setupSymmetry ();
405 
407  inline int evalOrder (int i) const
408  {return numbering_ [i];}
409 
411  inline int *evalVector ()
412  {return numbering_;}
413 
414  // get elements from vectors
415  inline CouenneConstraint *Con (int i) const {return constraints_ [i];}
416  inline CouenneObjective *Obj (int i) const {return objectives_ [i];}
417 
419  inline exprVar *Var (int i) const
420  {return variables_ [i];}
421 
423  inline std::vector <exprVar *> &Variables ()
424  {return variables_;}
425 
427  inline std::set <exprAux *, compExpr> *& AuxSet ()
428  {return auxSet_;}
429 
431  inline DepGraph *getDepGraph ()
432  {return graph_;}
433 
435  inline Domain *domain () const
436  {return &domain_;}
437 
438  inline std::vector <expression *>& commonExprs() { return commonexprs_; }
439 
440  // Get and set current variable and bounds
441  inline CouNumber &X (int i) const {return domain_.x (i);}
442  inline CouNumber &Lb (int i) const {return domain_.lb (i);}
443  inline CouNumber &Ub (int i) const {return domain_.ub (i);}
444 
445  // get and set current variable and bounds
446  inline CouNumber *X () const {return domain_.x ();}
447  inline CouNumber *Lb () const {return domain_.lb ();}
448  inline CouNumber *Ub () const {return domain_.ub ();}
449 
450  // get optimal solution and objective value
451  CouNumber *&bestSol () const {return optimum_;}
452  CouNumber bestObj () const {return bestObj_;}
453 
455  bool *&Commuted ()
456  {return commuted_;}
457 
459  void addObjective (expression *, const std::string & = "min");
460 
461  // Add (non linear) "=", ">=", "<=", and range constraints
462  void addEQConstraint (expression *, expression * = NULL);
463  void addGEConstraint (expression *, expression * = NULL);
464  void addLEConstraint (expression *, expression * = NULL);
466  expression * = NULL);
467 
469  void setObjective (int indObj = 0, expression * = NULL, const std::string & = "min");
470 
475  expression *addVariable (bool isint = false, Domain *d = NULL);
476 
480 
483 
487  bool standardize ();
488 
491  void print (std::ostream & = std::cout);
492 
493 #ifdef COIN_HAS_ASL
494  int readnl (const struct ASL *);
496 
498  expression *nl2e (struct expr *, const ASL *asl);
499 #endif
500 
501  // bound tightening parameters
502  bool doFBBT () const {return (doFBBT_ && (max_fbbt_iter_ != 0));}
503  bool doRCBT () const {return doRCBT_;}
504  bool doOBBT () const {return doOBBT_;}
505  bool doABT () const {return doABT_;}
506 
507  int logObbtLev () const {return logObbtLev_;}
508  int logAbtLev () const {return logAbtLev_;}
509 
522  void writeAMPL (const std::string &fname, bool aux);
523 
527  void writeGAMS (const std::string &fname);
528 
533  void writeLP (const std::string &fname);
534 
537  //void initAuxs (const CouNumber *, const CouNumber *, const CouNumber *);
538  void initAuxs () const;
539 
541  void getAuxs (CouNumber *) const;
542 
545  const CglTreeInfo info,
546  Bonmin::BabInfo * = NULL) const;
547 
549  bool btCore (t_chg_bounds *chg_bds) const;
550 
552  int obbt (const CouenneCutGenerator *cg,
553  const OsiSolverInterface &csi,
554  OsiCuts &cs,
555  const CglTreeInfo &info,
556  Bonmin::BabInfo * babInfo,
557  t_chg_bounds *chg_bds);
558 
563  t_chg_bounds *,
564  const CglTreeInfo &info,
565  Bonmin::BabInfo * = NULL) const;
566 
569  int redCostBT (const OsiSolverInterface *psi,
570  t_chg_bounds *chg_bds) const;
571 
575 
578 
581 
583  void fillObjCoeff (double *&);
584 
587  void auxiliarize (exprVar *, exprVar * = NULL);
588 
590  void setCutOff (CouNumber cutoff, const CouNumber *sol = NULL) const;
591 
593  void resetCutOff (CouNumber value = COUENNE_INFINITY) const;
594 
597 
600 
602  void installCutOff () const;
603 
606 
608  bool checkNLP (const double *solution, double &obj, bool recompute = false) const;
609 
612  int getIntegerCandidate (const double *xFrac, double *xInt, double *lb, double *ub) const;
613 
615  bool readOptimum (std::string *fname = NULL);
616 
619 
621  exprAux *linStandardize (bool addAux,
622  CouNumber c0,
623  LinMap &lmap,
624  QuadMap &qmap);
625 
629 
631  void indcoe2vector (int *indexL,
632  CouNumber *coeff,
633  std::vector <std::pair <exprVar *, CouNumber> > &lcoeff);
634 
636  void indcoe2vector (int *indexI,
637  int *indexJ,
638  CouNumber *coeff,
639  std::vector <quadElem> &qcoeff);
640 
652  CouNumber initCoe,
653  CouNumber &c0,
654  LinMap &lmap,
655  QuadMap &qmap);
656 
658  const std::string &problemName () const
659  {return problemName_;}
660 
661  void setProblemName(std::string& problemName__)
662  { problemName_ = problemName__; }
663 
665  const std::vector <std::set <int> > &Dependence () const
666  {return dependence_;}
667 
669  const std::vector <CouenneObject *> &Objects () const
670  {return objects_;}
671 
673  int findSOS (CbcModel *CbcModelPtr,
674  OsiSolverInterface *solver,
675  OsiObject ** objects);
676 
678  inline void setMaxCpuTime (double time)
679  {maxCpuTime_ = time;}
680 
682  inline double getMaxCpuTime () const
683  {return maxCpuTime_;}
684 
687 
693 
697  void restoreUnusedOriginals (CouNumber * = NULL) const;
698 
701  {return unusedOriginalsIndices_;}
702 
705  {return nUnusedOriginals_;}
706 
708  enum multiSep MultilinSep () const
709  {return multilinSep_;}
710 
712  bool fbbtReachedIterLimit () const
713  {return fbbtReachedIterLimit_;}
714 
716  bool orbitalBranching () const
717  {return orbitalBranching_;}
718 
722  void setCheckAuxBounds (bool value)
723  {checkAuxBounds_ = value;}
724 
727  bool checkAuxBounds () const
728  {return checkAuxBounds_;}
729 
732  {return trilinDecompType_;}
733 
736 
738  inline double constObjVal () const {return constObjVal_;}
739 
742 
743 protected:
744 
750  int fake_tighten (char direction,
751  int index,
752  const double *X,
753  CouNumber *olb,
754  CouNumber *oub,
755  t_chg_bounds *chg_bds,
756  t_chg_bounds *f_chg) const;
757 
760  OsiCuts &,
761  t_chg_bounds *,
762  Bonmin::BabInfo *) const;
763 
765  t_chg_bounds *chg_bds,
766  const CoinWarmStart *warmstart,
767  Bonmin::BabInfo *babInfo,
768  double *objcoe,
769  int sense,
770  int index) const;
771 
773  t_chg_bounds *chg_bds,
774  const CoinWarmStart *warmstart,
775  Bonmin::BabInfo *babInfo,
776  double *objcoe,
777  enum nodeType type,
778  int sense) const;
779 
784  LinMap &,
785  QuadMap &);
786 
789  void flattenMul (expression *mul,
790  CouNumber &coe,
791  std::map <int, CouNumber> &indices);
792 
794  void realign ();
795 
798 
800  void fillIntegerRank () const;
801 
803  int testIntFix (int index,
804  CouNumber xFrac,
805  enum fixType *fixed,
806  CouNumber *xInt,
807  CouNumber *dualL, CouNumber *dualR,
808  CouNumber *olb, CouNumber *oub,
809  bool patient) const;
810 
811 public:
812 
814  inline int getLastPrioSort() const
815  {return lastPrioSort_;}
816 
818  void setLastPrioSort (int givenLastPS);
819 
822  {return recBSol;}
823 
825  double getFeasTol() {return feas_tolerance_;}
826 
828  double checkObj(const CouNumber *sol, const double &precision) const;
829 
833  bool checkInt(const CouNumber *sol,
834  const int from, const int upto,
835  const std::vector<int> listInt,
836  const bool origVarOnly,
837  const bool stopAtFirstViol,
838  const double precision, double &maxViol) const;
839 
841  bool checkBounds(const CouNumber *sol,
842  const bool stopAtFirstViol,
843  const double precision, double &maxViol) const;
844 
846  bool checkAux(const CouNumber *sol,
847  const bool stopAtFirstViol,
848  const double precision, double &maxViol) const;
849 
851  bool checkCons(const CouNumber *sol,
852  const bool stopAtFirstViol,
853  const double precision, double &maxViol) const;
854 
867 
871 
876 
879  bool checkNLP2 (const double *solution,
880  const double obj,
881  const bool careAboutObj,
882  const bool stopAtFirstViol,
883  const bool checkAll,
884  const double precision) const;
885 
887  bool checkNLP0 (const double *solution,
888  double &obj,
889  bool recompute_obj = false,
890  const bool careAboutObj = false,
891  const bool stopAtFirstViol = true,
892  const bool checkAll = false,
893  const double precision = -1) const; // if -1 then use feas_tolerance_
894 
900  std::vector <CouenneConstraint *> *ConstraintClass (const char *str) {return ConstraintClass_ [str];}
901 };
902 
903 }
904 
905 #endif
Couenne::CouenneProblem::getCutOffSol
CouNumber * getCutOffSol() const
Get cutoff solution.
Couenne::CouenneProblem::Compute_Symmetry
void Compute_Symmetry() const
myclass0
Definition: CouenneProblem.hpp:76
Couenne::CouenneProblem::print
void print(std::ostream &=std::cout)
Display current representation of problem: objective, linear and nonlinear constraints,...
Couenne::t_chg_bounds
status of lower/upper bound of a variable, to be checked/modified in bound tightening
Definition: CouenneTypes.hpp:67
Couenne::feas_tolerance_default
const CouNumber feas_tolerance_default
Definition: CouenneProblem.hpp:159
Couenne::CouenneProblem::getCutOff
CouNumber getCutOff() const
Get cutoff.
Couenne::CouenneProblem::logAbtLev
int logAbtLev() const
How often shall we do ABT?
Definition: CouenneProblem.hpp:508
Couenne::CouenneProblem::nUnusedOriginals_
int nUnusedOriginals_
number of unused originals
Definition: CouenneProblem.hpp:304
Couenne::CouenneProblem::multilinSep_
enum multiSep multilinSep_
Type of Multilinear separation.
Definition: CouenneProblem.hpp:313
Couenne::CouenneProblem::domain_
Domain domain_
current point and bounds;
Definition: CouenneProblem.hpp:202
Couenne::CouenneProblem::commonexprs_
std::vector< expression * > commonexprs_
AMPL's common expressions (read from AMPL through structures cexps and cexps1)
Definition: CouenneProblem.hpp:200
Couenne::CouenneProblem::unusedOriginalsIndices
int * unusedOriginalsIndices()
return indices of neglected redundant variables
Definition: CouenneProblem.hpp:700
Couenne::CouenneProblem::Lb
CouNumber & Lb(int i) const
lower bound on
Definition: CouenneProblem.hpp:442
Couenne::CouenneProblem::nUnusedOriginals
int nUnusedOriginals()
number of unused originals
Definition: CouenneProblem.hpp:704
OsiObject
Couenne::exprMul
class for multiplications,
Definition: CouenneExprMul.hpp:24
Couenne::TrilinDecompType
TrilinDecompType
Definition: CouenneProblem.hpp:136
Couenne::CouenneProblem::pcutoff_
GlobalCutOff * pcutoff_
Pointer to a global cutoff object.
Definition: CouenneProblem.hpp:247
Couenne::CouenneProblem::sdpCutGen_
CouenneSdpCuts * sdpCutGen_
Temporary pointer to SDP cut generator.
Definition: CouenneProblem.hpp:355
Couenne::CouenneProblem::doFBBT
bool doFBBT() const
shall we do Feasibility Based Bound Tightening?
Definition: CouenneProblem.hpp:502
Couenne::CouenneProblem::initAuxs
void initAuxs() const
Initialize auxiliary variables and their bounds from original variables.
Couenne::CouenneProblem::bestSol
CouNumber *& bestSol() const
Best known solution (read from file)
Definition: CouenneProblem.hpp:451
CglTreeInfo
Couenne::CouenneProblem::fbbtReachedIterLimit
bool fbbtReachedIterLimit() const
true if latest call to FBBT terminated due to iteration limit reached
Definition: CouenneProblem.hpp:712
Couenne::CouenneProblem::getAuxs
void getAuxs(CouNumber *) const
Get auxiliary variables from original variables.
Couenne::CouenneProblem::multiSep
multiSep
Type of multilinear separation.
Definition: CouenneProblem.hpp:179
Couenne::CouenneProblem::nObjs
int nObjs() const
Get number of objectives.
Definition: CouenneProblem.hpp:372
Couenne::CouenneProblem::getSdpCutGen
CouenneSdpCuts * getSdpCutGen()
Returns pointer to sdp cut generator.
Definition: CouenneProblem.hpp:741
Couenne::CouenneProblem::getMaxCpuTime
double getMaxCpuTime() const
return maximum CPU time
Definition: CouenneProblem.hpp:682
Couenne::CouenneProblem::auxiliarize
void auxiliarize(exprVar *, exprVar *=NULL)
Replace all occurrences of original variable with new aux given as argument.
Couenne::CouenneProblem::logAbtLev_
int logAbtLev_
frequency of Aggressive bound tightening
Definition: CouenneProblem.hpp:258
Couenne::CouenneProblem::obbt
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.
Couenne::CouenneProblem::reformulate
void reformulate(CouenneCutGenerator *=NULL)
preprocess problem in order to extract linear relaxations etc.
COUENNE_INFINITY
#define COUENNE_INFINITY
Definition: CouennePrecisions.hpp:32
Couenne::CouenneProblem::btCore
bool btCore(t_chg_bounds *chg_bds) const
core of the bound tightening procedure
Couenne::CouenneProblem::fillIntegerRank
void fillIntegerRank() const
fill freeIntegers_ array
Couenne::CouenneProblem::redCostBT
int redCostBT(const OsiSolverInterface *psi, t_chg_bounds *chg_bds) const
procedure to strengthen variable bounds.
Bonmin
Couenne::CouenneProblem::evalOrder
int evalOrder(int i) const
get evaluation order index
Definition: CouenneProblem.hpp:407
Couenne::CouenneProblem::addAuxiliary
exprAux * addAuxiliary(expression *)
Add auxiliary variable and associate it with expression given as argument (used in standardization)
Couenne::CouenneProblem::constraints_
std::vector< CouenneConstraint * > constraints_
Constraints.
Definition: CouenneProblem.hpp:197
Couenne::CouenneProblem::recBSol
CouenneRecordBestSol * recBSol
Definition: CouenneProblem.hpp:310
Node::get_coeff
double get_coeff() const
Definition: CouenneProblem.hpp:65
Node::get_index
int get_index() const
Definition: CouenneProblem.hpp:64
Couenne::CouenneProblem::MulSepNone
@ MulSepNone
Definition: CouenneProblem.hpp:179
Couenne::ConstJnlstPtr
Ipopt::SmartPtr< const Ipopt::Journalist > ConstJnlstPtr
Definition: CouenneExprVar.hpp:35
Couenne::CouenneProblem::numberInRank_
std::vector< int > numberInRank_
numberInRank_ [i] is the number of integer variables in rank i
Definition: CouenneProblem.hpp:287
Couenne::CouenneProblem::checkBounds
bool checkBounds(const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const
Check bounds; returns true iff feasible for given precision.
Bonmin::OsiTMINLPInterface
Couenne::CouenneProblem::OBBTperfIndicator_
CouenneBTPerfIndicator * OBBTperfIndicator_
Performance indicator for OBBT – to be moved away from CouenneProblem.
Definition: CouenneProblem.hpp:343
Couenne::Domain::ub
CouNumber & ub(register int index)
current upper bound
Definition: CouenneDomain.hpp:158
Couenne::CouenneProblem::aggressiveBT
bool aggressiveBT(Bonmin::OsiTMINLPInterface *nlp, t_chg_bounds *, const CglTreeInfo &info, Bonmin::BabInfo *=NULL) const
aggressive bound tightening.
Couenne::CouenneProblem::~CouenneProblem
~CouenneProblem()
Destructor.
Couenne::CouenneProblem::nDefVars
int nDefVars() const
Number of def'd variables.
Definition: CouenneProblem.hpp:377
Couenne::CouenneProblem::logObbtLev
int logObbtLev() const
How often shall we do OBBT?
Definition: CouenneProblem.hpp:507
Ipopt
Couenne::CouenneProblem::dependence_
std::vector< std::set< int > > dependence_
inverse dependence structure: for each variable x give set of auxiliary variables (or better,...
Definition: CouenneProblem.hpp:275
Couenne::CouenneProblem::addVariable
expression * addVariable(bool isint=false, Domain *d=NULL)
Add original variable.
Couenne::CouenneProblem::domain
Domain * domain() const
return current point & bounds
Definition: CouenneProblem.hpp:435
Couenne::CouenneProblem::logObbtLev_
int logObbtLev_
frequency of Optimality-based bound tightening
Definition: CouenneProblem.hpp:257
Couenne::CouenneProblem::linStandardize
exprAux * linStandardize(bool addAux, CouNumber c0, LinMap &lmap, QuadMap &qmap)
standardization of linear exprOp's
Couenne::CouenneProblem::created_pcutoff_
bool created_pcutoff_
flag indicating if this class is creator of global cutoff object
Definition: CouenneProblem.hpp:250
Couenne::CouenneCutGenerator
Cut Generator for linear convexifications.
Definition: CouenneCutGenerator.hpp:49
Couenne::CouenneProblem::nOrigIntVars
int nOrigIntVars() const
Number of original integers.
Definition: CouenneProblem.hpp:378
CouenneConfig.h
Couenne::CouenneProblem::ConstraintClass_
std::map< const char *, std::vector< CouenneConstraint * > *, less_than_str > ConstraintClass_
Return particular constraint class.
Definition: CouenneProblem.hpp:350
Couenne::CouenneProblem::checkAux
bool checkAux(const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const
returns true iff value of all auxiliaries are within bounds
Node::get_lb
double get_lb() const
Definition: CouenneProblem.hpp:66
Couenne::CouenneProblem::commuted_
bool * commuted_
Variables that have commuted to auxiliary.
Definition: CouenneProblem.hpp:221
Couenne::CouenneProblem::objectives_
std::vector< CouenneObjective * > objectives_
Objectives.
Definition: CouenneProblem.hpp:196
less_than_str
Definition: CouenneProblem.hpp:128
Couenne::GlobalCutOff
Definition: CouenneGlobalCutOff.hpp:19
Couenne::CouenneProblem::CouenneProblem
CouenneProblem(ASL *=NULL, Bonmin::BabSetupBase *base=NULL, JnlstPtr jnlst=NULL)
Constructor.
Couenne::CouenneProblem::nOrigCons
int nOrigCons() const
Get number of original constraints.
Definition: CouenneProblem.hpp:374
Couenne::CouenneProblem::writeLP
void writeLP(const std::string &fname)
Write nonlinear problem to a .lp file.
Couenne::CouenneProblem::graph_
DepGraph * graph_
Dependence (acyclic) graph: shows dependence of all auxiliary variables on one another and on origina...
Definition: CouenneProblem.hpp:234
myclass0::operator()
bool operator()(register const Node &a, register const Node &b)
Definition: CouenneProblem.hpp:77
myclass::operator()
bool operator()(register const Node &a, register const Node &b)
Definition: CouenneProblem.hpp:123
Couenne::CouenneProblem::jnlst_
JnlstPtr jnlst_
SmartPointer to the Journalist.
Definition: CouenneProblem.hpp:261
Couenne::CouenneProblem::addObjective
void addObjective(expression *, const std::string &="min")
Add (non linear) objective function.
Couenne::CouenneProblem::obbt_iter
int obbt_iter(OsiSolverInterface *csi, t_chg_bounds *chg_bds, const CoinWarmStart *warmstart, Bonmin::BabInfo *babInfo, double *objcoe, int sense, int index) const
Couenne::CouenneProblem::fillQuadIndices
void fillQuadIndices()
Look for quadratic terms to be used with SDP cuts.
Couenne::CouenneProblem::bestObj
CouNumber bestObj() const
Objective of best known solution.
Definition: CouenneProblem.hpp:452
Couenne::CouenneProblem::setCutOff
void setCutOff(CouNumber cutoff, const CouNumber *sol=NULL) const
Set cutoff.
Couenne
general include file for different compilers
Definition: CouenneAggrProbing.hpp:24
Couenne::CouenneProblem::index_sort
myclass index_sort
Definition: CouenneProblem.hpp:391
Bonmin::BabSetupBase
Couenne::CouenneProblem::getIntegerCandidate
int getIntegerCandidate(const double *xFrac, double *xInt, double *lb, double *ub) const
generate integer NLP point Y starting from fractional solution using bound tightening
Couenne::CouenneRecordBestSol
Definition: CouenneRecordBestSol.hpp:19
Couenne::CouenneProblem::ConstraintClass
std::vector< CouenneConstraint * > * ConstraintClass(const char *str)
return particular constraint class.
Definition: CouenneProblem.hpp:900
Couenne::CouenneProblem::CouenneProblem
CouenneProblem(const CouenneProblem &)
Copy constructor.
Couenne::CouenneProblem::unusedOriginalsIndices_
int * unusedOriginalsIndices_
some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
Definition: CouenneProblem.hpp:301
Couenne::CouenneProblem::trilinDecompType_
enum TrilinDecompType trilinDecompType_
return type of decomposition of quadrilinear terms
Definition: CouenneProblem.hpp:332
Couenne::CouenneProblem::analyzeSparsity
void analyzeSparsity(CouNumber, LinMap &, QuadMap &)
analyze sparsity of potential exprQuad/exprGroup and change linear/quadratic maps accordingly,...
Couenne::CouenneProblem::nOrigVars_
int nOrigVars_
Number of original variables.
Definition: CouenneProblem.hpp:237
Couenne::CouenneProblem::setupSymmetry
void setupSymmetry()
empty if no NTY, symmetry data structure setup otherwise
Couenne::CouenneProblem::Obj
CouenneObjective * Obj(int i) const
i-th objective
Definition: CouenneProblem.hpp:416
Couenne::CouenneProblem::feas_tolerance_
CouNumber feas_tolerance_
feasibility tolerance (to be used in checkNLP)
Definition: CouenneProblem.hpp:270
Couenne::CouenneProblem::resetCutOff
void resetCutOff(CouNumber value=COUENNE_INFINITY) const
Reset cutoff.
Couenne::CouenneProblem::standardize
bool standardize()
Break problem's nonlinear constraints in simple expressions to be convexified later.
Node::color_vertex
void color_vertex(register int k)
Definition: CouenneProblem.hpp:63
Couenne::CouenneProblem::Jnlst
ConstJnlstPtr Jnlst() const
Provide Journalist.
Couenne::CouenneProblem::objects_
std::vector< CouenneObject * > objects_
vector of pointer to CouenneObjects.
Definition: CouenneProblem.hpp:280
Couenne::CouenneProblem::indcoe2vector
void indcoe2vector(int *indexL, CouNumber *coeff, std::vector< std::pair< exprVar *, CouNumber > > &lcoeff)
translates pair (indices, coefficients) into vector with pointers to variables
Couenne::CouenneProblem::writeGAMS
void writeGAMS(const std::string &fname)
Write nonlinear problem to a .gms file.
Couenne::CouenneProblem::ChangeBounds
void ChangeBounds(const double *, const double *, int) const
Couenne::CouenneProblem::max_fbbt_iter_
int max_fbbt_iter_
number of FBBT iterations
Definition: CouenneProblem.hpp:316
Node::bounds
void bounds(register double a, register double b)
Definition: CouenneProblem.hpp:71
Couenne::CouenneProblem::minNodePrint_
int minNodePrint_
Definition: CouenneProblem.hpp:185
Couenne::CouenneProblem::getDepGraph
DepGraph * getDepGraph()
Return pointer to dependence graph.
Definition: CouenneProblem.hpp:431
Couenne::CouenneProblem::Dependence
const std::vector< std::set< int > > & Dependence() const
return inverse dependence structure
Definition: CouenneProblem.hpp:665
Couenne::CouenneProblem::lastPrioSort_
int lastPrioSort_
Definition: CouenneProblem.hpp:307
Couenne::CouenneProblem::realign
void realign()
clear all spurious variables pointers not referring to the variables_ vector
Node::get_color
int get_color() const
Definition: CouenneProblem.hpp:68
Couenne::DepGraph
Dependence graph.
Definition: CouenneDepGraph.hpp:115
Couenne::CouenneProblem::Commuted
bool *& Commuted()
Get vector of commuted variables.
Definition: CouenneProblem.hpp:455
Couenne::CouenneProblem::optimum_
CouNumber * optimum_
Best solution known to be loaded from file – for testing purposes.
Definition: CouenneProblem.hpp:215
Couenne::CouenneProblem::doOBBT
bool doOBBT() const
shall we do Optimality Based Bound Tightening?
Definition: CouenneProblem.hpp:504
Couenne::tri_bi
@ tri_bi
Definition: CouenneProblem.hpp:136
Couenne::CouenneProblem::readOptimum
bool readOptimum(std::string *fname=NULL)
Read best known solution from file given in argument.
Couenne::CouenneProblem::doFBBT_
bool doFBBT_
do Feasibility-based bound tightening
Definition: CouenneProblem.hpp:252
Couenne::CouenneProblem::checkAuxBounds_
bool checkAuxBounds_
check bounds on auxiliary variables when verifying MINLP feasibility of a solution.
Definition: CouenneProblem.hpp:329
Couenne::CouenneProblem::checkCons
bool checkCons(const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const
returns true iff value of all auxiliaries are within bounds
Couenne::CouenneProblem::FBBTperfIndicator_
CouenneBTPerfIndicator * FBBTperfIndicator_
Performance indicator for FBBT – to be moved away from CouenneProblem when we do it with FBBT.
Definition: CouenneProblem.hpp:339
Couenne::CouenneProblem::numbering_
int * numbering_
numbering of variables.
Definition: CouenneProblem.hpp:225
CbcModel
Couenne::CouenneProblem::Ub
CouNumber * Ub() const
Return vector of upper bounds.
Definition: CouenneProblem.hpp:448
Bonmin::BabInfo
Ipopt::SmartPtr< Ipopt::Journalist >
Couenne::CouenneProblem::doPrint_
bool doPrint_
Definition: CouenneProblem.hpp:188
Couenne::CouenneProblem::getLastPrioSort
int getLastPrioSort() const
Definition: CouenneProblem.hpp:814
Node::get_sign
int get_sign() const
Definition: CouenneProblem.hpp:70
Couenne::CouNumber
double CouNumber
main number type in Couenne
Definition: CouenneTypes.hpp:100
Couenne::CouenneProblem::doOBBT_
bool doOBBT_
do Optimality-based bound tightening
Definition: CouenneProblem.hpp:254
Couenne::CouenneProblem::addLEConstraint
void addLEConstraint(expression *, expression *=NULL)
Add constraint, .
Couenne::CouenneProblem::doRCBT
bool doRCBT() const
shall we do reduced cost Bound Tightening?
Definition: CouenneProblem.hpp:503
Couenne::CouenneProblem::fillDependence
void fillDependence(Bonmin::BabSetupBase *base, CouenneCutGenerator *=NULL)
fill dependence_ structure
Couenne::CouenneProblem::bonBase_
Bonmin::BabSetupBase * bonBase_
options
Definition: CouenneProblem.hpp:293
Couenne::CouenneProblem::restoreUnusedOriginals
void restoreUnusedOriginals(CouNumber *=NULL) const
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
Couenne::CouenneProblem::Var
exprVar * Var(int i) const
Return pointer to i-th variable.
Definition: CouenneProblem.hpp:419
Couenne::CouenneProblem::impliedBounds
int impliedBounds(t_chg_bounds *) const
"Backward" bound tightening, aka implied bounds.
Couenne::Domain::lb
CouNumber & lb(register int index)
current lower bound
Definition: CouenneDomain.hpp:157
Couenne::CouenneProblem::getRecordBestSol
CouenneRecordBestSol * getRecordBestSol() const
returns recorded best solution
Definition: CouenneProblem.hpp:821
Couenne::CouenneProblem::nOrigVars
int nOrigVars() const
Number of orig. variables.
Definition: CouenneProblem.hpp:376
OsiCuts
Couenne::CouenneProblem::nVars
int nVars() const
Total number of variables.
Definition: CouenneProblem.hpp:380
Couenne::CouenneProblem::checkInt
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 ...
Couenne::CouenneProblem::problemName
const std::string & problemName() const
return problem name
Definition: CouenneProblem.hpp:658
Couenne::CouenneProblem::bonBase
Bonmin::BabSetupBase * bonBase() const
options
Definition: CouenneProblem.hpp:735
Couenne::CouenneProblem::doABT
bool doABT() const
shall we do Aggressive Bound Tightening?
Definition: CouenneProblem.hpp:505
Couenne::CouenneProblem::MulSepTight
@ MulSepTight
Definition: CouenneProblem.hpp:179
Couenne::CouenneProblem::node_info
std::vector< Node > node_info
Definition: CouenneProblem.hpp:387
Couenne::CouenneProblem::getTrilinDecompType
enum TrilinDecompType getTrilinDecompType()
return type of decomposition of quadrilinear terms
Definition: CouenneProblem.hpp:731
Couenne::CouenneProblem::Lb
CouNumber * Lb() const
Return vector of lower bounds.
Definition: CouenneProblem.hpp:447
Couenne::CouenneObjective
Objective function.
Definition: CouenneProblemElem.hpp:109
Couenne::expression::auxSign
auxSign
"sign" of the constraint defining an auxiliary.
Definition: CouenneExpression.hpp:55
Couenne::CouenneProblem::X
CouNumber * X() const
Return vector of variables.
Definition: CouenneProblem.hpp:446
Nauty
Definition: Nauty.h:24
Couenne::CouenneBTPerfIndicator
Definition: CouenneBTPerfIndicator.hpp:23
Couenne::exprVar
variable-type operator
Definition: CouenneExprVar.hpp:45
Couenne::CouenneProblem::bestObj_
CouNumber bestObj_
Best known objective function.
Definition: CouenneProblem.hpp:218
OsiSolverInterface
Couenne::CouenneProblem::nIntVars
int nIntVars() const
Number of integer variables.
Definition: CouenneProblem.hpp:379
CouenneTypes.hpp
Couenne::CouenneSdpCuts
These are cuts of the form.
Definition: CouenneSdpCuts.hpp:43
Couenne::CouenneProblem::sym_setup
void sym_setup()
Couenne::CouenneProblem::Objects
const std::vector< CouenneObject * > & Objects() const
return object vector
Definition: CouenneProblem.hpp:669
Couenne::CouenneProblem::constObjVal_
double constObjVal_
constant value of the objective if no variable is declared in it
Definition: CouenneProblem.hpp:335
Couenne::rAI
@ rAI
Definition: CouenneProblem.hpp:136
Couenne::CouenneProblem::fillObjCoeff
void fillObjCoeff(double *&)
Fill vector with coefficients of objective function.
Couenne::CouenneProblem::setProblemName
void setProblemName(std::string &problemName__)
Definition: CouenneProblem.hpp:661
Couenne::CouenneProblem::nauty_info
Nauty * nauty_info
Definition: CouenneProblem.hpp:388
CouenneExpression.hpp
Couenne::CouenneProblem::writeAMPL
void writeAMPL(const std::string &fname, bool aux)
Write nonlinear problem to a .mod file (with lots of defined variables)
Couenne::CouenneProblem::auxSet_
std::set< exprAux *, compExpr > * auxSet_
Expression map for comparison in standardization and to count occurrences of an auxiliary.
Definition: CouenneProblem.hpp:206
Couenne::CouenneProblem::curnvars_
int curnvars_
Number of elements in the x_, lb_, ub_ arrays.
Definition: CouenneProblem.hpp:209
Couenne::CouenneProblem::AuxSet
std::set< exprAux *, compExpr > *& AuxSet()
Return pointer to set for comparisons.
Definition: CouenneProblem.hpp:427
Couenne::CouenneProblem::nOrigCons_
int nOrigCons_
Number of original constraints (disregarding those that turned into auxiliary variable definition)
Definition: CouenneProblem.hpp:241
Couenne::CouenneProblem::Variables
std::vector< exprVar * > & Variables()
Return vector of variables (symbolic representation)
Definition: CouenneProblem.hpp:423
Couenne::nodeType
nodeType
type of a node in an expression tree
Definition: CouenneTypes.hpp:20
Couenne::CouenneProblem::fbbtReachedIterLimit_
bool fbbtReachedIterLimit_
true if FBBT exited for iteration limits as opposed to inability to further tighten bounds
Definition: CouenneProblem.hpp:320
Couenne::CouenneProblem::checkObj
double checkObj(const CouNumber *sol, const double &precision) const
Recompute objective value for sol.
Couenne::CouenneProblem::decomposeTerm
void decomposeTerm(expression *term, CouNumber initCoe, CouNumber &c0, LinMap &lmap, QuadMap &qmap)
given (expression *) element of sum, returns (coe,ind0,ind1) depending on element:
Couenne::CouenneProblem::maxCpuTime_
double maxCpuTime_
maximum cpu time
Definition: CouenneProblem.hpp:290
Couenne::CouenneProblem::integerRank_
int * integerRank_
each element is true if variable is integer and, if auxiliary, depends on no integer
Definition: CouenneProblem.hpp:284
Couenne::CouenneProblem::splitAux
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
Couenne::CouenneProblem::orbitalBranching_
bool orbitalBranching_
use orbital branching?
Definition: CouenneProblem.hpp:323
Couenne::CouenneProblem::setNDefVars
void setNDefVars(int ndefined__)
Definition: CouenneProblem.hpp:382
Couenne::CouenneProblem::Con
CouenneConstraint * Con(int i) const
i-th constraint
Definition: CouenneProblem.hpp:415
Node
Definition: CouenneProblem.hpp:53
Couenne::CouenneProblem::constObjVal
double constObjVal() const
returns constant objective value if it contains no variables
Definition: CouenneProblem.hpp:738
Couenne::JnlstPtr
Ipopt::SmartPtr< Ipopt::Journalist > JnlstPtr
Definition: CouenneExprVar.hpp:34
Couenne::CouenneProblem::checkNLP
bool checkNLP(const double *solution, double &obj, bool recompute=false) const
Check if solution is MINLP feasible.
Couenne::LinMap
Definition: CouenneLQelems.hpp:48
Couenne::CouenneProblem::compare
bool compare(register Node &a, register Node &b) const
Couenne::CouenneProblem::evalVector
int * evalVector()
get evaluation order vector (numbering_)
Definition: CouenneProblem.hpp:411
Node::get_code
int get_code() const
Definition: CouenneProblem.hpp:69
Couenne::CouenneProblem::createUnusedOriginals
void createUnusedOriginals()
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
Couenne::CouenneProblem::getNtyInfo
Nauty * getNtyInfo()
Definition: CouenneProblem.hpp:398
Couenne::CouenneProblem::setLastPrioSort
void setLastPrioSort(int givenLastPS)
Couenne::CouenneProblem::problemName_
std::string problemName_
problem name
Definition: CouenneProblem.hpp:193
Couenne::CouenneProblem::boundTightening
bool boundTightening(t_chg_bounds *, const CglTreeInfo info, Bonmin::BabInfo *=NULL) const
tighten bounds using propagation, implied bounds and reduced costs
Couenne::CouenneProblem::Ub
CouNumber & Ub(int i) const
upper bound on
Definition: CouenneProblem.hpp:443
Couenne::CouenneProblem::orbitalBranching
bool orbitalBranching() const
return true if orbital branching activated
Definition: CouenneProblem.hpp:716
Couenne::CouenneProblem::setObjective
void setObjective(int indObj=0, expression *=NULL, const std::string &="min")
Add (non linear) objective function.
Node::node
void node(int, double, double, double, int, int)
Couenne::CouenneProblem::checkNLP0
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.
Couenne::CouenneProblem::MulSepSimple
@ MulSepSimple
Definition: CouenneProblem.hpp:179
CouenneDomain.hpp
CoinWarmStart
Couenne::CouenneProblem::findSOS
int findSOS(CbcModel *CbcModelPtr, OsiSolverInterface *solver, OsiObject **objects)
find SOS constraints in problem
Couenne::CouenneProblem::doABT_
bool doABT_
do Aggressive bound tightening
Definition: CouenneProblem.hpp:255
Couenne::CouenneProblem::registerOptions
static void registerOptions(Ipopt::SmartPtr< Bonmin::RegisteredOptions > roptions)
Add list of options to be read from file.
Couenne::CouenneProblem::X
CouNumber & X(int i) const
Definition: CouenneProblem.hpp:441
Couenne::CouenneConstraint
Class to represent nonlinear constraints.
Definition: CouenneProblemElem.hpp:39
Couenne::CouenneProblem::Find_Orbit
std::vector< int > * Find_Orbit(int) const
myclass
Definition: CouenneProblem.hpp:122
Couenne::CouenneProblem::nIntVars_
int nIntVars_
Number of discrete variables.
Definition: CouenneProblem.hpp:212
less_than_str::operator()
bool operator()(register const char *a, register const char *b) const
Definition: CouenneProblem.hpp:129
Couenne::CouenneProblem::fake_tighten
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.
Couenne::CouenneProblem::addRNGConstraint
void addRNGConstraint(expression *, expression *=NULL, expression *=NULL)
Add range constraint, .
Couenne::CouenneProblem::getFeasTol
double getFeasTol()
returns feasibility tolerance
Definition: CouenneProblem.hpp:825
Couenne::CouenneProblem::ndefined_
int ndefined_
Number of "defined variables" (aka "common expressions")
Definition: CouenneProblem.hpp:228
Couenne::CouenneProblem::opt_window_
CouNumber opt_window_
window around known optimum (for testing purposes)
Definition: CouenneProblem.hpp:264
Couenne::CouenneProblem::installCutOff
void installCutOff() const
Make cutoff known to the problem.
Couenne::CouenneProblem::setBase
void setBase(Bonmin::BabSetupBase *base)
save CouenneBase
Couenne::CouenneProblem::node_sort
myclass0 node_sort
Definition: CouenneProblem.hpp:390
Couenne::treeDecomp
@ treeDecomp
Definition: CouenneProblem.hpp:136
Couenne::CouenneProblem::flattenMul
void flattenMul(expression *mul, CouNumber &coe, std::map< int, CouNumber > &indices)
re-organizes multiplication and stores indices (and exponents) of its variables
Couenne::CouenneProblem::useQuadratic_
bool useQuadratic_
Use quadratic expressions?
Definition: CouenneProblem.hpp:267
Couenne::CouenneProblem::addEQConstraint
void addEQConstraint(expression *, expression *=NULL)
Add equality constraint .
Couenne::CouenneProblem::nCons
int nCons() const
Get number of constraints.
Definition: CouenneProblem.hpp:373
Node::get_ub
double get_ub() const
Definition: CouenneProblem.hpp:67
Couenne::CouenneProblem::checkAuxBounds
bool checkAuxBounds() const
return true if bounds of auxiliary variables have to be satisfied whenever a solution is tested for M...
Definition: CouenneProblem.hpp:727
Couenne::Domain::x
CouNumber & x(register int index)
current variable
Definition: CouenneDomain.hpp:156
Couenne::CouenneProblem::nOrigIntVars_
int nOrigIntVars_
Number of original integer variables.
Definition: CouenneProblem.hpp:244
Couenne::CouenneProblem
Class for MINLP problems with symbolic information.
Definition: CouenneProblem.hpp:169
Couenne::CouenneProblem::testIntFix
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())
Couenne::CouenneProblem::clone
CouenneProblem * clone() const
Clone method (for use within CouenneCutGenerator::clone)
Definition: CouenneProblem.hpp:369
Couenne::CouenneProblem::addGEConstraint
void addGEConstraint(expression *, expression *=NULL)
Add constraint, .
Couenne::CouenneProblem::MultilinSep
enum multiSep MultilinSep() const
return type of separator for multilinear terms
Definition: CouenneProblem.hpp:708
Couenne::CouenneProblem::call_iter
int call_iter(OsiSolverInterface *csi, t_chg_bounds *chg_bds, const CoinWarmStart *warmstart, Bonmin::BabInfo *babInfo, double *objcoe, enum nodeType type, int sense) const
Couenne::CouenneProblem::doRCBT_
bool doRCBT_
do reduced cost bound tightening
Definition: CouenneProblem.hpp:253
Couenne::CouenneProblem::variables_
std::vector< exprVar * > variables_
Variables (original, auxiliary, and defined)
Definition: CouenneProblem.hpp:195
Couenne::exprAux
Auxiliary variable.
Definition: CouenneExprAux.hpp:32
Couenne::expression
Expression base class.
Definition: CouenneExpression.hpp:48
Couenne::CouenneProblem::tightenBounds
int tightenBounds(t_chg_bounds *) const
"Forward" bound tightening, that is, propagate bound of variable in an expression to the bounds of ...
Couenne::CouenneProblem::Print_Orbits
void Print_Orbits() const
Couenne::CouenneProblem::initOptions
void initOptions(Ipopt::SmartPtr< Ipopt::OptionsList > options)
initializes parameters like doOBBT
Couenne::CouenneProblem::setCheckAuxBounds
void setCheckAuxBounds(bool value)
set the value for checkAuxBounds.
Definition: CouenneProblem.hpp:722
COUENNE_EPS_SYMM
#define COUENNE_EPS_SYMM
Definition: CouenneProblem.hpp:74
Couenne::CouenneProblem::setMaxCpuTime
void setMaxCpuTime(double time)
set maximum CPU time
Definition: CouenneProblem.hpp:678
Couenne::CouenneProblem::checkNLP2
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 vari...
Couenne::Domain
Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO s...
Definition: CouenneDomain.hpp:104
Couenne::CouenneProblem::indcoe2vector
void indcoe2vector(int *indexI, int *indexJ, CouNumber *coeff, std::vector< quadElem > &qcoeff)
translates triplet (indicesI, indicesJ, coefficients) into vector with pointers to variables
Couenne::QuadMap
Definition: CouenneLQelems.hpp:75
Couenne::CouenneProblem::commonExprs
std::vector< expression * > & commonExprs()
Definition: CouenneProblem.hpp:438
Couenne::CouenneProblem::asl_
ASL * asl_
AMPL structure pointer (temporary — looking forward to embedding into OS...)
Definition: CouenneProblem.hpp:296
CouenneJournalist.hpp
Couenne::CouenneProblem::minDepthPrint_
int minDepthPrint_
Definition: CouenneProblem.hpp:182
Couenne::CouenneProblem::obbtInner
int obbtInner(OsiSolverInterface *, OsiCuts &, t_chg_bounds *, Bonmin::BabInfo *) const
Optimality Based Bound Tightening – inner loop.
Couenne::bi_tri
@ bi_tri
Definition: CouenneProblem.hpp:136