source: trunk/Cbc/src/CbcModel.hpp @ 862

Last change on this file since 862 was 862, checked in by forrest, 11 years ago

try and make faster

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 76.4 KB
Line 
1// Copyright (C) 2002, International Business Machines
2// Corporation and others.  All Rights Reserved.
3#ifndef CbcModel_H
4#define CbcModel_H
5#include <string>
6#include <vector>
7#include "CoinFinite.hpp"
8#include "CoinMessageHandler.hpp"
9#include "OsiSolverInterface.hpp"
10#include "OsiBranchingObject.hpp"
11#include "OsiCuts.hpp"
12#include "CoinWarmStartBasis.hpp"
13#include "CbcCompareBase.hpp"
14#include "CbcMessage.hpp"
15
16//class OsiSolverInterface;
17
18class CbcCutGenerator;
19class OsiRowCut;
20class OsiBabSolver;
21class OsiRowCutDebugger;
22class CglCutGenerator;
23class CbcCutModifier;
24class CglTreeProbingInfo;
25class CbcHeuristic;
26class OsiObject;
27class CbcTree;
28class CbcStrategy;
29class CbcFeasibilityBase;
30class CbcStatistics;
31class CbcEventHandler ;
32class CglPreProcess;
33
34// #define CBC_CHECK_BASIS 1
35
36//#############################################################################
37
38/** Simple Branch and bound class
39
40  The initialSolve() method solves the initial LP relaxation of the MIP
41  problem. The branchAndBound() method can then be called to finish using
42  a branch and cut algorithm.
43
44  <h3>Search Tree Traversal</h3>
45
46  Subproblems (aka nodes) requiring additional evaluation are stored using
47  the CbcNode and CbcNodeInfo objects. Ancestry linkage is maintained in the
48  CbcNodeInfo object. Evaluation of a subproblem within branchAndBound()
49  proceeds as follows:
50  <ul>
51    <li> The node representing the most promising parent subproblem is popped
52         from the heap which holds the set of subproblems requiring further
53         evaluation.
54    <li> Using branching instructions stored in the node, and information in
55         its ancestors, the model and solver are adjusted to create the
56         active subproblem.
57    <li> If the parent subproblem will require further evaluation
58         (<i>i.e.</i>, there are branches remaining) its node is pushed back
59         on the heap. Otherwise, the node is deleted.  This may trigger
60         recursive deletion of ancestors.
61    <li> The newly created subproblem is evaluated.
62    <li> If the subproblem requires further evaluation, a node is created.
63         All information needed to recreate the subproblem (branching
64         information, row and column cuts) is placed in the node and the node
65         is added to the set of subproblems awaiting further evaluation.
66  </ul>
67  Note that there is never a node representing the active subproblem; the model
68  and solver represent the active subproblem.
69
70  <h3>Row (Constraint) Cut Handling</h3>
71
72  For a typical subproblem, the sequence of events is as follows:
73  <ul>
74    <li> The subproblem is rebuilt for further evaluation: One result of a
75         call to addCuts() is a traversal of ancestors, leaving a list of all
76         cuts used in the ancestors in #addedCuts_. This list is then scanned
77         to construct a basis that includes only tight cuts. Entries for
78         loose cuts are set to NULL.
79    <li> The subproblem is evaluated: One result of a call to solveWithCuts()
80         is the return of a set of newly generated cuts for the subproblem.
81         #addedCuts_ is also kept up-to-date as old cuts become loose.
82    <li> The subproblem is stored for further processing: A call to
83         CbcNodeInfo::addCuts() adds the newly generated cuts to the
84         CbcNodeInfo object associated with this node.
85  </ul>
86  See CbcCountRowCut for details of the bookkeeping associated with cut
87  management.
88*/
89
90class CbcModel  {
91 
92public:
93
94enum CbcIntParam {
95  /** The maximum number of nodes before terminating */
96  CbcMaxNumNode=0,
97  /** The maximum number of solutions before terminating */
98  CbcMaxNumSol,
99  /** Fathoming discipline
100
101    Controls objective function comparisons for purposes of fathoming by bound
102    or determining monotonic variables.
103
104    If 1, action is taken only when the current objective is strictly worse
105    than the target. Implementation is handled by adding a small tolerance to
106    the target.
107  */
108  CbcFathomDiscipline,
109  /** Adjusts printout
110      1 does different node message with number unsatisfied on last branch
111  */
112  CbcPrinting,
113  /** Just a marker, so that a static sized array can store parameters. */
114  CbcLastIntParam
115};
116
117enum CbcDblParam {
118  /** The maximum amount the value of an integer variable can vary from
119      integer and still be considered feasible. */
120  CbcIntegerTolerance=0,
121  /** The objective is assumed to worsen by this amount for each
122      integer infeasibility. */
123  CbcInfeasibilityWeight,
124  /** The amount by which to tighten the objective function cutoff when
125      a new solution is discovered. */
126  CbcCutoffIncrement,
127  /** Stop when the gap between the objective value of the best known solution
128    and the best bound on the objective of any solution is less than this.
129 
130    This is an absolute value. Conversion from a percentage is left to the
131    client.
132  */
133  CbcAllowableGap,
134  /** Stop when the gap between the objective value of the best known solution
135    and the best bound on the objective of any solution is less than this
136    fraction of of the absolute value of best known solution.
137 
138    Code stops if either this test or CbcAllowableGap test succeeds
139  */
140  CbcAllowableFractionGap,
141  /** \brief The maximum number of seconds before terminating.
142             A double should be adequate! */
143  CbcMaximumSeconds,
144  /// Cutoff - stored for speed
145  CbcCurrentCutoff,
146  /// Optimization direction - stored for speed
147  CbcOptimizationDirection,
148  /// Current objective value
149  CbcCurrentObjectiveValue,
150  /// Current minimization objective value
151  CbcCurrentMinimizationObjectiveValue,
152  /** \brief The time at start of model.
153             So that other pieces of code can access */
154  CbcStartSeconds,
155  /** Just a marker, so that a static sized array can store parameters. */
156  CbcLastDblParam
157};
158
159  //---------------------------------------------------------------------------
160
161public:
162  ///@name Solve methods
163  //@{
164    /** \brief Solve the initial LP relaxation
165
166      Invoke the solver's %initialSolve() method.
167    */
168    void initialSolve(); 
169
170    /** \brief Invoke the branch \& cut algorithm
171
172      The method assumes that initialSolve() has been called to solve the
173      LP relaxation. It processes the root node, then proceeds to explore the
174      branch & cut search tree. The search ends when the tree is exhausted or
175      one of several execution limits is reached.
176      If doStatistics is 1 summary statistics are printed
177      if 2 then also the path to best solution (if found by branching)
178      if 3 then also one line per node
179    */
180     void branchAndBound(int doStatistics=0);
181
182    /** \brief create a clean model from partially fixed problem
183
184      The method creates a new model with given bounds and with no tree.
185    */
186     CbcModel *  cleanModel(const double * lower, const double * upper);
187    /** \brief Invoke the branch \& cut algorithm on partially fixed problem
188
189      The method presolves the given model and does branch and cut. The search
190      ends when the tree is exhausted or maximum nodes is reached.
191
192      If better solution found then it is saved.
193
194      Returns 0 if search completed and solution, 1 if not completed and solution,
195      2 if completed and no solution, 3 if not completed and no solution.
196
197      Normally okay to do cleanModel immediately followed by subBranchandBound
198      (== other form of subBranchAndBound)
199      but may need to get at model for advanced features.
200
201      Deletes model2
202    */
203     int subBranchAndBound(CbcModel * model2,
204                           CbcModel * presolvedModel,
205                           int maximumNodes);
206    /** \brief Invoke the branch \& cut algorithm on partially fixed problem
207
208      The method creates a new model with given bounds, presolves it
209      then proceeds to explore the branch & cut search tree. The search
210      ends when the tree is exhausted or maximum nodes is reached.
211
212      If better solution found then it is saved.
213
214      Returns 0 if search completed and solution, 1 if not completed and solution,
215      2 if completed and no solution, 3 if not completed and no solution.
216
217      This is just subModel immediately followed by other version of
218      subBranchandBound.
219
220    */
221     int subBranchAndBound(const double * lower, const double * upper,
222                            int maximumNodes);
223
224    /** \brief Process root node and return a strengthened model
225
226      The method assumes that initialSolve() has been called to solve the
227      LP relaxation. It processes the root node and then returns a pointer
228      to the strengthened model (or NULL if infeasible)
229    */
230     OsiSolverInterface *  strengthenedModel();
231  /** preProcess problem - replacing solver
232      If makeEquality true then <= cliques converted to ==.
233      Presolve will be done numberPasses times.
234
235      Returns NULL if infeasible
236
237      If makeEquality is 1 add slacks to get cliques,
238      if 2 add slacks to get sos (but only if looks plausible) and keep sos info
239  */
240  CglPreProcess * preProcess( int makeEquality=0, int numberPasses=5,
241                  int tuning=5);
242  /** Does postprocessing - original solver back.
243      User has to delete process */
244  void postProcess(CglPreProcess * process);
245private:
246    /** \brief Evaluate a subproblem using cutting planes and heuristics
247
248      The method invokes a main loop which generates cuts, applies heuristics,
249      and reoptimises using the solver's native %resolve() method.
250      It returns true if the subproblem remains feasible at the end of the
251      evaluation.
252    */
253  bool solveWithCuts(OsiCuts & cuts, int numberTries,CbcNode * node);
254  /** Input one node output N nodes to put on tree and optional solution update
255      This should be able to operate in parallel so is given a solver and is const(ish)
256      However we will need to keep an array of solver_ and bases and more
257      status is 0 for normal, 1 if solution
258      Calling code should always push nodes back on tree
259  */
260  CbcNode ** solveOneNode(int whichSolver,CbcNode * node, 
261                          int & numberNodesOutput, int & status) ;
262  /// Update size of whichGenerator
263  void resizeWhichGenerator(int numberNow, int numberAfter);
264public:
265#ifndef CBC_THREAD
266#define NEW_UPDATE_OBJECT 0
267#else
268#define NEW_UPDATE_OBJECT 2
269#endif
270#if NEW_UPDATE_OBJECT>1
271  /// Adds an update information object
272  void addUpdateInformation(const CbcObjectUpdateData & data);
273#endif
274  /** Do one node - broken out for clarity?
275      also for parallel (when baseModel!=this)
276      Returns 1 if solution found
277      node NULL on return if no branches left
278      newNode NULL if no new node created
279  */
280  int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);
281
282  /// Returns true if locked
283  bool isLocked() const;
284  /// Main loop (without threads but when subtrees) 1 if finished, 0 if stopped
285#if 0
286  int whileIterating(bool & locked, threadId, threadInfo,condition_mutex,condition_main,
287                     timeWaiting,threadModel,threadStats,totalTime,cutoff,
288                     eventHandler,saveCompare,lastDepth,lastUnsatisfied,createdNode);
289#else
290  int whileIterating(int numberIterations);
291#endif
292#ifdef CBC_THREAD
293  /**
294     Locks a thread if parallel so that stuff like cut pool
295     can be updated and/or used.
296  */
297  void lockThread();
298  /**
299     Unlocks a thread if parallel to say cut pool stuff not needed
300  */
301  void unlockThread();
302#else
303  inline void lockThread() {}
304  inline void unlockThread() {}
305#endif
306private:
307  /** Move/copy information from one model to another
308      -1 - initialization
309      0 - from base model
310      1 - to base model (and reset)
311      2 - add in final statistics etc (and reset so can do clean destruction)
312  */
313  void moveToModel(CbcModel * baseModel,int mode);
314public:
315    /** \brief Reoptimise an LP relaxation
316   
317      Invoke the solver's %resolve() method.
318      whereFrom -
319      0 - initial continuous
320      1 - resolve on branch (before new cuts)
321      2 - after new cuts
322      3  - obsolete code or something modified problem in unexpected way
323      10 - after strong branching has fixed variables at root
324      11 - after strong branching has fixed variables in tree
325
326      returns 1 feasible, 0 infeasible, -1 feasible but skip cuts
327    */
328    int resolve(CbcNodeInfo * parent, int whereFrom);
329    /// Make given rows (L or G) into global cuts and remove from lp
330    void makeGlobalCuts(int numberRows,const int * which); 
331    /// Make given cut into a global cut
332    void makeGlobalCut(const OsiRowCut * cut); 
333    /// Make given cut into a global cut
334    void makeGlobalCut(const OsiRowCut & cut); 
335  //@}
336
337  /** \name Presolve methods */
338  //@{
339
340  /** Identify cliques and construct corresponding objects.
341
342      Find cliques with size in the range
343      [\p atLeastThisMany, \p lessThanThis] and construct corresponding
344      CbcClique objects.
345      If \p makeEquality is true then a new model may be returned if
346      modifications had to be made, otherwise \c this is returned.
347      If the problem is infeasible #numberObjects_ is set to -1.
348      A client must use deleteObjects() before a second call to findCliques().
349      If priorities exist, clique priority is set to the default.
350  */
351  CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
352                         int lessThanThis, int defaultValue=1000);
353
354  /** Do integer presolve, creating a new (presolved) model.
355
356    Returns the new model, or NULL if feasibility is lost.
357    If weak is true then just does a normal presolve
358 
359    \todo It remains to work out the cleanest way of getting a solution to
360          the original problem at the end. So this is very preliminary.
361   */
362  CbcModel * integerPresolve(bool weak=false);
363
364  /** Do integer presolve, modifying the current model.
365
366      Returns true if the model remains feasible after presolve.
367  */
368  bool integerPresolveThisModel(OsiSolverInterface * originalSolver,bool weak=false);
369
370
371  /// Put back information into the original model after integer presolve.
372  void originalModel(CbcModel * presolvedModel,bool weak);
373
374  /** \brief For variables involved in VUB constraints, see if we can tighten
375             bounds by solving lp's
376
377      Returns false if feasibility is lost.
378      If CglProbing is available, it will be tried as well to see if it can
379      tighten bounds.
380      This routine is just a front end for tightenVubs(int,const int*,double).
381
382      If <tt>type = -1</tt> all variables are processed (could be very slow).
383      If <tt>type = 0</tt> only variables involved in VUBs are processed.
384      If <tt>type = n > 0</tt>, only the n most expensive VUB variables
385      are processed, where it is assumed that x is at its maximum so delta
386      would have to go to 1 (if x not at bound).
387
388      If \p allowMultipleBinary is true, then a VUB constraint is a row with
389      one continuous variable and any number of binary variables.
390
391      If <tt>useCutoff < 1.0e30</tt>, the original objective is installed as a
392      constraint with \p useCutoff as a bound.
393  */
394  bool tightenVubs(int type,bool allowMultipleBinary=false,
395                   double useCutoff=1.0e50);
396 
397  /** \brief For variables involved in VUB constraints, see if we can tighten
398             bounds by solving lp's
399
400    This version is just handed a list of variables to be processed.
401  */
402  bool tightenVubs(int numberVubs, const int * which,
403                   double useCutoff=1.0e50);
404  /**
405    Analyze problem to find a minimum change in the objective function.
406  */
407  void analyzeObjective();
408  /// Tighten bounds - lightweight
409  int tightenBounds();
410
411
412  //@}
413
414  /** \name Object manipulation routines
415 
416    See OsiObject for an explanation of `object' in the context of CbcModel.
417  */
418  //@{
419
420  /// Get the number of objects
421  inline int numberObjects() const { return numberObjects_;}
422  /// Set the number of objects
423  inline void setNumberObjects(int number) 
424  {  numberObjects_=number;}
425
426  /// Get the array of objects
427  inline OsiObject ** objects() const { return object_;}
428
429  /// Get the specified object
430  const inline OsiObject * object(int which) const { return object_[which];}
431  /// Get the specified object
432  inline OsiObject * modifiableObject(int which) const { return object_[which];}
433
434  /// Delete all object information (and just back to integers if true)
435  void deleteObjects(bool findIntegers=true);
436
437  /** Add in object information.
438 
439    Objects are cloned; the owner can delete the originals.
440  */
441  void addObjects(int numberObjects, OsiObject ** objects);
442
443  /** Add in object information.
444 
445    Objects are cloned; the owner can delete the originals.
446  */
447  void addObjects(int numberObjects, CbcObject ** objects);
448
449  /// Ensure attached objects point to this model.
450  void synchronizeModel() ;
451
452  /** \brief Identify integer variables and create corresponding objects.
453 
454    Record integer variables and create an CbcSimpleInteger object for each
455    one.
456    If \p startAgain is true, a new scan is forced, overwriting any existing
457    integer variable information.
458    If type > 0 then 1==PseudoCost
459  */
460
461  void findIntegers(bool startAgain,int type=0);
462
463  //@}
464
465  //---------------------------------------------------------------------------
466
467  /**@name Parameter set/get methods
468
469     The set methods return true if the parameter was set to the given value,
470     false if the value of the parameter is out of range.
471
472     The get methods return the value of the parameter.
473
474  */
475  //@{
476  /// Set an integer parameter
477  inline bool setIntParam(CbcIntParam key, int value) {
478    intParam_[key] = value;
479    return true;
480  }
481  /// Set a double parameter
482  inline bool setDblParam(CbcDblParam key, double value) {
483    dblParam_[key] = value;
484    return true;
485  }
486  /// Get an integer parameter
487  inline int getIntParam(CbcIntParam key) const {
488    return intParam_[key];
489  }
490  /// Get a double parameter
491  inline double getDblParam(CbcDblParam key) const {
492    return dblParam_[key];
493  }
494  /*! \brief Set cutoff bound on the objective function.
495
496    When using strict comparison, the bound is adjusted by a tolerance to
497    avoid accidentally cutting off the optimal solution.
498  */
499  void setCutoff(double value) ;
500
501  /// Get the cutoff bound on the objective function - always as minimize
502  inline double getCutoff() const
503  { //double value ;
504    //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
505    //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
506    return dblParam_[CbcCurrentCutoff];
507  }
508
509  /// Set the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
510  inline bool setMaximumNodes( int value)
511  { return setIntParam(CbcMaxNumNode,value); }
512
513  /// Get the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
514  inline int getMaximumNodes() const
515  { return getIntParam(CbcMaxNumNode); }
516
517  /** Set the
518      \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink
519      desired.
520  */
521  inline bool setMaximumSolutions( int value) {
522    return setIntParam(CbcMaxNumSol,value);
523  }
524  /** Get the
525      \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink
526      desired.
527  */
528  inline int getMaximumSolutions() const {
529    return getIntParam(CbcMaxNumSol);
530  }
531  /// Set the printing mode
532  inline bool setPrintingMode( int value)
533  { return setIntParam(CbcPrinting,value); }
534
535  /// Get the printing mode
536  inline int getPrintingMode() const
537  { return getIntParam(CbcPrinting); }
538
539  /** Set the
540      \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink
541      desired.
542  */
543  inline bool setMaximumSeconds( double value) {
544    return setDblParam(CbcMaximumSeconds,value);
545  }
546  /** Get the
547      \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink
548      desired.
549  */
550  inline double getMaximumSeconds() const {
551    return getDblParam(CbcMaximumSeconds);
552  }
553  /// Current time since start of branchAndbound
554  double getCurrentSeconds() const ;
555
556  /** Set the
557    \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink
558  */
559  inline bool setIntegerTolerance( double value) {
560    return setDblParam(CbcIntegerTolerance,value);
561  }
562  /** Get the
563    \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink
564  */
565  inline double getIntegerTolerance() const {
566    return getDblParam(CbcIntegerTolerance);
567  }
568
569  /** Set the
570      \link CbcModel::CbcInfeasibilityWeight
571            weight per integer infeasibility \endlink
572  */
573  inline bool setInfeasibilityWeight( double value) {
574    return setDblParam(CbcInfeasibilityWeight,value);
575  }
576  /** Get the
577      \link CbcModel::CbcInfeasibilityWeight
578            weight per integer infeasibility \endlink
579  */
580  inline double getInfeasibilityWeight() const {
581    return getDblParam(CbcInfeasibilityWeight);
582  }
583
584  /** Set the \link CbcModel::CbcAllowableGap allowable gap \endlink
585      between the best known solution and the best possible solution.
586  */
587  inline bool setAllowableGap( double value) {
588    return setDblParam(CbcAllowableGap,value);
589  }
590  /** Get the \link CbcModel::CbcAllowableGap allowable gap \endlink
591      between the best known solution and the best possible solution.
592  */
593  inline double getAllowableGap() const {
594    return getDblParam(CbcAllowableGap);
595  }
596
597  /** Set the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
598      between the best known solution and the best possible solution.
599  */
600  inline bool setAllowableFractionGap( double value) {
601    return setDblParam(CbcAllowableFractionGap,value);
602  }
603  /** Get the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
604      between the best known solution and the best possible solution.
605  */
606  inline double getAllowableFractionGap() const {
607    return getDblParam(CbcAllowableFractionGap);
608  }
609  /** Set the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
610      between the best known solution and the best possible solution.
611  */
612  inline bool setAllowablePercentageGap( double value) {
613    return setDblParam(CbcAllowableFractionGap,value*0.01);
614  }
615  /** Get the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
616      between the best known solution and the best possible solution.
617  */
618  inline double getAllowablePercentageGap() const {
619    return 100.0*getDblParam(CbcAllowableFractionGap);
620  }
621  /** Set the
622      \link CbcModel::CbcCutoffIncrement  \endlink
623      desired.
624  */
625  inline bool setCutoffIncrement( double value) {
626    return setDblParam(CbcCutoffIncrement,value);
627  }
628  /** Get the
629      \link CbcModel::CbcCutoffIncrement  \endlink
630      desired.
631  */
632  inline double getCutoffIncrement() const {
633    return getDblParam(CbcCutoffIncrement);
634  }
635
636  /** Pass in target solution and optional priorities.
637      If priorities then >0 means only branch if incorrect
638      while <0 means branch even if correct. +1 or -1 are
639      highest priority */
640  void setHotstartSolution(const double * solution, const int * priorities=NULL) ;
641 
642  /// Set the minimum drop to continue cuts
643  inline void setMinimumDrop(double value)
644  {minimumDrop_=value;}
645  /// Get the minimum drop to continue cuts
646  inline double getMinimumDrop() const
647  { return minimumDrop_;}
648
649  /** Set the maximum number of cut passes at root node (default 20)
650      Minimum drop can also be used for fine tuning */
651  inline void setMaximumCutPassesAtRoot(int value)
652  {maximumCutPassesAtRoot_=value;}
653  /** Get the maximum number of cut passes at root node */
654  inline int getMaximumCutPassesAtRoot() const
655  { return maximumCutPassesAtRoot_;}
656
657  /** Set the maximum number of cut passes at other nodes (default 10)
658      Minimum drop can also be used for fine tuning */
659  inline void setMaximumCutPasses(int value)
660  {maximumCutPasses_=value;}
661  /** Get the maximum number of cut passes at other nodes (default 10) */
662  inline int getMaximumCutPasses() const
663  { return maximumCutPasses_;}
664  /** Get current cut pass number in this round of cuts.
665      (1 is first pass) */
666  inline int getCurrentPassNumber() const
667  { return currentPassNumber_;}
668
669  /** Set the maximum number of candidates to be evaluated for strong
670    branching.
671
672    A value of 0 disables strong branching.
673  */
674  void setNumberStrong(int number);
675  /** Get the maximum number of candidates to be evaluated for strong
676    branching.
677  */
678  inline int numberStrong() const
679  { return numberStrong_;}
680  /** Set global preferred way to branch
681      -1 down, +1 up, 0 no preference */
682  inline void setPreferredWay(int value)
683  {preferredWay_=value;}
684  /** Get the preferred way to branch (default 0) */
685  inline int getPreferredWay() const
686  { return preferredWay_;}
687  /** Set size of mini - tree.  If > 1 then does total enumeration of
688      tree given by this best variables to branch on
689  */
690  inline void setSizeMiniTree(int value)
691  { sizeMiniTree_=value;}
692  inline int sizeMiniTree() const
693  { return sizeMiniTree_;}
694
695  /** Set the number of branches before pseudo costs believed
696      in dynamic strong branching.
697
698    A value of 0 disables dynamic strong branching.
699  */
700  void setNumberBeforeTrust(int number);
701  /** get the number of branches before pseudo costs believed
702      in dynamic strong branching. */
703  inline int numberBeforeTrust() const
704  { return numberBeforeTrust_;}
705  /** Set the number of variables for which to compute penalties
706      in dynamic strong branching.
707
708    A value of 0 disables penalties.
709  */
710  void setNumberPenalties(int number);
711  /** get the number of variables for which to compute penalties
712      in dynamic strong branching. */
713  inline int numberPenalties() const
714  { return numberPenalties_;}
715  /// Number of analyze iterations to do
716  inline void setNumberAnalyzeIterations(int number)
717  { numberAnalyzeIterations_=number;}
718  inline int numberAnalyzeIterations() const
719  { return numberAnalyzeIterations_;}
720  /** Get scale factor to make penalties match strong.
721      Should/will be computed */
722  inline double penaltyScaleFactor() const
723  { return penaltyScaleFactor_;}
724  /** Set scale factor to make penalties match strong.
725      Should/will be computed */
726  void setPenaltyScaleFactor(double value);
727  /** Problem type as set by user or found by analysis.  This will be extended
728      0 - not known
729      1 - Set partitioning <=
730      2 - Set partitioning ==
731      3 - Set covering
732      4 - all +- 1 or all +1 and odd
733  */
734  void inline setProblemType(int number)
735  { problemType_=number;}
736  inline int problemType() const
737  { return problemType_;}
738
739  /// Set how often to scan global cuts
740  void setHowOftenGlobalScan(int number);
741  /// Get how often to scan global cuts
742  inline int howOftenGlobalScan() const
743  { return howOftenGlobalScan_;}
744  /// Original columns as created by integerPresolve or preprocessing
745  inline int * originalColumns() const
746  { return originalColumns_;}
747  /// Set original columns as created by preprocessing
748  void setOriginalColumns(const int * originalColumns) ;
749
750  /** Set the print frequency.
751 
752    Controls the number of nodes evaluated between status prints.
753    If <tt>number <=0</tt> the print frequency is set to 100 nodes for large
754    problems, 1000 for small problems.
755    Print frequency has very slight overhead if small.
756  */
757  inline void setPrintFrequency(int number)
758  { printFrequency_=number;}
759  /// Get the print frequency
760  inline int printFrequency() const
761  { return printFrequency_;}
762  //@}
763
764  //---------------------------------------------------------------------------
765  ///@name Methods returning info on how the solution process terminated
766  //@{
767    /// Are there a numerical difficulties?
768    bool isAbandoned() const;
769    /// Is optimality proven?
770    bool isProvenOptimal() const;
771    /// Is  infeasiblity proven (or none better than cutoff)?
772    bool isProvenInfeasible() const;
773    /// Was continuous solution unbounded
774    bool isContinuousUnbounded() const;
775    /// Was continuous solution unbounded
776    bool isProvenDualInfeasible() const;
777    /// Node limit reached?
778    bool isNodeLimitReached() const;
779    /// Time limit reached?
780    bool isSecondsLimitReached() const;
781    /// Solution limit reached?
782    bool isSolutionLimitReached() const;
783    /// Get how many iterations it took to solve the problem.
784    inline int getIterationCount() const
785    { return numberIterations_;}
786    /// Get how many Nodes it took to solve the problem.
787    inline int getNodeCount() const
788    { return numberNodes_;}
789    /** Final status of problem
790        Some of these can be found out by is...... functions
791        -1 before branchAndBound
792        0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found
793        (or check value of best solution)
794        1 stopped - on maxnodes, maxsols, maxtime
795        2 difficulties so run was abandoned
796        (5 event user programmed event occurred)
797    */
798    inline int status() const
799    { return status_;}
800    inline void setProblemStatus(int value)
801    { status_=value;}
802    /** Secondary status of problem
803        -1 unset (status_ will also be -1)
804        0 search completed with solution
805        1 linear relaxation not feasible (or worse than cutoff)
806        2 stopped on gap
807        3 stopped on nodes
808        4 stopped on time
809        5 stopped on user event
810        6 stopped on solutions
811        7 linear relaxation unbounded
812    */
813    inline int secondaryStatus() const
814    { return secondaryStatus_;}
815    inline void setSecondaryStatus(int value)
816    { secondaryStatus_=value;}
817    /// Are there numerical difficulties (for initialSolve) ?
818    bool isInitialSolveAbandoned() const ;
819    /// Is optimality proven (for initialSolve) ?
820    bool isInitialSolveProvenOptimal() const ;
821    /// Is primal infeasiblity proven (for initialSolve) ?
822    bool isInitialSolveProvenPrimalInfeasible() const ;
823    /// Is dual infeasiblity proven (for initialSolve) ?
824    bool isInitialSolveProvenDualInfeasible() const ;
825
826  //@}
827
828  //---------------------------------------------------------------------------
829  /**@name Problem information methods
830     
831     These methods call the solver's query routines to return
832     information about the problem referred to by the current object.
833     Querying a problem that has no data associated with it result in
834     zeros for the number of rows and columns, and NULL pointers from
835     the methods that return vectors.
836     
837     Const pointers returned from any data-query method are valid as
838     long as the data is unchanged and the solver is not called.
839  */
840  //@{
841  /// Number of rows in continuous (root) problem.
842  inline int numberRowsAtContinuous() const
843  { return numberRowsAtContinuous_;}
844
845  /// Get number of columns
846  inline int getNumCols() const
847  { return solver_->getNumCols();}
848 
849  /// Get number of rows
850  inline int getNumRows() const
851  { return solver_->getNumRows();}
852 
853  /// Get number of nonzero elements
854  inline CoinBigIndex getNumElements() const
855  { return solver_->getNumElements();}
856
857  /// Number of integers in problem
858  inline int numberIntegers() const
859  { return numberIntegers_;}
860  // Integer variables
861  inline const int * integerVariable() const 
862  { return integerVariable_;}
863  /// Whether or not integer
864  inline char integerType(int i) const
865  { return integerInfo_[i];}
866  /// Whether or not integer
867  inline const char * integerType() const
868  { return integerInfo_;}
869
870  /// Get pointer to array[getNumCols()] of column lower bounds
871  inline const double * getColLower() const
872  { return solver_->getColLower();}
873 
874  /// Get pointer to array[getNumCols()] of column upper bounds
875  inline const double * getColUpper() const
876  { return solver_->getColUpper();}
877 
878  /** Get pointer to array[getNumRows()] of row constraint senses.
879      <ul>
880      <li>'L': <= constraint
881      <li>'E': =  constraint
882      <li>'G': >= constraint
883      <li>'R': ranged constraint
884      <li>'N': free constraint
885      </ul>
886  */
887  inline const char * getRowSense() const
888  { return solver_->getRowSense();}
889 
890  /** Get pointer to array[getNumRows()] of rows right-hand sides
891      <ul>
892      <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
893      <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i]
894      <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i]
895      <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0
896      </ul>
897  */
898  inline const double * getRightHandSide() const
899  { return solver_->getRightHandSide();}
900 
901  /** Get pointer to array[getNumRows()] of row ranges.
902      <ul>
903      <li> if rowsense()[i] == 'R' then
904      rowrange()[i] == rowupper()[i] - rowlower()[i]
905      <li> if rowsense()[i] != 'R' then
906      rowrange()[i] is 0.0
907      </ul>
908  */
909  inline const double * getRowRange() const
910  { return solver_->getRowRange();}
911 
912  /// Get pointer to array[getNumRows()] of row lower bounds
913  inline const double * getRowLower() const
914  { return solver_->getRowLower();}
915 
916  /// Get pointer to array[getNumRows()] of row upper bounds
917  inline const double * getRowUpper() const
918  { return solver_->getRowUpper();}
919 
920  /// Get pointer to array[getNumCols()] of objective function coefficients
921  inline const double * getObjCoefficients() const
922  { return solver_->getObjCoefficients();}
923 
924  /// Get objective function sense (1 for min (default), -1 for max)
925  inline double getObjSense() const
926  {
927    //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
928    return dblParam_[CbcOptimizationDirection];}
929 
930  /// Return true if variable is continuous
931  inline bool isContinuous(int colIndex) const
932  { return solver_->isContinuous(colIndex);}
933 
934  /// Return true if variable is binary
935  inline bool isBinary(int colIndex) const
936  { return solver_->isBinary(colIndex);}
937 
938  /** Return true if column is integer.
939      Note: This function returns true if the the column
940      is binary or a general integer.
941  */
942  inline bool isInteger(int colIndex) const
943  { return solver_->isInteger(colIndex);}
944 
945  /// Return true if variable is general integer
946  inline bool isIntegerNonBinary(int colIndex) const
947  { return solver_->isIntegerNonBinary(colIndex);}
948 
949  /// Return true if variable is binary and not fixed at either bound
950  inline bool isFreeBinary(int colIndex) const
951  { return solver_->isFreeBinary(colIndex) ;}
952 
953  /// Get pointer to row-wise copy of matrix
954  inline const CoinPackedMatrix * getMatrixByRow() const
955  { return solver_->getMatrixByRow();}
956 
957  /// Get pointer to column-wise copy of matrix
958  inline const CoinPackedMatrix * getMatrixByCol() const
959  { return solver_->getMatrixByCol();}
960 
961  /// Get solver's value for infinity
962  inline double getInfinity() const
963  { return solver_->getInfinity();}
964  /// Get pointer to array[getNumCols()] (for speed) of column lower bounds
965  inline const double * getCbcColLower() const
966  { return cbcColLower_;}
967  /// Get pointer to array[getNumCols()] (for speed) of column upper bounds
968  inline const double * getCbcColUpper() const
969  { return cbcColUpper_;}
970  /// Get pointer to array[getNumRows()] (for speed) of row lower bounds
971  inline const double * getCbcRowLower() const
972  { return cbcRowLower_;}
973  /// Get pointer to array[getNumRows()] (for speed) of row upper bounds
974  inline const double * getCbcRowUpper() const
975  { return cbcRowUpper_;}
976  /// Get pointer to array[getNumCols()] (for speed) of primal solution vector
977  inline const double * getCbcColSolution() const
978  { return cbcColSolution_;}
979  /// Get pointer to array[getNumRows()] (for speed) of dual prices
980  inline const double * getCbcRowPrice() const
981  { return cbcRowPrice_;}
982  /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
983  inline const double * getCbcReducedCost() const
984  { return cbcReducedCost_;}
985  /// Get pointer to array[getNumRows()] (for speed) of row activity levels.
986  inline const double * getCbcRowActivity() const
987  { return cbcRowActivity_;}
988  //@}
989 
990 
991  /**@name Methods related to querying the solution */
992  //@{
993  /// Holds solution at continuous (after cuts if branchAndBound called)
994  inline double * continuousSolution() const
995  { return continuousSolution_;}
996  /** Array marked whenever a solution is found if non-zero.
997      Code marks if heuristic returns better so heuristic
998      need only mark if it wants to on solutions which
999      are worse than current */
1000  inline int * usedInSolution() const
1001  { return usedInSolution_;}
1002  /// Increases usedInSolution for nonzeros
1003  void incrementUsed(const double * solution);
1004  /// Record a new incumbent solution and update objectiveValue
1005  void setBestSolution(CBC_Message how,
1006                       double & objectiveValue, const double *solution,
1007                       bool fixVariables=false);
1008  /// Just update objectiveValue
1009  void setBestObjectiveValue( double objectiveValue);
1010
1011  /** Call this to really test if a valid solution can be feasible
1012      Solution is number columns in size.
1013      If fixVariables true then bounds of continuous solver updated.
1014      Returns objective value (worse than cutoff if not feasible)
1015      Previously computed objective value is now passed in (in case user does not do solve)
1016 */
1017  double checkSolution(double cutoff, double * solution,
1018                       bool fixVariables, double originalObjValue);
1019  /** Test the current solution for feasiblility.
1020
1021    Scan all objects for indications of infeasibility. This is broken down
1022    into simple integer infeasibility (\p numberIntegerInfeasibilities)
1023    and all other reports of infeasibility (\p numberObjectInfeasibilities).
1024  */
1025  bool feasibleSolution(int & numberIntegerInfeasibilities,
1026                        int & numberObjectInfeasibilities) const;
1027
1028  /** Solution to the most recent lp relaxation.
1029
1030    The solver's solution to the most recent lp relaxation.
1031  */
1032   
1033  inline double * currentSolution() const
1034  { return currentSolution_;}
1035  /** For testing infeasibilities - will point to
1036      currentSolution_ or solver-->getColSolution()
1037  */
1038  inline const double * testSolution() const
1039  { return testSolution_;}
1040  inline void setTestSolution(const double * solution)
1041  { testSolution_ = solution;}
1042  /// Make sure region there and optionally copy solution
1043  void reserveCurrentSolution(const double * solution=NULL);
1044
1045  /// Get pointer to array[getNumCols()] of primal solution vector
1046  inline const double * getColSolution() const
1047  { return solver_->getColSolution();}
1048 
1049  /// Get pointer to array[getNumRows()] of dual prices
1050  inline const double * getRowPrice() const
1051  { return solver_->getRowPrice();}
1052 
1053  /// Get a pointer to array[getNumCols()] of reduced costs
1054  inline const double * getReducedCost() const
1055  { return solver_->getReducedCost();}
1056 
1057  /// Get pointer to array[getNumRows()] of row activity levels.
1058  inline const double * getRowActivity() const
1059  { return solver_->getRowActivity();}
1060 
1061  /// Get current objective function value
1062  inline double getCurrentObjValue() const
1063  { return dblParam_[CbcCurrentObjectiveValue]; }
1064  /// Get current minimization objective function value
1065  inline double getCurrentMinimizationObjValue() const
1066  { return dblParam_[CbcCurrentMinimizationObjectiveValue];}
1067 
1068  /// Get best objective function value as minimization
1069  inline double getMinimizationObjValue() const
1070  { return bestObjective_;}
1071  /// Set best objective function value as minimization
1072  inline void setMinimizationObjValue(double value) 
1073  { bestObjective_=value;}
1074 
1075  /// Get best objective function value
1076  inline double getObjValue() const
1077  { return bestObjective_ * solver_->getObjSense() ; } 
1078  /** Get best possible objective function value.
1079      This is better of best possible left on tree
1080      and best solution found.
1081      If called from within branch and cut may be optimistic.
1082  */
1083  double getBestPossibleObjValue() const;
1084  /// Set best objective function value
1085  inline void setObjValue(double value) 
1086  { bestObjective_=value * solver_->getObjSense() ;}
1087 
1088  /** The best solution to the integer programming problem.
1089
1090    The best solution to the integer programming problem found during
1091    the search. If no solution is found, the method returns null.
1092  */
1093
1094  inline double * bestSolution() const
1095  { return bestSolution_;}
1096  void setBestSolution(const double * solution,int numberColumns,double objectiveValue);
1097 
1098  /// Get number of solutions
1099  inline int getSolutionCount() const
1100  { return numberSolutions_;}
1101 
1102  /// Set number of solutions (so heuristics will be different)
1103  inline void setSolutionCount(int value) 
1104  { numberSolutions_=value;}
1105  /** Current phase (so heuristics etc etc can find out).
1106      0 - initial solve
1107      1 - solve with cuts at root
1108      2 - solve with cuts
1109      3 - other e.g. strong branching
1110      4 - trying to validate a solution
1111      5 - at end of search
1112  */
1113  inline int phase() const
1114  { return phase_;}
1115 
1116  /// Get number of heuristic solutions
1117  inline int getNumberHeuristicSolutions() const { return numberHeuristicSolutions_;}
1118  /// Set number of heuristic solutions
1119  inline void setNumberHeuristicSolutions(int value) { numberHeuristicSolutions_=value;}
1120
1121  /// Set objective function sense (1 for min (default), -1 for max,)
1122  inline void setObjSense(double s) { dblParam_[CbcOptimizationDirection]=s;
1123  solver_->setObjSense(s);}
1124
1125  /// Value of objective at continuous
1126  inline double getContinuousObjective() const
1127  { return originalContinuousObjective_;}
1128  inline void setContinuousObjective(double value)
1129  { originalContinuousObjective_=value;}
1130  /// Number of infeasibilities at continuous
1131  inline int getContinuousInfeasibilities() const
1132  { return continuousInfeasibilities_;}
1133  inline void setContinuousInfeasibilities(int value)
1134  { continuousInfeasibilities_=value;}
1135  /// Value of objective after root node cuts added
1136  inline double rootObjectiveAfterCuts() const
1137  { return continuousObjective_;}
1138  /// Sum of Changes to objective by first solve
1139  inline double sumChangeObjective() const
1140  { return sumChangeObjective1_;}
1141  /** Number of times global cuts violated.  When global cut pool then this
1142      should be kept for each cut and type of cut */
1143  inline int numberGlobalViolations() const
1144  { return numberGlobalViolations_;}
1145  inline void clearNumberGlobalViolations()
1146  { numberGlobalViolations_=0;}
1147  /// Whether to force a resolve after takeOffCuts
1148  inline bool resolveAfterTakeOffCuts() const
1149  { return resolveAfterTakeOffCuts_;}
1150  inline void setResolveAfterTakeOffCuts(bool yesNo)
1151  { resolveAfterTakeOffCuts_=yesNo;}
1152  /// Maximum number of rows
1153  inline int maximumRows() const
1154  { return maximumRows_;}
1155  /// Work basis for temporary use
1156  inline CoinWarmStartBasis & workingBasis()
1157  { return workingBasis_;}
1158  /// Get number of threads
1159  inline int getNumberThreads() const
1160  { return numberThreads_;}
1161  /// Set number of threads
1162  inline void setNumberThreads(int value) 
1163  { numberThreads_=value;}
1164  /// Get thread mode
1165  inline int getThreadMode() const
1166  { return threadMode_;}
1167  /** Set thread mode
1168      always use numberThreads for branching
1169      1 set then use numberThreads in root mini branch and bound
1170      2 set then use numberThreads for root cuts
1171      default is 0
1172  */
1173  inline void setThreadMode(int value) 
1174  { threadMode_=value;}
1175  /// Get number of "iterations" to stop after
1176  inline int getStopNumberIterations() const
1177  { return stopNumberIterations_;}
1178  /// Set number of "iterations" to stop after
1179  inline void setStopNumberIterations(int value) 
1180  { stopNumberIterations_=value;}
1181  //@}
1182
1183  /** \name Node selection */
1184  //@{
1185  // Comparison functions (which may be overridden by inheritance)
1186  inline CbcCompareBase * nodeComparison() const
1187  { return nodeCompare_;}
1188  void setNodeComparison(CbcCompareBase * compare);
1189  void setNodeComparison(CbcCompareBase & compare);
1190  //@}
1191
1192  /** \name Problem feasibility checking */
1193  //@{
1194  // Feasibility functions (which may be overridden by inheritance)
1195  inline CbcFeasibilityBase * problemFeasibility() const
1196  { return problemFeasibility_;}
1197  void setProblemFeasibility(CbcFeasibilityBase * feasibility);
1198  void setProblemFeasibility(CbcFeasibilityBase & feasibility);
1199  //@}
1200
1201  /** \name Tree methods and subtree methods */
1202  //@{
1203  /// Tree method e.g. heap (which may be overridden by inheritance)
1204  inline CbcTree * tree() const
1205  { return tree_;}
1206  /// For modifying tree handling (original is cloned)
1207  void passInTreeHandler(CbcTree & tree);
1208  /** For passing in an CbcModel to do a sub Tree (with derived tree handlers).
1209      Passed in model must exist for duration of branch and bound
1210  */
1211  void passInSubTreeModel(CbcModel & model);
1212  /** For retrieving a copy of subtree model with given OsiSolver.
1213      If no subtree model will use self (up to user to reset cutoff etc).
1214      If solver NULL uses current
1215  */
1216  CbcModel * subTreeModel(OsiSolverInterface * solver=NULL) const;
1217  /// Returns number of times any subtree stopped on nodes, time etc
1218  inline int numberStoppedSubTrees() const
1219  { return numberStoppedSubTrees_;}
1220  /// Says a sub tree was stopped
1221  inline void incrementSubTreeStopped()
1222  { numberStoppedSubTrees_++;}
1223  /** Whether to automatically do presolve before branch and bound (subTrees).
1224      0 - no
1225      1 - ordinary presolve
1226      2 - integer presolve (dodgy)
1227  */
1228  inline int typePresolve() const
1229  { return presolve_;}
1230  inline void setTypePresolve(int value)
1231  { presolve_=value;}
1232 
1233  //@}
1234
1235  /** \name Branching Decisions
1236 
1237    See the CbcBranchDecision class for additional information.
1238  */
1239  //@{
1240
1241  /// Get the current branching decision method.
1242  inline CbcBranchDecision * branchingMethod() const
1243  { return branchingMethod_;}
1244  /// Set the branching decision method.
1245  inline void setBranchingMethod(CbcBranchDecision * method)
1246  { delete branchingMethod_; branchingMethod_ = method->clone();}
1247  /** Set the branching method
1248 
1249    \overload
1250  */
1251  inline void setBranchingMethod(CbcBranchDecision & method)
1252  { delete branchingMethod_; branchingMethod_ = method.clone();}
1253  /// Get the current cut modifier method
1254  inline CbcCutModifier * cutModifier() const
1255  { return cutModifier_;}
1256  /// Set the cut modifier method
1257  void setCutModifier(CbcCutModifier * modifier);
1258  /** Set the cut modifier method
1259 
1260    \overload
1261  */
1262  void setCutModifier(CbcCutModifier & modifier);
1263  //@}
1264
1265  /** \name Row (constraint) and Column (variable) cut generation */
1266  //@{
1267
1268  /** State of search
1269      0 - no solution
1270      1 - only heuristic solutions
1271      2 - branched to a solution
1272      3 - no solution but many nodes
1273  */
1274  inline int stateOfSearch() const
1275  { return stateOfSearch_;}
1276  inline void setStateOfSearch(int state)
1277  { stateOfSearch_=state;}
1278  /// Strategy worked out - mainly at root node for use by CbcNode
1279  inline int searchStrategy() const
1280  { return searchStrategy_;}
1281  /// Set strategy worked out - mainly at root node for use by CbcNode
1282  inline void setSearchStrategy(int value)
1283  { searchStrategy_ = value; }
1284
1285  /// Get the number of cut generators
1286  inline int numberCutGenerators() const
1287  { return numberCutGenerators_;}
1288  /// Get the list of cut generators
1289  inline CbcCutGenerator ** cutGenerators() const
1290  { return generator_;}
1291  ///Get the specified cut generator
1292  inline CbcCutGenerator * cutGenerator(int i) const
1293  { return generator_[i];}
1294  ///Get the specified cut generator before any changes
1295  inline CbcCutGenerator * virginCutGenerator(int i) const
1296  { return virginGenerator_[i];}
1297  /** Add one generator - up to user to delete generators.
1298      howoften affects how generator is used. 0 or 1 means always,
1299      >1 means every that number of nodes.  Negative values have same
1300      meaning as positive but they may be switched off (-> -100) by code if
1301      not many cuts generated at continuous.  -99 is just done at root.
1302      Name is just for printout.
1303      If depth >0 overrides how often generator is called (if howOften==-1 or >0).
1304  */
1305  void addCutGenerator(CglCutGenerator * generator,
1306                       int howOften=1, const char * name=NULL,
1307                       bool normal=true, bool atSolution=false, 
1308                       bool infeasible=false,int howOftenInSub=-100,
1309                       int whatDepth=-1, int whatDepthInSub=-1);
1310//@}
1311  /** \name Strategy and sub models
1312 
1313    See the CbcStrategy class for additional information.
1314  */
1315  //@{
1316
1317  /// Get the current strategy
1318  inline CbcStrategy * strategy() const
1319  { return strategy_;}
1320  /// Set the strategy. Clones
1321  void setStrategy(CbcStrategy & strategy);
1322  /// Get the current parent model
1323  inline CbcModel * parentModel() const
1324  { return parentModel_;}
1325  /// Set the parent model
1326  inline void setParentModel(CbcModel & parentModel)
1327  { parentModel_ = &parentModel;}
1328  //@}
1329
1330
1331  /** \name Heuristics and priorities */
1332  //@{
1333  /*! \brief Add one heuristic - up to user to delete
1334
1335    The name is just used for print messages.
1336  */
1337  void addHeuristic(CbcHeuristic * generator, const char *name = NULL);
1338  ///Get the specified heuristic
1339  inline CbcHeuristic * heuristic(int i) const
1340  { return heuristic_[i];}
1341  /// Get the number of heuristics
1342  inline int numberHeuristics() const
1343  { return numberHeuristics_;}
1344  /// Pointer to heuristic solver which found last solution (or NULL)
1345  inline CbcHeuristic * lastHeuristic() const
1346  { return lastHeuristic_;}
1347  /// set last heuristic which found a solution
1348  inline void setLastHeuristic(CbcHeuristic * last)
1349  { lastHeuristic_=last;}
1350
1351  /** Pass in branching priorities.
1352 
1353      If ifClique then priorities are on cliques otherwise priorities are
1354      on integer variables. 
1355      Other type (if exists set to default)
1356      1 is highest priority. (well actually -INT_MAX is but that's ugly)
1357      If hotstart > 0 then branches are created to force
1358      the variable to the value given by best solution.  This enables a
1359      sort of hot start.  The node choice should be greatest depth
1360      and hotstart should normally be switched off after a solution.
1361
1362      If ifNotSimpleIntegers true then appended to normal integers
1363
1364      This is now deprecated except for simple usage.  If user
1365      creates Cbcobjects then set priority in them
1366
1367      \internal Added for Kurt Spielberg.
1368  */
1369  void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);
1370
1371  /// Returns priority level for an object (or 1000 if no priorities exist)
1372  inline int priority(int sequence) const
1373  { return object_[sequence]->priority();}
1374
1375  /*! \brief Set an event handler
1376 
1377    A clone of the handler passed as a parameter is stored in CbcModel.
1378  */
1379  void passInEventHandler(const CbcEventHandler *eventHandler) ;
1380
1381  /*! \brief Retrieve a pointer to the event handler */
1382  inline CbcEventHandler* getEventHandler() const
1383  { return (eventHandler_) ; } 
1384
1385  //@}
1386   
1387  /**@name Setting/Accessing application data */
1388  //@{
1389    /** Set application data.
1390
1391        This is a pointer that the application can store into and
1392        retrieve from the solver interface.
1393        This field is available for the application to optionally
1394        define and use.
1395    */
1396    void setApplicationData (void * appData);
1397
1398    /// Get application data
1399    void * getApplicationData() const;
1400  /**
1401      For advanced applications you may wish to modify the behavior of Cbc
1402      e.g. if the solver is a NLP solver then you may not have an exact
1403      optimum solution at each step.  Information could be built into
1404      OsiSolverInterface but this is an alternative so that that interface
1405      does not have to be changed.  If something similar is useful to
1406      enough solvers then it could be migrated
1407      You can also pass in by using solver->setAuxiliaryInfo.
1408      You should do that if solver is odd - if solver is normal simplex
1409      then use this.
1410      NOTE - characteristics are not cloned
1411  */
1412  void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
1413  /// Get solver characteristics
1414  inline const OsiBabSolver * solverCharacteristics() const
1415  { return solverCharacteristics_;}
1416  //@}
1417 
1418  //---------------------------------------------------------------------------
1419
1420  /**@name Message handling */
1421  //@{
1422  /// Pass in Message handler (not deleted at end)
1423  void passInMessageHandler(CoinMessageHandler * handler);
1424  /// Set language
1425  void newLanguage(CoinMessages::Language language);
1426  inline void setLanguage(CoinMessages::Language language)
1427  {newLanguage(language);}
1428  /// Return handler
1429  inline CoinMessageHandler * messageHandler() const
1430  {return handler_;}
1431  /// Return messages
1432  inline CoinMessages & messages() 
1433  {return messages_;}
1434  /// Return pointer to messages
1435  inline CoinMessages * messagesPointer() 
1436  {return &messages_;}
1437  /// Set log level
1438  void setLogLevel(int value);
1439  /// Get log level
1440  inline int logLevel() const
1441  { return handler_->logLevel();}
1442  //@}
1443  //---------------------------------------------------------------------------
1444  ///@name Specialized
1445  //@{
1446
1447  /**
1448      Set special options
1449      0 bit (1) - check if cuts valid (if on debugger list)
1450      1 bit (2) - use current basis to check integer solution (rather than all slack)
1451      2 bit (4) - don't check integer solution (by solving LP)
1452      3 bit (8) - fast analyze
1453      4 bit (16) - non-linear model - so no well defined CoinPackedMatrix
1454      5 bit (32) - keep names
1455      6 bit (64) - try for dominated columns
1456  */
1457  /// Set special options
1458  inline void setSpecialOptions(int value)
1459  { specialOptions_=value;}
1460  /// Get special options
1461  inline int specialOptions() const
1462  { return specialOptions_;}
1463  /// Says if normal solver i.e. has well defined CoinPackedMatrix
1464  inline bool normalSolver() const
1465  { return (specialOptions_&16)==0;}
1466  /// Now we may not own objects - just point to solver's objects
1467  inline bool ownObjects() const
1468  { return ownObjects_;}
1469  /// Pointer to a mutex
1470  inline void * mutex()
1471  { return mutex_;}
1472  /// Split up nodes
1473  int splitModel(int numberModels, CbcModel ** model,
1474                  int numberNodes);
1475  /// Start threads
1476  void startSplitModel(int numberIterations);
1477  /// Merge models
1478  void mergeModels(int numberModel, CbcModel ** model,
1479                   int numberNodes);
1480  //@}
1481  //---------------------------------------------------------------------------
1482
1483  ///@name Constructors and destructors etc
1484  //@{
1485    /// Default Constructor
1486    CbcModel(); 
1487   
1488    /// Constructor from solver
1489    CbcModel(const OsiSolverInterface &);
1490 
1491    /** Assign a solver to the model (model assumes ownership)
1492
1493      On return, \p solver will be NULL.
1494      If deleteSolver then current solver deleted (if model owned)
1495
1496      \note Parameter settings in the outgoing solver are not inherited by
1497            the incoming solver.
1498    */
1499    void assignSolver(OsiSolverInterface *&solver,bool deleteSolver=true);
1500
1501    /** \brief Set ownership of solver
1502
1503      A parameter of false tells CbcModel it does not own the solver and
1504      should not delete it. Once you claim ownership of the solver, you're
1505      responsible for eventually deleting it. Note that CbcModel clones
1506      solvers with abandon.  Unless you have a deep understanding of the
1507      workings of CbcModel, the only time you want to claim ownership is when
1508      you're about to delete the CbcModel object but want the solver to
1509      continue to exist (as, for example, when branchAndBound has finished
1510      and you want to hang on to the answer).
1511    */
1512    inline void setModelOwnsSolver (bool ourSolver)
1513  { ownership_ = ourSolver ? (ownership_ |0x80000000) : (ownership_ & (~0x80000000)) ; } 
1514
1515    /*! \brief Get ownership of solver
1516   
1517      A return value of true means that CbcModel owns the solver and will
1518      take responsibility for deleting it when that becomes necessary.
1519    */
1520  inline bool modelOwnsSolver () { return ((ownership_&0x80000000)!=0) ; } 
1521 
1522    /** Copy constructor .
1523      If noTree is true then tree and cuts are not copied
1524    */ 
1525    CbcModel(const CbcModel & rhs, bool noTree=false);
1526 
1527    /// Assignment operator
1528    CbcModel & operator=(const CbcModel& rhs);
1529 
1530    /// Destructor
1531     ~CbcModel ();
1532
1533    /// Returns solver - has current state
1534    inline OsiSolverInterface * solver() const
1535    { return solver_;}
1536
1537    /// Returns current solver - sets new one
1538    inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) 
1539    { OsiSolverInterface * returnSolver = solver_; solver_ = solver; return returnSolver;}
1540
1541    /// Returns solver with continuous state
1542    inline OsiSolverInterface * continuousSolver() const
1543    { return continuousSolver_;}
1544
1545    /// Create solver with continuous state
1546    inline void createContinuousSolver()
1547    { continuousSolver_ = solver_->clone();}
1548    /// Clear solver with continuous state
1549    inline void clearContinuousSolver()
1550    { delete continuousSolver_; continuousSolver_ = NULL;}
1551
1552  /// A copy of the solver, taken at constructor or by saveReferenceSolver
1553  inline OsiSolverInterface * referenceSolver() const
1554  { return referenceSolver_;}
1555
1556  /// Save a copy of the current solver so can be reset to
1557  void saveReferenceSolver();
1558
1559  /** Uses a copy of reference solver to be current solver.
1560      Because of possible mismatches all exotic integer information is loat
1561      (apart from normal information in OsiSolverInterface)
1562      so SOS etc and priorities will have to be redone
1563  */
1564  void resetToReferenceSolver();
1565
1566  /// Clears out as much as possible (except solver)
1567  void gutsOfDestructor();
1568  /** Clears out enough to reset CbcModel as if no branch and bound done
1569   */
1570  void gutsOfDestructor2();
1571  /** Clears out enough to reset CbcModel cutoff etc
1572   */
1573  void resetModel();
1574  /// Move status, nodes etc etc across
1575  void moveInfo(const CbcModel & rhs);
1576  //@}
1577
1578  ///@semi-private i.e. users should not use
1579  //@{
1580    /// Get how many Nodes it took to solve the problem.
1581    int getNodeCount2() const
1582    { return numberNodes2_;}
1583  /// Set pointers for speed
1584  void setPointers(const OsiSolverInterface * solver);
1585  /** Perform reduced cost fixing
1586
1587    Fixes integer variables at their current value based on reduced cost
1588    penalties.  Returns number fixed
1589  */
1590  int reducedCostFix() ;
1591  /// Encapsulates solver resolve
1592  int resolve(OsiSolverInterface * solver);
1593
1594  /** Encapsulates choosing a variable -
1595      anyAction -2, infeasible (-1 round again), 0 done
1596  */
1597  int chooseBranch(CbcNode * newNode, int numberPassesLeft,
1598                   CbcNode * oldNode, OsiCuts & cuts,
1599                   bool & resolved, CoinWarmStartBasis *lastws,
1600                   const double * lowerBefore,const double * upperBefore,
1601                   OsiSolverBranch * & branches);
1602  int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);
1603
1604  /** Return an empty basis object of the specified size
1605
1606    A useful utility when constructing a basis for a subproblem from scratch.
1607    The object returned will be of the requested capacity and appropriate for
1608    the solver attached to the model.
1609  */
1610  CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;
1611
1612  /** Remove inactive cuts from the model
1613
1614    An OsiSolverInterface is expected to maintain a valid basis, but not a
1615    valid solution, when loose cuts are deleted. Restoring a valid solution
1616    requires calling the solver to reoptimise. If it's certain the solution
1617    will not be required, set allowResolve to false to suppress
1618    reoptimisation.
1619    If saveCuts then slack cuts will be saved
1620  */
1621  void takeOffCuts(OsiCuts &cuts, 
1622                     bool allowResolve,OsiCuts * saveCuts) ;
1623
1624  /** Determine and install the active cuts that need to be added for
1625    the current subproblem
1626
1627    The whole truth is a bit more complicated. The first action is a call to
1628    addCuts1(). addCuts() then sorts through the list, installs the tight
1629    cuts in the model, and does bookkeeping (adjusts reference counts).
1630    The basis returned from addCuts1() is adjusted accordingly.
1631   
1632    If it turns out that the node should really be fathomed by bound,
1633    addCuts() simply treats all the cuts as loose as it does the bookkeeping.
1634
1635    canFix true if extra information being passed
1636  */
1637  int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws,bool canFix);
1638
1639  /** Traverse the tree from node to root and prep the model
1640
1641    addCuts1() begins the job of prepping the model to match the current
1642    subproblem. The model is stripped of all cuts, and the search tree is
1643    traversed from node to root to determine the changes required. Appropriate
1644    bounds changes are installed, a list of cuts is collected but not
1645    installed, and an appropriate basis (minus the cuts, but big enough to
1646    accommodate them) is constructed.
1647
1648    \todo addCuts1() is called in contexts where it's known in advance that
1649          all that's desired is to determine a list of cuts and do the
1650          bookkeeping (adjust the reference counts). The work of installing
1651          bounds and building a basis goes to waste.
1652  */
1653  void addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
1654  /** Returns bounds just before where - initially original bounds.
1655      Also sets downstream nodes (lower if force 1, upper if 2)
1656  */
1657  void previousBounds (CbcNode * node, CbcNodeInfo * where,int iColumn,
1658                       double & lower, double & upper,int force);
1659  /** Set objective value in a node.  This is separated out so that
1660     odd solvers can use.  It may look at extra information in
1661     solverCharacteriscs_ and will also use bound from parent node
1662  */
1663  void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;
1664
1665  /** If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
1666      Scan and convert CbcSimpleInteger objects
1667  */
1668  void convertToDynamic();
1669  /// Zap integer information in problem (may leave object info)
1670  void zapIntegerInformation(bool leaveObjects=true);
1671  /// Use cliques for pseudocost information - return nonzero if infeasible
1672  int cliquePseudoCosts(int doStatistics);
1673  /// Fill in useful estimates
1674  void pseudoShadow(double * down, double * up);
1675  /** Do heuristics at root.
1676      0 - don't delete
1677      1 - delete
1678      2 - just delete - don't even use
1679  */
1680  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0);
1681  /// Get the hotstart solution
1682  inline const double * hotstartSolution() const
1683  { return hotstartSolution_;}
1684  /// Get the hotstart priorities
1685  inline const int * hotstartPriorities() const
1686  { return hotstartPriorities_;}
1687
1688  /// Return the list of cuts initially collected for this subproblem
1689  inline CbcCountRowCut ** addedCuts() const
1690  { return addedCuts_;}
1691  /// Number of entries in the list returned by #addedCuts()
1692  inline int currentNumberCuts() const
1693  { return currentNumberCuts_;}
1694  /// Global cuts
1695  inline OsiCuts * globalCuts() 
1696  { return &globalCuts_;}
1697  /// Copy and set a pointer to a row cut which will be added instead of normal branching.
1698  void setNextRowCut(const OsiRowCut & cut);
1699  /// Get a pointer to current node (be careful)
1700  inline CbcNode * currentNode() const
1701  { return currentNode_;}
1702  /// Get a pointer to probing info
1703  inline CglTreeProbingInfo * probingInfo() const
1704  { return probingInfo_;}
1705  /// Set the number of iterations done in strong branching.
1706  inline void setNumberStrongIterations(int number)
1707  { numberStrongIterations_ = number;}
1708  /// Get the number of iterations done in strong branching.
1709  inline int numberStrongIterations() const
1710  { return numberStrongIterations_;}
1711  /// Increment strong info
1712  void incrementStrongInfo(int numberTimes, int numberIterations,
1713                           int numberFixed, bool ifInfeasible);
1714  /// Says whether all dynamic integers
1715  inline bool allDynamic () { return ((ownership_&0x40000000)!=0) ; } 
1716  /// Create C++ lines to get to current state
1717  void generateCpp( FILE * fp,int options);
1718  /// Generate an OsiBranchingInformation object
1719  OsiBranchingInformation usefulInformation() const;
1720  /** Warm start object produced by heuristic or strong branching
1721
1722      If get a valid integer solution outside branch and bound then it can take
1723      a reasonable time to solve LP which produces clean solution.  If this object has
1724      any size then it will be used in solve.
1725  */
1726  inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis)
1727  { bestSolutionBasis_ = bestSolutionBasis;}
1728  //@}
1729
1730//---------------------------------------------------------------------------
1731
1732private:
1733  ///@name Private member data
1734  //@{
1735
1736  /// The solver associated with this model.
1737  OsiSolverInterface * solver_;
1738
1739  /** Ownership of objects and other stuff
1740
1741      0x80000000 model owns solver
1742      0x40000000 all variables CbcDynamicPseudoCost
1743  */
1744  unsigned int ownership_ ;
1745
1746  /// A copy of the solver, taken at the continuous (root) node.
1747  OsiSolverInterface * continuousSolver_;
1748
1749  /// A copy of the solver, taken at constructor or by saveReferenceSolver
1750  OsiSolverInterface * referenceSolver_;
1751
1752   /// Message handler
1753  CoinMessageHandler * handler_;
1754
1755  /** Flag to say if handler_ is the default handler.
1756 
1757    The default handler is deleted when the model is deleted. Other
1758    handlers (supplied by the client) will not be deleted.
1759  */
1760  bool defaultHandler_;
1761
1762  /// Cbc messages
1763  CoinMessages messages_;
1764
1765  /// Array for integer parameters
1766  int intParam_[CbcLastIntParam];
1767
1768  /// Array for double parameters
1769  double dblParam_[CbcLastDblParam];
1770
1771  /** Pointer to an empty warm start object
1772
1773    It turns out to be useful to have this available as a base from
1774    which to build custom warm start objects. This is typed as CoinWarmStart
1775    rather than CoinWarmStartBasis to allow for the possibility that a
1776    client might want to apply a solver that doesn't use a basis-based warm
1777    start. See getEmptyBasis for an example of how this field can be used.
1778  */
1779  mutable CoinWarmStart *emptyWarmStart_ ;
1780
1781  /// Best objective
1782  double bestObjective_;
1783  /// Best possible objective
1784  double bestPossibleObjective_;
1785  /// Sum of Changes to objective by first solve
1786  double sumChangeObjective1_;
1787  /// Sum of Changes to objective by subsequent solves
1788  double sumChangeObjective2_;
1789
1790  /// Array holding the incumbent (best) solution.
1791  double * bestSolution_;
1792
1793  /** Array holding the current solution.
1794
1795    This array is used more as a temporary.
1796  */
1797  double * currentSolution_;
1798  /** For testing infeasibilities - will point to
1799      currentSolution_ or solver-->getColSolution()
1800  */
1801  mutable const double * testSolution_;
1802  /** Warm start object produced by heuristic or strong branching
1803
1804      If get a valid integer solution outside branch and bound then it can take
1805      a reasonable time to solve LP which produces clean solution.  If this object has
1806      any size then it will be used in solve.
1807  */
1808  CoinWarmStartBasis bestSolutionBasis_ ;
1809  /// Global cuts
1810  OsiCuts globalCuts_;
1811
1812  /// Minimum degradation in objective value to continue cut generation
1813  double minimumDrop_;
1814  /// Number of solutions
1815  int numberSolutions_;
1816  /** State of search
1817      0 - no solution
1818      1 - only heuristic solutions
1819      2 - branched to a solution
1820      3 - no solution but many nodes
1821  */
1822  int stateOfSearch_;
1823  /// Hotstart solution
1824  double * hotstartSolution_;
1825  /// Hotstart priorities
1826  int * hotstartPriorities_;
1827  /// Number of heuristic solutions
1828  int numberHeuristicSolutions_;
1829  /// Cumulative number of nodes
1830  int numberNodes_;
1831  /** Cumulative number of nodes for statistics.
1832      Must fix to match up
1833  */
1834  int numberNodes2_;
1835  /// Cumulative number of iterations
1836  int numberIterations_;
1837  /// Status of problem - 0 finished, 1 stopped, 2 difficulties
1838  int status_;
1839  /** Secondary status of problem
1840      -1 unset (status_ will also be -1)
1841      0 search completed with solution
1842      1 linear relaxation not feasible (or worse than cutoff)
1843      2 stopped on gap
1844      3 stopped on nodes
1845      4 stopped on time
1846      5 stopped on user event
1847      6 stopped on solutions
1848   */
1849  int secondaryStatus_;
1850  /// Number of integers in problem
1851  int numberIntegers_;
1852  /// Number of rows at continuous
1853  int numberRowsAtContinuous_;
1854  /// Maximum number of cuts
1855  int maximumNumberCuts_;
1856  /** Current phase (so heuristics etc etc can find out).
1857      0 - initial solve
1858      1 - solve with cuts at root
1859      2 - solve with cuts
1860      3 - other e.g. strong branching
1861      4 - trying to validate a solution
1862      5 - at end of search
1863  */
1864  int phase_;
1865
1866  /// Number of entries in #addedCuts_
1867  int currentNumberCuts_;
1868
1869  /** Current limit on search tree depth
1870
1871    The allocated size of #walkback_. Increased as needed.
1872  */
1873  int maximumDepth_;
1874  /** Array used to assemble the path between a node and the search tree root
1875
1876    The array is resized when necessary. #maximumDepth_  is the current
1877    allocated size.
1878  */
1879  CbcNodeInfo ** walkback_;
1880
1881  /** The list of cuts initially collected for this subproblem
1882
1883    When the subproblem at this node is rebuilt, a set of cuts is collected
1884    for inclusion in the constraint system. If any of these cuts are
1885    subsequently removed because they have become loose, the corresponding
1886    entry is set to NULL.
1887  */
1888  CbcCountRowCut ** addedCuts_;
1889
1890  /** A pointer to a row cut which will be added instead of normal branching.
1891      After use it should be set to NULL.
1892  */
1893  OsiRowCut * nextRowCut_;
1894
1895  /// Current node so can be used elsewhere
1896  CbcNode * currentNode_;
1897
1898  /// Indices of integer variables
1899  int * integerVariable_;
1900  /// Whether of not integer
1901  char * integerInfo_;
1902  /// Holds solution at continuous (after cuts)
1903  double * continuousSolution_;
1904  /// Array marked whenever a solution is found if non-zero
1905  int * usedInSolution_;
1906  /**
1907      0 bit (1) - check if cuts valid (if on debugger list)
1908      1 bit (2) - use current basis to check integer solution (rather than all slack)
1909      2 bit (4) - don't check integer solution
1910      3 bit (8) - Strong is doing well - keep on
1911  */
1912  int specialOptions_;
1913  /// User node comparison function
1914  CbcCompareBase * nodeCompare_;
1915  /// User feasibility function (see CbcFeasibleBase.hpp)
1916  CbcFeasibilityBase * problemFeasibility_;
1917  /// Tree
1918  CbcTree * tree_;
1919  /// A pointer to model to be used for subtrees
1920  CbcModel * subTreeModel_;
1921  /// Number of times any subtree stopped on nodes, time etc
1922  int numberStoppedSubTrees_;
1923  /// Variable selection function
1924  CbcBranchDecision * branchingMethod_;
1925  /// Cut modifier function
1926  CbcCutModifier * cutModifier_;
1927  /// Strategy
1928  CbcStrategy * strategy_;
1929  /// Parent model
1930  CbcModel * parentModel_;
1931  /** Whether to automatically do presolve before branch and bound.
1932      0 - no
1933      1 - ordinary presolve
1934      2 - integer presolve (dodgy)
1935  */
1936  /// Pointer to array[getNumCols()] (for speed) of column lower bounds
1937  const double * cbcColLower_;
1938  /// Pointer to array[getNumCols()] (for speed) of column upper bounds
1939  const double * cbcColUpper_;
1940  /// Pointer to array[getNumRows()] (for speed) of row lower bounds
1941  const double * cbcRowLower_;
1942  /// Pointer to array[getNumRows()] (for speed) of row upper bounds
1943  const double * cbcRowUpper_;
1944  /// Pointer to array[getNumCols()] (for speed) of primal solution vector
1945  const double * cbcColSolution_;
1946  /// Pointer to array[getNumRows()] (for speed) of dual prices
1947  const double * cbcRowPrice_;
1948  /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
1949  const double * cbcReducedCost_;
1950  /// Pointer to array[getNumRows()] (for speed) of row activity levels.
1951  const double * cbcRowActivity_;
1952  /// Pointer to user-defined data structure
1953  void * appData_;
1954  /// Pointer to a mutex
1955  void * mutex_;
1956  /// Presolve for CbcTreeLocal
1957  int presolve_;
1958  /** Maximum number of candidates to consider for strong branching.
1959    To disable strong branching, set this to 0.
1960  */
1961  int numberStrong_;
1962  /** \brief The number of branches before pseudo costs believed
1963             in dynamic strong branching.
1964     
1965    A value of 0 is  off.
1966  */
1967  int numberBeforeTrust_;
1968  /** \brief The number of variables for which to compute penalties
1969             in dynamic strong branching.
1970  */
1971  int numberPenalties_;
1972  /// For threads - stop after this many "iterations"
1973  int stopNumberIterations_;
1974  /** Scale factor to make penalties match strong.
1975      Should/will be computed */
1976  double penaltyScaleFactor_;
1977  /// Number of analyze iterations to do
1978  int numberAnalyzeIterations_;
1979  /// Arrays with analysis results
1980  double * analyzeResults_;
1981  /// Number of nodes infeasible by normal branching (before cuts)
1982  int numberInfeasibleNodes_;
1983  /** Problem type as set by user or found by analysis.  This will be extended
1984      0 - not known
1985      1 - Set partitioning <=
1986      2 - Set partitioning ==
1987      3 - Set covering
1988  */
1989  int problemType_;
1990  /// Print frequency
1991  int printFrequency_;
1992  /// Number of cut generators
1993  int numberCutGenerators_;
1994  // Cut generators
1995  CbcCutGenerator ** generator_;
1996  // Cut generators before any changes
1997  CbcCutGenerator ** virginGenerator_;
1998  /// Number of heuristics
1999  int numberHeuristics_;
2000  /// Heuristic solvers
2001  CbcHeuristic ** heuristic_;
2002  /// Pointer to heuristic solver which found last solution (or NULL)
2003  CbcHeuristic * lastHeuristic_;
2004  /*! Pointer to the event handler */
2005# ifdef CBC_ONLY_CLP
2006  ClpEventHandler *eventHandler_ ;
2007# else
2008  CbcEventHandler *eventHandler_ ;
2009# endif
2010
2011  /// Total number of objects
2012  int numberObjects_;
2013
2014  /** \brief Integer and Clique and ... information
2015
2016    \note The code assumes that the first objects on the list will be
2017          SimpleInteger objects for each integer variable, followed by
2018          Clique objects. Portions of the code that understand Clique objects
2019          will fail if they do not immediately follow the SimpleIntegers.
2020          Large chunks of the code will fail if the first objects are not
2021          SimpleInteger. As of 2003.08, SimpleIntegers and Cliques are the only
2022          objects.
2023  */
2024  OsiObject ** object_;
2025  /// Now we may not own objects - just point to solver's objects
2026  bool ownObjects_;
2027 
2028  /// Original columns as created by integerPresolve or preprocessing
2029  int * originalColumns_;
2030  /// How often to scan global cuts
2031  int howOftenGlobalScan_;
2032  /** Number of times global cuts violated.  When global cut pool then this
2033      should be kept for each cut and type of cut */
2034  int numberGlobalViolations_;
2035  /** Value of objective at continuous
2036      (Well actually after initial round of cuts)
2037  */
2038  double continuousObjective_;
2039  /** Value of objective before root node cuts added
2040  */
2041  double originalContinuousObjective_;
2042  /// Number of infeasibilities at continuous
2043  int continuousInfeasibilities_;
2044  /// Maximum number of cut passes at root
2045  int maximumCutPassesAtRoot_;
2046  /// Maximum number of cut passes
2047  int maximumCutPasses_;
2048  /// Preferred way of branching
2049  int preferredWay_;
2050  /// Current cut pass number
2051  int currentPassNumber_;
2052  /// Maximum number of cuts (for whichGenerator_)
2053  int maximumWhich_;
2054  /// Maximum number of rows
2055  int maximumRows_;
2056  /// Work basis for temporary use
2057  CoinWarmStartBasis workingBasis_;
2058  /// Which cut generator generated this cut
2059  int * whichGenerator_;
2060  /// Maximum number of statistics
2061  int maximumStatistics_;
2062  /// statistics
2063  CbcStatistics ** statistics_;
2064  /// Maximum depth reached
2065  int maximumDepthActual_;
2066  /// Number of reduced cost fixings
2067  double numberDJFixed_;
2068  /// Probing info
2069  CglTreeProbingInfo * probingInfo_;
2070  /// Number of fixed by analyze at root
2071  int numberFixedAtRoot_;
2072  /// Number fixed by analyze so far
2073  int numberFixedNow_;
2074  /// Whether stopping on gap
2075  bool stoppedOnGap_;
2076  /// Whether event happened
2077  bool eventHappened_;
2078  /// Number of long strong goes
2079  int numberLongStrong_;
2080  /// Number of old active cuts
2081  int numberOldActiveCuts_;
2082  /// Number of new cuts
2083  int numberNewCuts_;
2084  /// Size of mini - tree
2085  int sizeMiniTree_;
2086  /// Strategy worked out - mainly at root node
2087  int searchStrategy_;
2088  /// Number of iterations in strong branching
2089  int numberStrongIterations_;
2090  /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible */
2091  int strongInfo_[3];
2092  /**
2093      For advanced applications you may wish to modify the behavior of Cbc
2094      e.g. if the solver is a NLP solver then you may not have an exact
2095      optimum solution at each step.  This gives characteristics - just for one BAB.
2096      For actually saving/restoring a solution you need the actual solver one.
2097  */
2098  OsiBabSolver * solverCharacteristics_;
2099  /// Whether to force a resolve after takeOffCuts
2100  bool resolveAfterTakeOffCuts_;
2101#if NEW_UPDATE_OBJECT>1
2102  /// Number of outstanding update information items
2103  int numberUpdateItems_;
2104  /// Maximum number of outstanding update information items
2105  int maximumNumberUpdateItems_;
2106  /// Update items
2107  CbcObjectUpdateData * updateItems_;
2108#endif
2109  /**
2110     Parallel
2111     0 - off
2112     1 - testing
2113     2-99 threads
2114     other special meanings
2115  */
2116  int numberThreads_;
2117  /** thread mode
2118      always use numberThreads for branching
2119      1 set then use numberThreads in root mini branch and bound
2120      2 set then use numberThreads for root cuts
2121      default is 0
2122  */
2123  int threadMode_;
2124 //@}
2125};
2126/// So we can use osiObject or CbcObject during transition
2127void getIntegerInformation(const OsiObject * object, double & originalLower,
2128                           double & originalUpper) ;
2129// So we can call from other programs
2130// Real main program
2131class OsiClpSolverInterface;
2132int CbcMain (int argc, const char *argv[],OsiClpSolverInterface & solver,CbcModel ** babSolver);
2133int CbcMain (int argc, const char *argv[],CbcModel & babSolver);
2134// four ways of calling
2135int callCbc(const char * input2, OsiClpSolverInterface& solver1); 
2136int callCbc(const char * input2);
2137int callCbc(const std::string input2, OsiClpSolverInterface& solver1); 
2138int callCbc(const std::string input2) ;
2139// When we want to load up CbcModel with options first
2140void CbcMain0 (CbcModel & babSolver);
2141int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver);
2142// two ways of calling
2143int callCbc(const char * input2, CbcModel & babSolver); 
2144int callCbc(const std::string input2, CbcModel & babSolver); 
2145// And when CbcMain0 already called to initialize
2146int callCbc1(const char * input2, CbcModel & babSolver); 
2147int callCbc1(const std::string input2, CbcModel & babSolver); 
2148// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
2149int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 
2150int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 
2151int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
2152// For uniform setting of cut and heuristic options
2153void setCutAndHeuristicOptions(CbcModel & model);
2154#endif
Note: See TracBrowser for help on using the repository browser.