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
495  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
#define COUENNE_INFINITY
#define COUENNE_EPS_SYMM
Class to represent nonlinear constraints.
Cut Generator for linear convexifications.
Class for MINLP problems with symbolic information.
double getMaxCpuTime() const
return maximum CPU time
bool standardize()
Break problem's nonlinear constraints in simple expressions to be convexified later.
bool *& Commuted()
Get vector of commuted variables.
int logAbtLev() const
How often shall we do ABT?
std::vector< exprVar * > & Variables()
Return vector of variables (symbolic representation)
bool useQuadratic_
Use quadratic expressions?
const std::vector< CouenneObject * > & Objects() const
return object vector
DepGraph * getDepGraph()
Return pointer to dependence graph.
CouenneRecordBestSol * recBSol
void writeGAMS(const std::string &fname)
Write nonlinear problem to a .gms file.
int nObjs() const
Get number of objectives.
CouenneBTPerfIndicator * FBBTperfIndicator_
Performance indicator for FBBT – to be moved away from CouenneProblem when we do it with FBBT.
bool doABT_
do Aggressive bound tightening
CouNumber & Ub(int i) const
upper bound on
CouenneObjective * Obj(int i) const
i-th objective
int nUnusedOriginals_
number of unused originals
int tightenBounds(t_chg_bounds *) const
"Forward" bound tightening, that is, propagate bound of variable in an expression to the bounds of ...
int * numbering_
numbering of variables.
CouNumber * getCutOffSol() const
Get cutoff solution.
std::vector< exprVar * > variables_
Variables (original, auxiliary, and defined)
bool btCore(t_chg_bounds *chg_bds) const
core of the bound tightening procedure
int nOrigVars() const
Number of orig. variables.
std::set< exprAux *, compExpr > * auxSet_
Expression map for comparison in standardization and to count occurrences of an auxiliary.
void installCutOff() const
Make cutoff known to the problem.
int nDefVars() const
Number of def'd variables.
bool doABT() const
shall we do Aggressive Bound Tightening?
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.
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...
int nOrigCons_
Number of original constraints (disregarding those that turned into auxiliary variable definition)
void addRNGConstraint(expression *, expression *=NULL, expression *=NULL)
Add range constraint, .
void fillQuadIndices()
Look for quadratic terms to be used with SDP cuts.
int * unusedOriginalsIndices_
some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
void indcoe2vector(int *indexL, CouNumber *coeff, std::vector< std::pair< exprVar *, CouNumber > > &lcoeff)
translates pair (indices, coefficients) into vector with pointers to variables
void fillIntegerRank() const
fill freeIntegers_ array
double constObjVal_
constant value of the objective if no variable is declared in it
CouenneProblem * clone() const
Clone method (for use within CouenneCutGenerator::clone)
void setNDefVars(int ndefined__)
void restoreUnusedOriginals(CouNumber *=NULL) const
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
void addEQConstraint(expression *, expression *=NULL)
Add equality constraint .
bool boundTightening(t_chg_bounds *, const CglTreeInfo info, Bonmin::BabInfo *=NULL) const
tighten bounds using propagation, implied bounds and reduced costs
int obbtInner(OsiSolverInterface *, OsiCuts &, t_chg_bounds *, Bonmin::BabInfo *) const
Optimality Based Bound Tightening – inner loop.
CouNumber * optimum_
Best solution known to be loaded from file – for testing purposes.
std::vector< int > * Find_Orbit(int) const
bool checkCons(const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const
returns true iff value of all auxiliaries are within bounds
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
bool orbitalBranching_
use orbital branching?
int * unusedOriginalsIndices()
return indices of neglected redundant variables
bool orbitalBranching() const
return true if orbital branching activated
const std::string & problemName() const
return problem name
void setCheckAuxBounds(bool value)
set the value for checkAuxBounds.
double constObjVal() const
returns constant objective value if it contains no variables
enum TrilinDecompType trilinDecompType_
return type of decomposition of quadrilinear terms
void setupSymmetry()
empty if no NTY, symmetry data structure setup otherwise
CouenneConstraint * Con(int i) const
i-th constraint
std::vector< int > numberInRank_
numberInRank_ [i] is the number of integer variables in rank i
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 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.
void addGEConstraint(expression *, expression *=NULL)
Add constraint, .
bool readOptimum(std::string *fname=NULL)
Read best known solution from file given in argument.
void createUnusedOriginals()
Some originals may be unused due to their zero multiplicity (that happens when they are duplicates).
int redCostBT(const OsiSolverInterface *psi, t_chg_bounds *chg_bds) const
procedure to strengthen variable bounds.
int logObbtLev() const
How often shall we do OBBT?
CouNumber feas_tolerance_
feasibility tolerance (to be used in checkNLP)
void addObjective(expression *, const std::string &="min")
Add (non linear) objective function.
bool compare(register Node &a, register Node &b) const
int nOrigVars_
Number of original variables.
void ChangeBounds(const double *, const double *, int) const
bool checkAuxBounds_
check bounds on auxiliary variables when verifying MINLP feasibility of a solution.
bool checkBounds(const CouNumber *sol, const bool stopAtFirstViol, const double precision, double &maxViol) const
Check bounds; returns true iff feasible for given precision.
void setObjective(int indObj=0, expression *=NULL, const std::string &="min")
Add (non linear) objective function.
std::vector< std::set< int > > dependence_
inverse dependence structure: for each variable x give set of auxiliary variables (or better,...
void setBase(Bonmin::BabSetupBase *base)
save CouenneBase
void analyzeSparsity(CouNumber, LinMap &, QuadMap &)
analyze sparsity of potential exprQuad/exprGroup and change linear/quadratic maps accordingly,...
CouNumber *& bestSol() const
Best known solution (read from file)
int logObbtLev_
frequency of Optimality-based bound tightening
int nUnusedOriginals()
number of unused originals
bool doFBBT_
do Feasibility-based bound tightening
int ndefined_
Number of "defined variables" (aka "common expressions")
GlobalCutOff * pcutoff_
Pointer to a global cutoff object.
void setMaxCpuTime(double time)
set maximum CPU time
int evalOrder(int i) const
get evaluation order index
bool aggressiveBT(Bonmin::OsiTMINLPInterface *nlp, t_chg_bounds *, const CglTreeInfo &info, Bonmin::BabInfo *=NULL) const
aggressive bound tightening.
exprAux * addAuxiliary(expression *)
Add auxiliary variable and associate it with expression given as argument (used in standardization)
double checkObj(const CouNumber *sol, const double &precision) const
Recompute objective value for sol.
bool doFBBT() const
shall we do Feasibility Based Bound Tightening?
int nOrigCons() const
Get number of original constraints.
bool doRCBT_
do reduced cost bound tightening
void writeAMPL(const std::string &fname, bool aux)
Write nonlinear problem to a .mod file (with lots of defined variables)
double maxCpuTime_
maximum cpu time
void setCutOff(CouNumber cutoff, const CouNumber *sol=NULL) const
Set cutoff.
ConstJnlstPtr Jnlst() const
Provide Journalist.
int curnvars_
Number of elements in the x_, lb_, ub_ arrays.
Domain domain_
current point and bounds;
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.
CouenneSdpCuts * getSdpCutGen()
Returns pointer to sdp cut generator.
std::vector< CouenneConstraint * > * ConstraintClass(const char *str)
return particular constraint class.
int nVars() const
Total number of variables.
CouNumber * Lb() const
Return vector of lower bounds.
const std::vector< std::set< int > > & Dependence() const
return inverse dependence structure
exprAux * linStandardize(bool addAux, CouNumber c0, LinMap &lmap, QuadMap &qmap)
standardization of linear exprOp's
enum TrilinDecompType getTrilinDecompType()
return type of decomposition of quadrilinear terms
CouenneBTPerfIndicator * OBBTperfIndicator_
Performance indicator for OBBT – to be moved away from CouenneProblem.
CouNumber & X(int i) const
CouenneRecordBestSol * getRecordBestSol() const
returns recorded best solution
int impliedBounds(t_chg_bounds *) const
"Backward" bound tightening, aka implied bounds.
multiSep
Type of multilinear separation.
std::vector< CouenneObjective * > objectives_
Objectives.
ASL * asl_
AMPL structure pointer (temporary — looking forward to embedding into OS...)
int logAbtLev_
frequency of Aggressive bound tightening
bool fbbtReachedIterLimit_
true if FBBT exited for iteration limits as opposed to inability to further tighten bounds
bool fbbtReachedIterLimit() const
true if latest call to FBBT terminated due to iteration limit reached
CouNumber & Lb(int i) const
lower bound on
expression * addVariable(bool isint=false, Domain *d=NULL)
Add original variable.
CouNumber opt_window_
window around known optimum (for testing purposes)
CouNumber bestObj() const
Objective of best known solution.
void addLEConstraint(expression *, expression *=NULL)
Add constraint, .
void initAuxs() const
Initialize auxiliary variables and their bounds from original variables.
bool doRCBT() const
shall we do reduced cost Bound Tightening?
Bonmin::BabSetupBase * bonBase_
options
int findSOS(CbcModel *CbcModelPtr, OsiSolverInterface *solver, OsiObject **objects)
find SOS constraints in problem
DepGraph * graph_
Dependence (acyclic) graph: shows dependence of all auxiliary variables on one another and on origina...
std::vector< CouenneObject * > objects_
vector of pointer to CouenneObjects.
void getAuxs(CouNumber *) const
Get auxiliary variables from original variables.
std::vector< expression * > & commonExprs()
int nOrigIntVars_
Number of original integer variables.
double getFeasTol()
returns feasibility tolerance
CouNumber bestObj_
Best known objective function.
void flattenMul(expression *mul, CouNumber &coe, std::map< int, CouNumber > &indices)
re-organizes multiplication and stores indices (and exponents) of its variables
std::vector< expression * > commonexprs_
AMPL's common expressions (read from AMPL through structures cexps and cexps1)
int nIntVars() const
Number of integer variables.
Bonmin::BabSetupBase * bonBase() const
options
void auxiliarize(exprVar *, exprVar *=NULL)
Replace all occurrences of original variable with new aux given as argument.
int obbt_iter(OsiSolverInterface *csi, t_chg_bounds *chg_bds, const CoinWarmStart *warmstart, Bonmin::BabInfo *babInfo, double *objcoe, int sense, int index) const
void decomposeTerm(expression *term, CouNumber initCoe, CouNumber &c0, LinMap &lmap, QuadMap &qmap)
given (expression *) element of sum, returns (coe,ind0,ind1) depending on element:
bool doOBBT_
do Optimality-based bound tightening
bool checkNLP(const double *solution, double &obj, bool recompute=false) const
Check if solution is MINLP feasible.
CouenneSdpCuts * sdpCutGen_
Temporary pointer to SDP cut generator.
enum multiSep MultilinSep() const
return type of separator for multilinear terms
void writeLP(const std::string &fname)
Write nonlinear problem to a .lp file.
std::string problemName_
problem name
Domain * domain() const
return current point & bounds
void realign()
clear all spurious variables pointers not referring to the variables_ vector
int nOrigIntVars() const
Number of original integers.
int * evalVector()
get evaluation order vector (numbering_)
enum multiSep multilinSep_
Type of Multilinear separation.
bool doOBBT() const
shall we do Optimality Based Bound Tightening?
int max_fbbt_iter_
number of FBBT iterations
static void registerOptions(Ipopt::SmartPtr< Bonmin::RegisteredOptions > roptions)
Add list of options to be read from file.
bool * commuted_
Variables that have commuted to auxiliary.
int getIntegerCandidate(const double *xFrac, double *xInt, double *lb, double *ub) const
generate integer NLP point Y starting from fractional solution using bound tightening
CouNumber * X() const
Return vector of variables.
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 reformulate(CouenneCutGenerator *=NULL)
preprocess problem in order to extract linear relaxations etc.
std::map< const char *, std::vector< CouenneConstraint * > *, less_than_str > ConstraintClass_
Return particular constraint class.
void initOptions(Ipopt::SmartPtr< Ipopt::OptionsList > options)
initializes parameters like doOBBT
CouenneProblem(const CouenneProblem &)
Copy constructor.
void setLastPrioSort(int givenLastPS)
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())
~CouenneProblem()
Destructor.
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 ...
void setProblemName(std::string &problemName__)
void Compute_Symmetry() const
JnlstPtr jnlst_
SmartPointer to the Journalist.
void fillDependence(Bonmin::BabSetupBase *base, CouenneCutGenerator *=NULL)
fill dependence_ structure
std::vector< CouenneConstraint * > constraints_
Constraints.
CouenneProblem(ASL *=NULL, Bonmin::BabSetupBase *base=NULL, JnlstPtr jnlst=NULL)
Constructor.
bool checkAuxBounds() const
return true if bounds of auxiliary variables have to be satisfied whenever a solution is tested for M...
void print(std::ostream &=std::cout)
Display current representation of problem: objective, linear and nonlinear constraints,...
void fillObjCoeff(double *&)
Fill vector with coefficients of objective function.
void resetCutOff(CouNumber value=COUENNE_INFINITY) const
Reset cutoff.
std::set< exprAux *, compExpr > *& AuxSet()
Return pointer to set for comparisons.
int nIntVars_
Number of discrete variables.
CouNumber * Ub() const
Return vector of upper bounds.
std::vector< Node > node_info
int * integerRank_
each element is true if variable is integer and, if auxiliary, depends on no integer
exprVar * Var(int i) const
Return pointer to i-th variable.
int nCons() const
Get number of constraints.
CouNumber getCutOff() const
Get cutoff.
void Print_Orbits() const
bool created_pcutoff_
flag indicating if this class is creator of global cutoff object
void indcoe2vector(int *indexI, int *indexJ, CouNumber *coeff, std::vector< quadElem > &qcoeff)
translates triplet (indicesI, indicesJ, coefficients) into vector with pointers to variables
These are cuts of the form.
Dependence graph.
Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO s...
CouNumber & x(register int index)
current variable
CouNumber & lb(register int index)
current lower bound
CouNumber & ub(register int index)
current upper bound
Auxiliary variable.
class for multiplications,
variable-type operator
Expression base class.
auxSign
"sign" of the constraint defining an auxiliary.
status of lower/upper bound of a variable, to be checked/modified in bound tightening
Definition: Nauty.h:24
double get_coeff() const
void color_vertex(register int k)
int get_code() const
void bounds(register double a, register double b)
void node(int, double, double, double, int, int)
double get_lb() const
double get_ub() const
int get_index() const
int get_sign() const
int get_color() const
general include file for different compilers
nodeType
type of a node in an expression tree
Ipopt::SmartPtr< Ipopt::Journalist > JnlstPtr
double CouNumber
main number type in Couenne
Ipopt::SmartPtr< const Ipopt::Journalist > ConstJnlstPtr
const CouNumber feas_tolerance_default
bool operator()(register const char *a, register const char *b) const
bool operator()(register const Node &a, register const Node &b)
bool operator()(register const Node &a, register const Node &b)