Couenne 0.5.8
Loading...
Searching...
No Matches
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
30namespace Ipopt {
31 template <class T> class SmartPtr;
32 class OptionsList;
33 class Journalist;
34}
35
36namespace Bonmin {
38 class BabInfo;
40 class BabSetupBase;
41}
42
43struct ASL;
44struct expr;
45
46class CglTreeInfo;
47class CbcModel;
48class OsiObject;
49class CoinWarmStart;
50
51class 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
134namespace 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
168
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
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
216
219
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
291
294
296 ASL *asl_;
297
302
305
306 // to speedup sorting operations in strong branching
308
309 // to record best solution found
311
314
317
321
324
330
333
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
366 void initOptions (Ipopt::SmartPtr <Ipopt::OptionsList> options);
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;
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
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
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
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
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
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
618 static void registerOptions (Ipopt::SmartPtr <Bonmin::RegisteredOptions> roptions);
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
702
706
708 enum multiSep MultilinSep () const
709 {return multilinSep_;}
710
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
733
736
738 inline double constObjVal () const {return constObjVal_;}
739
742
743protected:
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
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
811public:
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.
double getMaxCpuTime() const
return maximum CPU time
bool standardize()
Break problem's nonlinear constraints in simple expressions to be convexified later.
int logAbtLev() const
How often shall we do ABT?
bool useQuadratic_
Use quadratic expressions?
CouenneRecordBestSol * recBSol
void writeGAMS(const std::string &fname)
Write nonlinear problem to a .gms file.
int nObjs() const
Get number of objectives.
std::vector< expression * > & commonExprs()
CouenneBTPerfIndicator * FBBTperfIndicator_
Performance indicator for FBBT – to be moved away from CouenneProblem when we do it with FBBT.
bool doABT_
do Aggressive bound tightening
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.
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.
CouenneProblem * clone() const
Clone method (for use within CouenneCutGenerator::clone)
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.
exprAux * linStandardize(bool addAux, CouNumber c0, LinMap &lmap, QuadMap &qmap)
standardization of linear exprOp's
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
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.
DepGraph * getDepGraph()
Return pointer to dependence graph.
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?
bool orbitalBranching() const
return true if orbital branching activated
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
std::vector< CouenneConstraint * > * ConstraintClass(const char *str)
return particular constraint class.
void setupSymmetry()
empty if no NTY, symmetry data structure setup otherwise
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.
CouNumber & Lb(int i) const
lower bound on
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
Domain * domain() const
return current point & bounds
void analyzeSparsity(CouNumber, LinMap &, QuadMap &)
analyze sparsity of potential exprQuad/exprGroup and change linear/quadratic maps accordingly,...
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.
std::vector< exprVar * > & Variables()
Return vector of variables (symbolic representation)
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.
double checkObj(const CouNumber *sol, const double &precision) const
Recompute objective value for sol.
int * evalVector()
get evaluation order vector (numbering_)
bool doFBBT() const
shall we do Feasibility Based Bound Tightening?
CouenneRecordBestSol * getRecordBestSol() const
returns recorded best solution
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)
expression * addVariable(bool isint=false, Domain *d=NULL)
Add original variable.
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.
int nVars() const
Total number of variables.
std::vector< int > * Find_Orbit(int) const
int * unusedOriginalsIndices()
return indices of neglected redundant variables
enum TrilinDecompType getTrilinDecompType()
return type of decomposition of quadrilinear terms
CouenneBTPerfIndicator * OBBTperfIndicator_
Performance indicator for OBBT – to be moved away from CouenneProblem.
CouNumber * Lb() const
Return vector of lower bounds.
CouNumber & Ub(int i) const
upper bound on
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
std::set< exprAux *, compExpr > *& AuxSet()
Return pointer to set for comparisons.
bool fbbtReachedIterLimit_
true if FBBT exited for iteration limits as opposed to inability to further tighten bounds
bool *& Commuted()
Get vector of commuted variables.
CouenneSdpCuts * getSdpCutGen()
Returns pointer to sdp cut generator.
bool fbbtReachedIterLimit() const
true if latest call to FBBT terminated due to iteration limit reached
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
Bonmin::BabSetupBase * bonBase() const
options
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.
const std::vector< std::set< int > > & Dependence() const
return inverse dependence structure
int nOrigIntVars_
Number of original integer variables.
double getFeasTol()
returns feasibility tolerance
CouNumber bestObj_
Best known objective function.
CouNumber * getCutOffSol() const
Get cutoff solution.
void flattenMul(expression *mul, CouNumber &coe, std::map< int, CouNumber > &indices)
re-organizes multiplication and stores indices (and exponents) of its variables
CouNumber *& bestSol() const
Best known solution (read from file)
std::vector< expression * > commonexprs_
AMPL's common expressions (read from AMPL through structures cexps and cexps1)
int nIntVars() const
Number of integer variables.
void auxiliarize(exprVar *, exprVar *=NULL)
Replace all occurrences of original variable with new aux given as argument.
CouNumber * X() const
Return vector of variables.
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.
exprVar * Var(int i) const
Return pointer to i-th variable.
CouenneObjective * Obj(int i) const
i-th objective
std::string problemName_
problem name
const std::string & problemName() const
return problem name
void realign()
clear all spurious variables pointers not referring to the variables_ vector
int nOrigIntVars() const
Number of original integers.
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
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.
CouNumber & X(int i) const
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
CouNumber * Ub() const
Return vector of upper bounds.
const std::vector< CouenneObject * > & Objects() const
return object vector
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.
int nIntVars_
Number of discrete variables.
std::vector< Node > node_info
int * integerRank_
each element is true if variable is integer and, if auxiliary, depends on no integer
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
CouenneConstraint * Con(int i) const
i-th constraint
void indcoe2vector(int *indexI, int *indexJ, CouNumber *coeff, std::vector< quadElem > &qcoeff)
translates triplet (indicesI, indicesJ, coefficients) into vector with pointers to variables
exprAux * addAuxiliary(expression *)
Add auxiliary variable and associate it with expression given as argument (used in standardization)
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...
Auxiliary variable.
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)