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

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

add ifdefs for future exploration

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