Blis  0.94
BlisModel.h
Go to the documentation of this file.
1 /*===========================================================================*
2  * This file is part of the BiCePS Linear Integer Solver (BLIS). *
3  * *
4  * BLIS is distributed under the Eclipse Public License as part of the *
5  * COIN-OR repository (http://www.coin-or.org). *
6  * *
7  * Authors: *
8  * *
9  * Yan Xu, Lehigh University *
10  * Ted Ralphs, Lehigh University *
11  * *
12  * Conceptual Design: *
13  * *
14  * Yan Xu, Lehigh University *
15  * Ted Ralphs, Lehigh University *
16  * Laszlo Ladanyi, IBM T.J. Watson Research Center *
17  * Matthew Saltzman, Clemson University *
18  * *
19  * *
20  * Copyright (C) 2001-2019, Lehigh University, Yan Xu, and Ted Ralphs. *
21  * All Rights Reserved. *
22  *===========================================================================*/
23 
24 //#############################################################################
25 
26 #ifndef BlisModel_h_
27 #define BlisModel_h_
28 
29 //#############################################################################
30 
31 #include <vector>
32 
33 #include "CoinMpsIO.hpp"
34 #include "CoinLpIO.hpp"
35 #include "CoinPackedMatrix.hpp"
36 
37 #include "CglCutGenerator.hpp"
38 
39 #include "OsiCuts.hpp"
40 #include "OsiSolverInterface.hpp"
41 
42 #include "AlpsEnumProcessT.h"
43 #include "AlpsParams.h"
44 #include "AlpsTreeNode.h"
45 
46 #include "BcpsBranchStrategy.h"
47 #include "BcpsObject.h"
48 #include "BcpsObjectPool.h"
49 #include "BcpsModel.h"
50 
51 #include "Blis.h"
52 #include "BlisConGenerator.h"
53 #include "BlisHeuristic.h"
54 #include "BlisMessage.h"
55 #include "BlisParams.h"
56 #include "BlisPseudo.h"
57 #include "BlisPresolve.h"
58 
59 //#############################################################################
60 
61 class BlisConstraint;
62 class BlisSolution;
63 class BcpsVariable;
64 class BlisVariable;
65 
66 //#############################################################################
67 
68 /* Declare a BLIS model */
69 class BlisModel : public BcpsModel {
70 
71 protected:
72 
73  //------------------------------------------------------
74  // LP SOLVER.
75  //------------------------------------------------------
76 
84 
85  //------------------------------------------------------
86  // PROBLEM DATA. Populate when loadProblem(),
87  //------------------------------------------------------
88 
91 
94  double *varLB_;
95  double *varUB_;
96  double *conLB_;
97  double *conUB_;
99 
102  int numCols_;
103  int numRows_;
106 
109  double objSense_;
110  double *objCoef_;
112 
116  int *intColIndices_; // size of numIntObjects_
118 
121  std::vector<BcpsVariable *> inputVar_;
122  std::vector<BcpsConstraint *> inputCon_;
124 
125  //------------------------------------------------------
126  // PRESOLVE
127  //------------------------------------------------------
128 
130  // AT - Begin
131  bool presolved;
133  // AT - End
134 
135  //------------------------------------------------------
136  // SOLUTION.
137  //------------------------------------------------------
138 
141 
143  double incObjValue_;
144 
146  double *incumbent_;
147 
149  double cutoff_;
150 
152  double cutoffInc_;
153 
154  //------------------------------------------------------
155  // SEARCHING.
156  //------------------------------------------------------
157 
158  int *intObjIndices_; // size of numCols_
159  char *colType_;
160 
163  double *startVarLB_;
164  double *startVarUB_;
165  double *startConLB_;
166  double *startConUB_;
168 
172 
173  // Hotstart strategy 0 = off,
174  // 1 = branch if incorrect,
175  // 2 = branch even if correct, ....
177 
180 
183 
186 
188  int *priority_;
189 
192 
195 
196  // Not used.
197  double nodeWeight_;
198 
201 
202  //------------------------------------------------------
203  // HEURISTICS.
204  //------------------------------------------------------
205 
208 
211 
212  //------------------------------------------------------
213  // CONSTRAINTS.
214  //------------------------------------------------------
215 
218 
221 
224 
227 
230 
233 
236 
239 
242 
244  double *conRandoms_;
245 
248 
249  //------------------------------------------------------
250  // PARAMETERS, STATISTICS, and MESSAGE
251  //------------------------------------------------------
252 
255 
258 
261 
264 
267 
270 
273 
274  //------------------------------------------------------
275  // TEMPORARY STORAGE
276  //------------------------------------------------------
277 
285 
286  //------------------------------------------------------
287  // Knowledge shared
288  //------------------------------------------------------
289 
292 
295 
296  public:
297 
299  bool isRoot_;
300 
303 
305  double integerTol_;
306 
309 
312 
314  double currRelGap_;
315 
317  double currAbsGap_;
318 
321 
324 
327 
329  std::vector<AlpsTreeNode *> leafToRootPath;
330 
331  protected:
332 
334  void init();
335 
337  void createObjects();
338 
339  public:
340 
343  {
344  init();
345  }
346 
348  virtual ~BlisModel();
349 
351  void gutsOfDestructor();
352 
353  //------------------------------------------------------
354  // SETUP, LP SOLVER
355  //------------------------------------------------------
356 
359 
361  void setNumCons(int num){ numRows_ = num; }
362 
364  void setNumVars(int num){ numCols_ = num; }
365 
367  void setNumElems(int num){ numElems_ = num; }
368 
370  void setConLb(double *cl){ conLB_ = cl; }
371 
373  void setConUb(double *cu){ conUB_ = cu; }
374 
376  void setVarLb(double *lb){ varLB_ = lb; }
377 
379  void setVarUb(double *ub){ varUB_ = ub; }
380 
382  void setColType(char *colType){
383  colType_ = colType;
384  }
385 
387  void setObjCoef(double *obj){ objCoef_ = obj; }
388 
398  virtual void readInstance(const char* dataFile);
399 
411  virtual void importModel(std::vector<BlisVariable *> vars,
412  std::vector<BlisConstraint *> cons);
413 
415  virtual void readParameters(const int argnum, const char * const *arglist);
416 
418  virtual void writeParameters(std::ostream& outstream) const;
419 
423  virtual AlpsTreeNode * createRoot();
424 
434  virtual bool setupSelf();
435 
437  virtual void preprocess();
438 
440  virtual void postprocess();
441 
443  virtual void setSolver(OsiSolverInterface *si) { origLpSolver_ = si; }
444 
447 
449  virtual OsiSolverInterface *solver() { return lpSolver_; }
450 
452  bool resolve();
453 
455  void setActiveNode(AlpsTreeNode *node) { activeNode_ = node; }
456 
458  void setSolEstimate(double est) { activeNode_->setSolEstimate(est); }
459 
461  int getNumStrong() { return numStrong_; }
462 
464  void addNumStrong(int num=1) { numStrong_ += num; }
465 
468 
470  void setNumBranchResolve(int num) { numBranchResolve_ = num; }
471 
474 
476  void setFeasCheckTime(double t) { feasCheckTime_ = t; }
477 
479  void addFeasCheckTime(double t) { feasCheckTime_ += t; }
480 
481  //------------------------------------------------------
482  // PROBLEM DATA
483  //------------------------------------------------------
484 
486  double* getObjCoef() const { return objCoef_; }
487 
489  const double * getColLower() { return lpSolver_->getColLower(); }
490 
492  const double * getColUpper() { return lpSolver_->getColUpper(); }
493 
495  int getNumCols() { return lpSolver_->getNumCols(); }
496 
498  int getNumRows() { return lpSolver_->getNumRows(); }
499 
501  double *varLB() { return varLB_; }
502  double *varUB() { return varUB_; }
503 
505  double *conLB() { return conLB_; }
506  double *conUB() { return conUB_; }
507 
509  double *startVarLB() { return startVarLB_; }
510  double *startVarUB() { return startVarUB_; }
511 
513  double *startConLB() { return startConLB_; }
514  double *startConUB() { return startConUB_; }
515 
517  int *tempVarLBPos() { return tempVarLBPos_; }
518  int *tempVarUBPos() { return tempVarUBPos_; }
519  int *tempConLBPos() { return tempConLBPos_; }
520  int *tempConUBPos() { return tempConUBPos_; }
521 
522  //------------------------------------------------------
523  // LP SOLUTION
524  //------------------------------------------------------
525 
527  double getLpObjValue() const { return lpSolver_->getObjValue(); }
528 
530  const double * getLpSolution() const { return lpSolver_->getColSolution();}
531 
532  //------------------------------------------------------
533  // MILP SOLUTION
534  //------------------------------------------------------
535 
537  int getNumSolutions() const { return numSolutions_; }
538 
540  int getNumHeurSolutions() const { return numHeurSolutions_;}
541 
543  double * incumbent() { return incumbent_; }
544 
547 
549  inline double getCutoff() const { return cutoff_; }
550 
552  inline void setCutoff(double co) {
553  double inc = BlisPar_->entry(BlisParams::cutoffInc);
554 #if 0
555  std::cout << "3. cutoff_ = "<< cutoff_
556  << "; inc = " << inc << std::endl;
557 #endif
558  co += inc;
559  if (co < cutoff_) {
560  cutoff_ = co;
562  }
563  }
564 
566  BlisSolution *feasibleSolutionHeur(const double *solution);
567 
572  virtual BlisSolution *feasibleSolution(int & numIntegerInfs,
573  int & numObjectInfs);
574 
583  virtual BlisSolution *userFeasibleSolution(const double * solution,
584  bool &feasible) {
585  BlisSolution *sol = NULL;
586  feasible = true; // Feasible by default
587  return sol;
588  }
589 
590  //------------------------------------------------------
591  // BRANCHING
592  //------------------------------------------------------
593 
600  { return branchStrategy_; }
601 
603  inline void setBranchingMethod(BcpsBranchStrategy * method) {
604  if (branchStrategy_) delete branchStrategy_;
605  branchStrategy_ = method;
606  }
607 
609  inline void setBranchingMethod(BcpsBranchStrategy & method) {
610  if (branchStrategy_) delete branchStrategy_;
611  branchStrategy_ = &method;
612  }
614  { return rampUpBranchStrategy_; }
616 
621  inline int numObjects() const { return numObjects_; }
622 
624  inline void setNumObjects(int num) { numObjects_ = num; }
625 
627  inline BcpsObject ** objects() { return objects_;}
628 
630  inline BcpsObject * objects(int which) { return objects_[which]; }
631 
633  void setSharedObjectMark(int i) { sharedObjectMark_[i] = 1; }
634 
637  for (int k = 0; k < numIntObjects_; ++k) {
638  sharedObjectMark_[k] = 0;
639  }
640  }
641 
643  void deleteObjects();
644 
647  void addObjects(int numObjects, BcpsObject ** objects);
649 
651  void createIntgerObjects(bool startAgain);
652 
654  int* getIntObjIndices() const { return intObjIndices_; }
655 
657  int getNumIntObjects() const { return numIntObjects_; }
658 
660  int* getIntColIndices() const { return intColIndices_; }
661 
663  bool checkInteger(double value) const {
664  double integerTolerance = 1.0e-5;
665  double nearest = floor(value + 0.5);
666  if (fabs(value - nearest) <= integerTolerance) {
667  return true;
668  }
669  else {
670  return false;
671  }
672  }
673 
674  void analyzeObjective();
675 
676  //------------------------------------------------------
677  // HEURISTICS.
678  //------------------------------------------------------
679 
681  void addHeuristic(BlisHeuristic * heur);
682 
684  BlisHeuristic * heuristics(int i) const { return heuristics_[i]; }
685 
687  int numHeuristics() const { return numHeuristics_; }
688 
689  //------------------------------------------------------
690  // CONSTRAINTS.
691  //------------------------------------------------------
692 
694  void addCutGenerator(BlisConGenerator * generator);
695 
697  void addCutGenerator(CglCutGenerator * generator,
698  const char * name = NULL,
700  int cutGenerationFrequency = 1,
701  bool normal = true,
702  bool atSolution = false,
703  bool whenInfeasible = false);
704 
706  BlisConGenerator *cutGenerators(int i) const { return generators_[i]; }
707 
709  int numCutGenerators() const { return numCutGenerators_; }
710 
712  int getMaxNumCons() const { return maxNumCons_; }
713 
715  void setMaxNumCons(int m) { maxNumCons_ = m; }
716 
719 
722  { return constraintPoolReceive_; }
723 
726 
728 
729  int getNumOldConstraints() const { return numOldConstraints_; }
730 
732  void setNumOldConstraints(int num) { numOldConstraints_ = num; }
733 
736 
739 
742 
745 
748  delete [] oldConstraints_;
749  oldConstraints_ = NULL;
750  }
752 
755  return cutStrategy_;
756  }
757 
760 
763 
766 
768  int getDenseConCutoff() const { return denseConCutoff_; }
769 
771  void setDenseConCutoff(int cutoff) { denseConCutoff_ = cutoff; }
772 
774  double *getConRandoms() const { return conRandoms_; }
775 
776  //------------------------------------------------------
777  // PRIORITY AND WEITGHT.
778  //------------------------------------------------------
779 
794  void passInPriorities(const int * priorities,
795  bool ifNotSimpleIntegers,
796  int defaultValue = 1000);
797 
799  inline const int * priority() const { return priority_; }
800 
802  inline int priority(int sequence) const {
803  if (priority_) return priority_[sequence];
804  else return 1000;
805  }
806 
807  inline double getNodeWeight() const { return nodeWeight_; }
808 
809  inline void setNodeWeight(double nw) { nodeWeight_ = nw; }
811 
812  //------------------------------------------------------
813  // STATISTICS.
814  //------------------------------------------------------
815 
817  virtual void modelLog();
818 
820  int getNumNodes() const { return numNodes_; }
821 
823  int getNumIterations() const { return numIterations_; }
824 
826  int getAveIterations() const { return aveIterations_; }
827 
829  void addNumNodes(int newNodes = 1) { numNodes_ += newNodes; }
830 
832  void addNumIterations(int newIter) {
833  numIterations_ += newIter;
835  }
836 
839  { return blisMessageHandler_; }
840 
843 
846  BlisParams * BlisPar() { return BlisPar_; }
848 
850  virtual void nodeLog(AlpsTreeNode *node, bool force);
851 
853  virtual bool fathomAllNodes();
854 
855  //------------------------------------------------------
856  // PARALLEL
857  //------------------------------------------------------
858 
859  protected:
860 
862  AlpsReturnStatus encodeBlis(AlpsEncoded *encoded) const;
863 
866 
868  void packSharedPseudocost(AlpsEncoded *encoded, int numToShare);
869 
871  void unpackSharedPseudocost(AlpsEncoded &encoded);
872 
874  void packSharedConstraints(AlpsEncoded *encoded);
875 
877  void unpackSharedConstraints(AlpsEncoded &encoded);
878 
880  void packSharedVariables(AlpsEncoded *encoded);
881 
883  void unpackSharedVariables(AlpsEncoded &encoded);
884 
885  public:
886 
889  virtual void registerKnowledge();
890 
891  using AlpsKnowledge::encode ;
893  virtual AlpsEncoded* encode() const;
894 
896  virtual void decodeToSelf(AlpsEncoded&);
897 
900  virtual AlpsEncoded* packSharedKnowlege();
901 
903  virtual void unpackSharedKnowledge(AlpsEncoded&);
904 
905  //AT - Begin
906  virtual void presolveForTheWholeTree();
907  //AT - end
908 };
909 
910 #endif /* End of file */
BlisModel::createRoot
virtual AlpsTreeNode * createRoot()
For parallel code, only the master calls this function.
BlisModel::getObjCoef
double * getObjCoef() const
Get objective coefficients.
Definition: BlisModel.h:486
BlisSolution
This class contains the solutions generated by the LP solver (either primal or dual.
Definition: BlisSolution.h:36
BlisModel::setOldConstraintsSize
void setOldConstraintsSize(int num)
Set max number of old constraints.
Definition: BlisModel.h:738
BlisModel::delOldConstraints
void delOldConstraints()
Set max number of old constraints.
Definition: BlisModel.h:747
BlisModel::branchStrategy_
BcpsBranchStrategy * branchStrategy_
Variable selection function.
Definition: BlisModel.h:170
BlisModel::currAbsGap_
double currAbsGap_
Current absolute optimal gap.
Definition: BlisModel.h:317
BlisModel::intObjIndices_
int * intObjIndices_
Definition: BlisModel.h:158
BlisModel::setSharedObjectMark
void setSharedObjectMark(int i)
Mark object to be shared.
Definition: BlisModel.h:633
BlisModel::rampUpBranchStrategy
BcpsBranchStrategy * rampUpBranchStrategy() const
Definition: BlisModel.h:613
BcpsModel
BlisModel::cutoff_
double cutoff_
Cutoff in lp solver.
Definition: BlisModel.h:149
BlisModel::setBranchingMethod
void setBranchingMethod(BcpsBranchStrategy &method)
Set the branching stratedy.
Definition: BlisModel.h:609
BlisModel::getConRandoms
double * getConRandoms() const
Get randoms for check parallel constraints.
Definition: BlisModel.h:774
BlisModel::numIntObjects_
int numIntObjects_
Column types.
Definition: BlisModel.h:115
BlisModel::constraintPoolSend
BcpsConstraintPool * constraintPoolSend()
Access send constraint pool.
Definition: BlisModel.h:725
BlisModel::encodeBlis
AlpsReturnStatus encodeBlis(AlpsEncoded *encoded) const
Pack Blis portion of the model into an encoded object.
BlisModel::addHeuristic
void addHeuristic(BlisHeuristic *heur)
Add a heuristic.
BlisModel::createObjects
void createObjects()
Create variables and constraints.
BlisModel::unpackSharedConstraints
void unpackSharedConstraints(AlpsEncoded &encoded)
Unpack and store shared constraints.
BlisModel::userFeasibleSolution
virtual BlisSolution * userFeasibleSolution(const double *solution, bool &feasible)
User's criteria for a feasible solution.
Definition: BlisModel.h:583
BlisModel::feasibleSolution
virtual BlisSolution * feasibleSolution(int &numIntegerInfs, int &numObjectInfs)
Test the current LP solution for feasiblility.
BlisModel::encode
virtual AlpsEncoded * encode() const
The method that encodes the model into an encoded object.
BlisHeuristic
Heuristic base class.
Definition: BlisHeuristic.h:48
BlisModel::unpackSharedVariables
void unpackSharedVariables(AlpsEncoded &encoded)
Unpack and store shared variables.
BlisModel::problemSetup
bool problemSetup
Definition: BlisModel.h:132
BlisPresolve
A interface to Osi/Coin Presolve.
Definition: BlisPresolve.h:37
OsiSolverInterface::getNumRows
virtual int getNumRows() const=0
BlisModel::varLB
double * varLB()
Get variable bounds arrary.
Definition: BlisModel.h:501
BlisConGenerator
Interface between Blis and Cut Generation Library.
Definition: BlisConGenerator.h:58
BlisModel::numObjects_
int numObjects_
Number of objects.
Definition: BlisModel.h:179
BlisModel::leafToRootPath
std::vector< AlpsTreeNode * > leafToRootPath
Record the path from leaf to root.
Definition: BlisModel.h:329
CoinLpIO.hpp
BlisModel::numRows_
int numRows_
Definition: BlisModel.h:103
BlisModel::numBranchResolve_
int numBranchResolve_
Maximum number of resolve during branching.
Definition: BlisModel.h:200
BlisModel::constraintPoolReceive
BcpsConstraintPool * constraintPoolReceive()
Access receive constraint pool.
Definition: BlisModel.h:721
BlisModel::setCutoff
void setCutoff(double co)
Set cut off value.
Definition: BlisModel.h:552
BlisModel::numNodes_
int numNodes_
Number of processed nodes.
Definition: BlisModel.h:263
BlisModel::registerKnowledge
virtual void registerKnowledge()
Register knowledge.
BlisModel::addObjects
void addObjects(int numObjects, BcpsObject **objects)
Add in object information.
BlisModel::writeParameters
virtual void writeParameters(std::ostream &outstream) const
Write out parameters.
BlisModel::getNumBranchResolve
int getNumBranchResolve()
Get the maximum number of resolve during branching.
Definition: BlisModel.h:467
BcpsObject
BlisModel::setNodeWeight
void setNodeWeight(double nw)
Definition: BlisModel.h:809
BlisModel::presolve_
BlisPresolve * presolve_
Definition: BlisModel.h:129
BlisModel::fathomAllNodes
virtual bool fathomAllNodes()
Return true, if all nodes can be fathomed.
BlisHeuristic.h
BlisModel::boundingPass_
int boundingPass_
The number of passes during bounding procedure.
Definition: BlisModel.h:302
BlisPseudo.h
BlisModel::oldConstraintsSize_
int oldConstraintsSize_
The memory size allocated for oldConstraints_.
Definition: BlisModel.h:238
BlisModel::setOldConstraints
void setOldConstraints(BlisConstraint **old)
set old constraints.
Definition: BlisModel.h:744
BlisModel::cutGenerators
BlisConGenerator * cutGenerators(int i) const
Get a specific cut generator.
Definition: BlisModel.h:706
BlisModel::nodeWeight_
double nodeWeight_
Definition: BlisModel.h:197
BlisModel::resolve
bool resolve()
Resolving a lp.
BlisModel::init
void init()
Intialize member data.
AlpsReturnStatus
AlpsReturnStatus
BlisModel::presolveForTheWholeTree
virtual void presolveForTheWholeTree()
BlisModel::priority
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
Definition: BlisModel.h:802
BlisModel::generators_
BlisConGenerator ** generators_
The list of cut generators used.
Definition: BlisModel.h:229
BlisModel::numOldConstraints_
int numOldConstraints_
Number of old constraints.
Definition: BlisModel.h:241
BlisModel
Definition: BlisModel.h:69
BlisModel::constraintPool
BcpsConstraintPool * constraintPool()
Access constraint pool.
Definition: BlisModel.h:718
BlisModel::getMaxNumCons
int getMaxNumCons() const
Get the max number of cuts can be generated.
Definition: BlisModel.h:712
OsiSolverInterface::getObjValue
virtual double getObjValue() const=0
BlisModel::tempVarUBPos
int * tempVarUBPos()
Definition: BlisModel.h:518
BlisModel::conLB_
double * conLB_
Definition: BlisModel.h:96
BlisModel::getNumSolutions
int getNumSolutions() const
Get number of solutions.
Definition: BlisModel.h:537
BlisModel::getNumRows
int getNumRows()
Get number of rows.
Definition: BlisModel.h:498
BlisModel::colMatrix_
CoinPackedMatrix * colMatrix_
Column majored matrix.
Definition: BlisModel.h:90
BlisModel::packSharedKnowlege
virtual AlpsEncoded * packSharedKnowlege()
Pack knowledge to be shared with others into an encoded object.
BlisModel::numHeuristics_
int numHeuristics_
Number of heuristics.
Definition: BlisModel.h:207
BlisHotStartStrategy
BlisHotStartStrategy
Definition: Blis.h:95
BlisModel::clearSharedObjectMark
void clearSharedObjectMark()
Clear all the share mark.
Definition: BlisModel.h:636
BlisModel::numStrong_
int numStrong_
Number of strong branching.
Definition: BlisModel.h:194
BlisModel::priority
const int * priority() const
Priorities.
Definition: BlisModel.h:799
BlisModel::presolved
bool presolved
Definition: BlisModel.h:131
BlisModel::varUB_
double * varUB_
Definition: BlisModel.h:95
BlisVariable
Definition: BlisVariable.h:31
BlisModel::decodeToSelf
virtual void decodeToSelf(AlpsEncoded &)
The method that decodes the model from an encoded object.
BlisModel::getFeasCheckTime
int getFeasCheckTime()
Get the total time spent checking solutions for feasibility.
Definition: BlisModel.h:473
BlisModel::setFeasCheckTime
void setFeasCheckTime(double t)
Set the total time spent checking solutions for feasibility.
Definition: BlisModel.h:476
BlisModel::startVarLB_
double * startVarLB_
Starting var/con bounds for processing each node.
Definition: BlisModel.h:163
CoinMessages
BlisModel::numObjects
int numObjects() const
Get the number of objects.
Definition: BlisModel.h:621
BlisModel::getNumIterations
int getNumIterations() const
Get how many iterations it took to solve the problem.
Definition: BlisModel.h:823
BcpsBranchStrategy.h
CoinMpsIO.hpp
AlpsEncoded
BlisModel::objSense_
double objSense_
Objective function.
Definition: BlisModel.h:109
BlisModel::blisMessages
CoinMessages blisMessages()
Return messages.
Definition: BlisModel.h:842
BlisModel::lpSolver_
OsiSolverInterface * lpSolver_
Actually used.
Definition: BlisModel.h:83
BlisModel::addNumIterations
void addNumIterations(int newIter)
Increment Iteration count.
Definition: BlisModel.h:832
BlisModel::setNumBranchResolve
void setNumBranchResolve(int num)
Set the maximum number of resolve during branching.
Definition: BlisModel.h:470
BlisModel::getColUpper
const double * getColUpper()
Get column upper bound.
Definition: BlisModel.h:492
BlisModel::addNumStrong
void addNumStrong(int num=1)
Add num to number of strong branchings.
Definition: BlisModel.h:464
BlisModel::incumbent_
double * incumbent_
Incumbent.
Definition: BlisModel.h:146
BlisModel::getLpObjValue
double getLpObjValue() const
Get current objective function value.
Definition: BlisModel.h:527
BlisModel::tempVarUBPos_
int * tempVarUBPos_
Definition: BlisModel.h:281
BlisModel::passInPriorities
void passInPriorities(const int *priorities, bool ifNotSimpleIntegers, int defaultValue=1000)
Pass in branching priorities.
BlisModel::tempConUBPos_
int * tempConUBPos_
Definition: BlisModel.h:283
BlisModel::packSharedVariables
void packSharedVariables(AlpsEncoded *encoded)
Retrieve and pack shared variables.
BlisModel::numHeurSolutions_
int numHeurSolutions_
Definition: BlisModel.h:140
BcpsObjectPool.h
BlisModel::createIntgerObjects
void createIntgerObjects(bool startAgain)
Identify integer variable.
BlisParams::cutoffInc
@ cutoffInc
The value added to relaxation value when deciding fathom.
Definition: BlisParams.h:142
BlisModel::objects
BcpsObject * objects(int which)
Get the specified object.
Definition: BlisModel.h:630
BlisModel::getLpSolution
const double * getLpSolution() const
Get active lp solution.
Definition: BlisModel.h:530
AlpsTreeNode.h
AlpsTreeNode::setSolEstimate
void setSolEstimate(double est)
BlisModel::denseConCutoff_
int denseConCutoff_
Dense constraint cutoff.
Definition: BlisModel.h:247
CglCutGenerator.hpp
BlisModel::setConUb
void setConUb(double *cu)
Pass column lower bounds.
Definition: BlisModel.h:373
BlisModel::packSharedPseudocost
void packSharedPseudocost(AlpsEncoded *encoded, int numToShare)
Retrieve and pack shared pseudocost.
BlisModel::setNumCons
void setNumCons(int num)
Pass column upper bounds.
Definition: BlisModel.h:361
BlisModel::heuristics
BlisHeuristic * heuristics(int i) const
Get a specific heuristic.
Definition: BlisModel.h:684
BlisModel::cutGenerationFrequency_
int cutGenerationFrequency_
Frequency of cut generation.
Definition: BlisModel.h:220
BlisModel::deleteObjects
void deleteObjects()
Delete all object information.
BlisModel::postprocess
virtual void postprocess()
Postprocessing the searching results.
AlpsTreeNode
BlisModel::startVarUB_
double * startVarUB_
Definition: BlisModel.h:164
BlisSolutionType
BlisSolutionType
Definition: Blis.h:112
BlisModel::numCutGenerators
int numCutGenerators() const
Get the number of cut generators.
Definition: BlisModel.h:709
BlisModel::incObjValue_
double incObjValue_
Incumbent objective value.
Definition: BlisModel.h:143
BlisModel::getSolver
virtual OsiSolverInterface * getSolver()
Get lp solver.
Definition: BlisModel.h:446
BlisModel::numCols_
int numCols_
Number of columns/rows/elements.
Definition: BlisModel.h:102
BlisModel::constraintPoolSend_
BcpsConstraintPool * constraintPoolSend_
Constraints that can be sent/broadcasted to other processes.
Definition: BlisModel.h:291
BlisModel::startConLB_
double * startConLB_
Definition: BlisModel.h:165
BlisModel::getCutStrategy
BlisCutStrategy getCutStrategy() const
Query constraint generation strategy.
Definition: BlisModel.h:754
BlisModel::storeSolution
int storeSolution(BlisSolutionType how, BlisSolution *sol)
Record a new incumbent solution and update objectiveValue.
BlisModel::maxNumCons_
int maxNumCons_
Number of cuts can be generators.
Definition: BlisModel.h:226
AlpsKnowledge::encode
virtual AlpsEncoded * encode() const
BlisModel::readInstance
virtual void readInstance(const char *dataFile)
For parallel code, only the master calls this function.
BlisModel::varLB_
double * varLB_
Variable and constraint bounds.
Definition: BlisModel.h:94
BlisModel::getDenseConCutoff
int getDenseConCutoff() const
Get the thresheld to be considered as a dense constraint.
Definition: BlisModel.h:768
BlisParams
Definition: BlisParams.h:35
CglCutGenerator
BlisModel::setSolver
virtual void setSolver(OsiSolverInterface *si)
Set lp solver.
Definition: BlisModel.h:443
BlisModel::tempConLBPos
int * tempConLBPos()
Definition: BlisModel.h:519
OsiSolverInterface::getColSolution
virtual const double * getColSolution() const=0
BlisModel::setNumElems
void setNumElems(int num)
Pass column upper bounds.
Definition: BlisModel.h:367
BlisModel::getNumHeurSolutions
int getNumHeurSolutions() const
Get number of heuristic solutions.
Definition: BlisModel.h:540
BlisModel::blisMessageHandler_
CoinMessageHandler * blisMessageHandler_
Message handler.
Definition: BlisModel.h:257
BlisParams::entry
bool entry(const chrParams key) const
Definition: BlisParams.h:236
BlisMessage.h
BlisModel::objects_
BcpsObject ** objects_
The set of objects.
Definition: BlisModel.h:182
BlisModel::getCutoff
double getCutoff() const
Get cut off value.
Definition: BlisModel.h:549
BlisModel::constraintPool_
BcpsConstraintPool * constraintPool_
Store all the cuts.
Definition: BlisModel.h:232
BlisModel::oldConstraints_
BlisConstraint ** oldConstraints_
Temporary store old cuts at a node when installing a node.
Definition: BlisModel.h:235
BlisModel::setupSelf
virtual bool setupSelf()
All processes call this function.
Blis.h
BlisModel::getAveIterations
int getAveIterations() const
Get the average iterations it took to solve a lp.
Definition: BlisModel.h:826
BlisModel::heurStrategy_
BlisHeurStrategy heurStrategy_
If use heuristics.
Definition: BlisModel.h:320
CoinMessageHandler
BlisModel::setVarUb
void setVarUb(double *ub)
Pass variable lower bounds.
Definition: BlisModel.h:379
BlisModel::cutoffInc_
double cutoffInc_
Cutoff increment.
Definition: BlisModel.h:152
BlisModel::startVarUB
double * startVarUB()
Definition: BlisModel.h:510
OsiCuts
BlisModel::setColType
void setColType(char *colType)
Pass variable types.
Definition: BlisModel.h:382
BlisModel::numHeuristics
int numHeuristics() const
Get the number of heuristics.
Definition: BlisModel.h:687
BlisModel::activeNode_
AlpsTreeNode * activeNode_
Active node.
Definition: BlisModel.h:191
BlisModel::inputVar_
std::vector< BcpsVariable * > inputVar_
User's input objects.
Definition: BlisModel.h:121
BlisModel::objects
BcpsObject ** objects()
Get the array of objects.
Definition: BlisModel.h:627
BlisModel::incumbent
double * incumbent()
Return best ip solution found so far.
Definition: BlisModel.h:543
BlisModel::tempConUBPos
int * tempConUBPos()
Definition: BlisModel.h:520
BlisCutStrategy
BlisCutStrategy
Definition: Blis.h:69
BlisModel::setNumOldConstraints
void setNumOldConstraints(int num)
Set number of old constraints.
Definition: BlisModel.h:732
BlisModel::numIterations_
int numIterations_
Number of lp(Simplex) iterations.
Definition: BlisModel.h:266
BlisModel::setSolEstimate
void setSolEstimate(double est)
Set the solution estimate of the active node.
Definition: BlisModel.h:458
BlisModel::currRelGap_
double currRelGap_
Current relative optimal gap.
Definition: BlisModel.h:314
BlisModel::BlisPar_
BlisParams * BlisPar_
Blis parameters.
Definition: BlisModel.h:254
BlisModel::optimalAbsGap_
double optimalAbsGap_
Input absolute optimal gap.
Definition: BlisModel.h:311
OsiCuts.hpp
BlisModel::setDenseConCutoff
void setDenseConCutoff(int cutoff)
Set the thresheld to be considered as a dense constraint.
Definition: BlisModel.h:771
BlisModel::nodeLog
virtual void nodeLog(AlpsTreeNode *node, bool force)
Node log.
BlisModel::setCutStrategy
void setCutStrategy(BlisCutStrategy u)
Set constraint generation strategy.
Definition: BlisModel.h:759
OsiSolverInterface
BlisModel::checkInteger
bool checkInteger(double value) const
Check if a value is integer.
Definition: BlisModel.h:663
BlisModel::hotstartStrategy_
BlisHotStartStrategy hotstartStrategy_
Definition: BlisModel.h:176
CoinPackedMatrix.hpp
BlisModel::setActiveNode
void setActiveNode(AlpsTreeNode *node)
Set active node.
Definition: BlisModel.h:455
BlisModel::constraintPoolReceive_
BcpsConstraintPool * constraintPoolReceive_
Constraints that are received from other processses.
Definition: BlisModel.h:294
BlisParams.h
BlisHeurStrategy
BlisHeurStrategy
Definition: Blis.h:77
BlisModel::conUB_
double * conUB_
Definition: BlisModel.h:97
BlisModel::startVarLB
double * startVarLB()
The starting variable bounds arrary of a subproblem (internal use).
Definition: BlisModel.h:509
BlisModel::tempConLBPos_
int * tempConLBPos_
Definition: BlisModel.h:282
BlisModel::tempVarLBPos_
int * tempVarLBPos_
Tempory storage for var/con indices.
Definition: BlisModel.h:280
BlisModel::origLpSolver_
OsiSolverInterface * origLpSolver_
Input by user.
Definition: BlisModel.h:78
CoinPackedMatrix
BlisModel::decodeBlis
AlpsReturnStatus decodeBlis(AlpsEncoded &encoded)
Unpack Blis portion of the model from an encoded object.
BlisModel::startConUB_
double * startConUB_
Definition: BlisModel.h:166
BcpsVariable
BlisModel::sharedObjectMark_
char * sharedObjectMark_
The objects that can be shared.
Definition: BlisModel.h:185
BlisModel::addNumNodes
void addNumNodes(int newNodes=1)
Increment node count.
Definition: BlisModel.h:829
BlisModel::blisMessages_
CoinMessages blisMessages_
Blis messages.
Definition: BlisModel.h:260
OsiSolverInterface.hpp
BlisModel::optimalRelGap_
double optimalRelGap_
Input relative optimal gap.
Definition: BlisModel.h:308
BlisModel::setMaxNumCons
void setMaxNumCons(int m)
Set the max number of cuts can be generated.
Definition: BlisModel.h:715
BlisModel::isRoot_
bool isRoot_
If root node.
Definition: BlisModel.h:299
BlisModel::getIntObjIndices
int * getIntObjIndices() const
Get integers' object indices.
Definition: BlisModel.h:654
BlisModel::numElems_
int numElems_
Definition: BlisModel.h:104
BlisModel::setObjCoef
void setObjCoef(double *obj)
Pass objective coefficients.
Definition: BlisModel.h:387
BlisModel::getNumStrong
int getNumStrong()
Get number of strong branchings.
Definition: BlisModel.h:461
BlisModel::readParameters
virtual void readParameters(const int argnum, const char *const *arglist)
Read in Alps, Blis parameters.
BlisModel::setColMatrix
void setColMatrix(CoinPackedMatrix *mat)
Pass a matrix in.
Definition: BlisModel.h:358
BlisModel::numSolutions_
int numSolutions_
Definition: BlisModel.h:139
BlisModel::addFeasCheckTime
void addFeasCheckTime(double t)
Add to the time spent checking solutions for feasibility.
Definition: BlisModel.h:479
AlpsEnumProcessT.h
BlisModel::getOldConstraintsSize
int getOldConstraintsSize() const
Get max number of old constraints.
Definition: BlisModel.h:735
BlisModel::conUB
double * conUB()
Definition: BlisModel.h:506
BlisPresolve.h
BlisModel::startConUB
double * startConUB()
Definition: BlisModel.h:514
BlisModel::cutStrategy_
BlisCutStrategy cutStrategy_
If use cut generators.
Definition: BlisModel.h:217
BlisModel::feasCheckTime_
double feasCheckTime_
Time spent checking feasibility of solutions.
Definition: BlisModel.h:272
OsiSolverInterface::getColUpper
virtual const double * getColUpper() const=0
BlisModel::unpackSharedPseudocost
void unpackSharedPseudocost(AlpsEncoded &encoded)
Unpack and store shared pseduocost.
BlisModel::integerTol_
double integerTol_
Integer tolerance.
Definition: BlisModel.h:305
BlisCutStrategyAuto
@ BlisCutStrategyAuto
Definition: Blis.h:73
BlisConstraint
Definition: BlisConstraint.h:33
BlisModel::newCutPool_
OsiCuts newCutPool_
Store new cuts in each pass.
Definition: BlisModel.h:326
BlisModel::presolvedLpSolver_
OsiSolverInterface * presolvedLpSolver_
Presolved.
Definition: BlisModel.h:80
BlisModel::setVarLb
void setVarLb(double *lb)
Pass variable upper bounds.
Definition: BlisModel.h:376
BlisModel::packSharedConstraints
void packSharedConstraints(AlpsEncoded *encoded)
Retrieve and pack shared constraints.
BlisModel::~BlisModel
virtual ~BlisModel()
Destructor.
BlisModel::intColIndices_
int * intColIndices_
Definition: BlisModel.h:116
BlisModel::conLB
double * conLB()
Get original constraint bounds arrary.
Definition: BlisModel.h:505
BlisModel::importModel
virtual void importModel(std::vector< BlisVariable * > vars, std::vector< BlisConstraint * > cons)
For parallel code, only the master calls this function.
BlisModel::inputCon_
std::vector< BcpsConstraint * > inputCon_
Definition: BlisModel.h:122
BlisModel::colType_
char * colType_
Definition: BlisModel.h:159
BlisModel::getColLower
const double * getColLower()
Get column lower bound.
Definition: BlisModel.h:489
BcpsBranchStrategy
BlisModel::conRandoms_
double * conRandoms_
Random keys.
Definition: BlisModel.h:244
BlisModel::getNumIntObjects
int getNumIntObjects() const
Get number of integers.
Definition: BlisModel.h:657
BlisModel::feasibleSolutionHeur
BlisSolution * feasibleSolutionHeur(const double *solution)
Test if a solution found by heuristic is feasible.
BlisModel::setBranchingMethod
void setBranchingMethod(BcpsBranchStrategy *method)
Set the branching strategy.
Definition: BlisModel.h:603
BlisModel::rampUpBranchStrategy_
BcpsBranchStrategy * rampUpBranchStrategy_
Definition: BlisModel.h:171
BlisModel::branchStrategy
BcpsBranchStrategy * branchStrategy() const
Get the current branching strategy.
Definition: BlisModel.h:599
BlisModel::BlisPar
BlisParams * BlisPar()
Access parameters.
Definition: BlisModel.h:846
BlisModel::gutsOfDestructor
void gutsOfDestructor()
Actual destructor.
AlpsParams.h
BlisModel::analyzeObjective
void analyzeObjective()
BlisModel::getNumOldConstraints
int getNumOldConstraints() const
Get number of old constraints.
Definition: BlisModel.h:729
BlisConGenerator.h
BlisModel::startConLB
double * startConLB()
The starting constraint bounds arrary of a subproblem (internal use).
Definition: BlisModel.h:513
BlisModel::getIntColIndices
int * getIntColIndices() const
Get integers' column indices.
Definition: BlisModel.h:660
BlisModel::setConLb
void setConLb(double *cl)
Pass column upper bounds.
Definition: BlisModel.h:370
BlisModel::aveIterations_
int aveIterations_
Average number of lp iterations to solve a subproblem.
Definition: BlisModel.h:269
BlisModel::varUB
double * varUB()
Definition: BlisModel.h:502
BlisModel::setNumVars
void setNumVars(int num)
Pass column upper bounds.
Definition: BlisModel.h:364
BlisModel::addCutGenerator
void addCutGenerator(BlisConGenerator *generator)
Add a Blis cut generator.
BlisModel::oldConstraints
BlisConstraint ** oldConstraints()
Access old constraints.
Definition: BlisModel.h:741
OsiSolverInterface::getNumCols
virtual int getNumCols() const=0
BcpsModel.h
OsiSolverInterface::setDblParam
virtual bool setDblParam(OsiDblParam key, double value)
BlisModel::setNumObjects
void setNumObjects(int num)
Set the number of objects.
Definition: BlisModel.h:624
BlisModel::getNumCols
int getNumCols()
Get number of columns.
Definition: BlisModel.h:495
BlisModel::heurCallFrequency_
int heurCallFrequency_
Frequency of using heuristics.
Definition: BlisModel.h:323
BlisModel::setCutStrategy
void setCutStrategy(int f)
Set constraint generation frequency.
Definition: BlisModel.h:765
BlisModel::solver
virtual OsiSolverInterface * solver()
Get lp solver.
Definition: BlisModel.h:449
BlisModel::tempVarLBPos
int * tempVarLBPos()
Temparory storage.
Definition: BlisModel.h:517
BlisModel::BlisModel
BlisModel()
Default construtor.
Definition: BlisModel.h:342
BcpsObject.h
OsiDualObjectiveLimit
OsiDualObjectiveLimit
BlisModel::priority_
int * priority_
Priorities of integer object.
Definition: BlisModel.h:188
BlisModel::heuristics_
BlisHeuristic ** heuristics_
The list of heuristics.
Definition: BlisModel.h:210
OsiSolverInterface::getColLower
virtual const double * getColLower() const=0
BlisModel::modelLog
virtual void modelLog()
Log of specific models.
BcpsConstraintPool
BlisModel::preprocess
virtual void preprocess()
Preprocessing the model.
BlisModel::unpackSharedKnowledge
virtual void unpackSharedKnowledge(AlpsEncoded &)
Unpack and store shared knowledge from an encoded object.
BlisModel::objCoef_
double * objCoef_
Definition: BlisModel.h:110
BlisModel::getCutGenerationFrequency
int getCutGenerationFrequency() const
Query constraint generation frequency.
Definition: BlisModel.h:762
BlisModel::numCutGenerators_
int numCutGenerators_
Number of cut generators used.
Definition: BlisModel.h:223
BlisModel::getNumNodes
int getNumNodes() const
Get how many Nodes it took to solve the problem.
Definition: BlisModel.h:820
BlisModel::blisMessageHandler
CoinMessageHandler * blisMessageHandler() const
Get the message handler.
Definition: BlisModel.h:838
BlisModel::getNodeWeight
double getNodeWeight() const
Definition: BlisModel.h:807