source: branches/devel/Cbc/src/CbcGenCtlBlk.hpp @ 592

Last change on this file since 592 was 591, checked in by lou, 13 years ago

Initial commit of cbc-generic source.

  • Property svn:eol-style set to native
File size: 23.0 KB
Line 
1/*
2  Copyright (C) 2007, Lou Hafer, International Business Machines Corporation
3  and others.  All Rights Reserved.
4
5  This file is part of cbc-generic.
6*/
7
8#ifndef CbcGenCtlBlk_H
9#define CbcGenCtlBlk_H
10
11/* \file CbcGenCtlBlk.hpp
12   \brief Declarations for parameters of the cbc-generic main program.
13*/
14
15#include "CoinParam.hpp"
16
17#include "CglCutGenerator.hpp"
18#include "CglProbing.hpp"
19#include "CglClique.hpp"
20#include "CglFlowCover.hpp"
21#include "CglGomory.hpp"
22#include "CglKnapsackCover.hpp"
23#include "CglMixedIntegerRounding2.hpp"
24#include "CglOddHole.hpp"
25#include "CglRedSplit.hpp"
26#include "CglTwomir.hpp"
27
28#include "CbcModel.hpp"
29
30#include "CbcHeuristic.hpp"
31#include "CbcHeuristicFPump.hpp"
32#include "CbcHeuristicGreedy.hpp"
33#include "CbcHeuristicLocal.hpp"
34#include "CbcTreeLocal.hpp"
35
36#define CBC_GENERIC_VERSION "00.01.00"
37
38class CbcGenCtlBlk ;
39namespace CbcGenParamUtils
40{
41  void addCbcGenParams(int &numParams, CoinParamVec &paramVec,
42                       CbcGenCtlBlk *ctlBlk) ;
43}
44
45/* \brief cbc-generic algorithm control class
46
47  This class defines values and methods used to control the operation of the
48  cbc-generic main program.
49*/
50
51class CbcGenCtlBlk
52{
53
54friend void CbcGenParamUtils::addCbcGenParams(int &numParams,
55        CoinParamVec &paramVec, CbcGenCtlBlk *ctlBlk) ;
56
57public:
58
59/*! \name Enumeration types used for cbc-generic control variables */
60//@{
61
62/*
63  In order for initialisation to work properly, the order of declaration of
64  the enum constants here must match the order of keyword declaration for
65  the PREPROCESS parameter in CbcGenParamUtils::addCbcGenParams
66*/
67/*! \brief Codes to control integer preprocessing
68
69  - IPPOff: Integer preprocessing is off.
70  - IPPOn:  Integer preprocessing is on.
71  - IPPSave: IPPOn, plus preprocessed system will be saved to presolved.mps.
72  - IPPEqual: IPPOn, plus `<=' cliques are converted to `=' cliques.
73  - IPPSOS: IPPOn, plus will create SOS sets (see below).
74  - IPPTrySOS: IPPOn, plus will create SOS sets (see below).
75  - IPPEqualAll: IPPOn, plus turns all valid inequalities into equalities
76                with integer slacks.
77  - IPPStrategy: look to CbcStrategy object for instructions.
78
79  IPPSOS will create SOS sets if all binary variables (except perhaps one)
80  can be covered by SOS sets with no overlap between sets. IPPTrySOS will
81  allow any number of binary variables to be uncovered.
82*/
83
84typedef enum { IPPOff = 0, IPPOn, IPPSave, IPPEqual,
85               IPPSOS, IPPTrySOS, IPPEqualAll, IPPStrategy } IPPControl ;
86
87/*
88  In order for initialisation to work properly, the order of declaration of
89  the enum constants here must match the order of keyword declaration for
90  the various cut and heuristic control parameters in
91  CbcGenParamUtils::addCbcGenParams
92*/
93/*! \brief Codes to control the use of cut generators and heuristics
94
95  - CGOff: the cut generator will not be installed
96  - CGOn:  the cut generator will be installed; exactly how often it's
97           activated depends on the settings at installation
98  - CGRoot: the cut generator will be installed with settings that restrict
99           it to activation at the root node only.
100  - CGIfMove: the cut generator will be installed with settings that allow
101           it to remain active only so long as it's generating cuts that
102           tighten the relaxation.
103  - CGForceOn: the cut generator will be installed with settings that force
104           it to be called at every node
105  - CGForceBut: the cut generator will be installed with settings that force
106           it to be called at every node, but more active at root (probing
107           only)
108  - CGMarker: a convenience to mark the end of the codes.
109
110  The same codes are used for heuristics.
111*/
112
113typedef enum { CGOff, CGOn, CGRoot, CGIfMove,
114               CGForceOn, CGForceBut, CGMarker } CGControl ;
115
116/*! \brief Codes to specify the assignment of branching priorities
117
118  - BPOff: no priorities are passed to cbc
119  - BPCost: a priority vector is constructed based on objective coefficients
120  - BPOrder: a priority vector is constructed based on column order
121  - BPExt: the user has provided a priority vector
122*/
123
124typedef enum { BPOff, BPCost, BPOrder, BPExt } BPControl ;
125
126/*! \brief Major status codes for branch-and-cut
127
128  - BACInvalid: status not yet set
129  - BACNotRun: branch-and-cut has not yet run for the current problem
130  - BACFinish: branch-and-cut has finished normally
131  - BACStop: branch-and-cut has stopped on a limit
132  - BACAbandon: branch-and-cut abandoned the problem
133  - BACUser: branch-and-cut stopped on user signal
134
135  Consult minorStatus_ for details.
136
137  These codes are (mostly) set to match the codes used by CbcModel. Additions
138  to CbcModel codes should be reflected here and in translateMajor.
139*/
140
141typedef enum { BACInvalid = -1, BACFinish = 0,
142               BACStop = 1, BACAbandon = 2, BACNotRun, BACUser = 5 } BACMajor ;
143
144/*! \brief Minor status codes
145
146  - BACmInvalid         status not yet set
147  - BACmFinish          search exhausted the tree; optimal solution found
148  - BACmInfeas          problem is infeasible
149  - BACmUbnd            problem is unbounded
150  - BACmGap             stopped on integrality gap
151  - BACmNodeLimit       stopped on node limit
152  - BACmTimeLimit       stopped on time limit
153  - BACmSolnLimit       stopped on number of solutions limit
154  - BACmUser            stopped due to user event
155  - BACmOther           nothing else is appropriate
156
157  It's not possible to make these codes agree with CbcModel. The meaning varies
158  according to context: if the BACWhere code specifies a relaxation, then the
159  minor status reflects the underlying OSI solver. Otherwise, it reflects the
160  integer problem.
161*/
162
163typedef enum { BACmInvalid = -1, BACmFinish = 0, BACmInfeas, BACmUbnd,
164               BACmGap, BACmNodeLimit, BACmTimeLimit, BACmSolnLimit,
165               BACmUser, BACmOther } BACMinor ;
166
167/*! \brief Codes to specify where branch-and-cut stopped
168
169  - BACwNotStarted      stopped before we ever got going
170  - BACwBareRoot        stopped after initial solve of root relaxation
171  - BACwIPP             stopped after integer preprocessing
172  - BACwIPPRelax        stopped after initial solve of preprocessed problem
173  - BACwBAC             stopped at some point in branch-and-cut
174*/
175
176typedef enum { BACwInvalid = -1, BACwNotStarted = 0, BACwBareRoot,
177               BACwIPP, BACwIPPRelax, BACwBAC } BACWhere ;
178
179//@}
180 
181/*! \name Constructors and destructors */
182//@{
183
184  /*! \brief Default constructor */
185
186  CbcGenCtlBlk() ;
187
188  /*! \brief Destructor */
189
190  ~CbcGenCtlBlk() ;
191//@}
192
193/*! \name Access and Control Functions for Cut Generators and Heuristics
194    \brief Control functions, plus lazy creation functions for cut generators
195           and heuristics
196
197    cbc-generic avoids creating objects for cut generators and heuristics
198    unless they're actually used. For cut generators, a prototype is created
199    and reused. For heuristics, the default is to create a new object with each
200    call, because the model may have changed. The object is returned through
201    the reference parameter. The return value of the function is the current
202    action state.
203
204    Cut generator and heuristic objects created by these calls will be deleted
205    with the destruction of the CbcGenCtlBlk object.
206*/
207//@{
208
209  /*! \brief Get cut depth setting
210
211    The name is a bit of a misnomer. Essentially, this overrides the
212    `every so many nodes' control with `execute when (depth in tree)
213    mod (cut depth) == 0'.
214  */
215
216  inline int getCutDepth() { return cutDepth_ ; } ;
217
218  /*! \brief Set cut depth setting.
219
220    See comments for getCutDepth().
221  */
222
223  inline void setCutDepth(int cutDepth) { cutDepth_ = cutDepth ; } ;
224
225  /*1 \brief Get action state for use of integer preprocessing */
226
227  inline IPPControl getIPPAction() { return (preProcess_) ; } ;
228
229  /*! \brief Set action state for use of integer preprocessing */
230
231  inline void setIPPAction(IPPControl action)
232  { preProcess_ = action ; } ;
233
234  /*! \brief Obtain a prototype for a probing cut generator. */
235
236  CGControl getProbing(CglCutGenerator *&gen) ;
237
238  /*! \brief Set action state for use of probing cut generator. */
239
240  inline void setProbingAction(CGControl action)
241  { probing_.action_ = action ; } ;
242
243  /*! \brief Obtain a prototype for a clique cut generator. */
244
245  CGControl getClique(CglCutGenerator *&gen) ;
246
247  /*! \brief Set action state for use of clique cut generator. */
248
249  inline void setCliqueAction(CGControl action)
250  { clique_.action_ = action ; } ;
251
252  /*! \brief Obtain a prototype for a flow cover cut generator. */
253
254  CGControl getFlow(CglCutGenerator *&gen) ;
255
256  /*! \brief Set action state for use of flow cover cut generator. */
257
258  inline void setFlowAction(CGControl action)
259  { flow_.action_ = action ; } ;
260
261  /*! \brief Obtain a prototype for a Gomory cut generator. */
262
263  CGControl getGomory(CglCutGenerator *&gen) ;
264
265  /*! \brief Set action state for use of Gomory cut generator. */
266
267  inline void setGomoryAction(CGControl action)
268  { gomory_.action_ = action ; } ;
269
270  /*! \brief Obtain a prototype for a knapsack cover cut generator. */
271
272  CGControl getKnapsack(CglCutGenerator *&gen) ;
273
274  /*! \brief Set action state for use of knapsack cut generator. */
275
276  inline void setKnapsackAction(CGControl action)
277  { knapsack_.action_ = action ; } ;
278
279/*  \brief Obtain a prototype for a lift-and-project cut generator.
280
281  CGControl getLandP(CglCutGenerator *&gen) ;
282
283   \brief Set action state for use of lift-and-project cut generator.
284
285  inline void setLandPAction(CGControl action)
286  { landp_.action_ = action ; } ;
287*/
288
289  /*! \brief Obtain a prototype for a mixed integer rounding (MIR)
290             cut generator.
291  */
292
293  CGControl getMir(CglCutGenerator *&gen) ;
294
295  /*! \brief Set action state for use of MIR cut generator. */
296
297  inline void setMirAction(CGControl action)
298  { mir_.action_ = action ; } ;
299
300  /*! \brief Obtain a prototype for a reduce and split cut generator. */
301
302  CGControl getRedSplit(CglCutGenerator *&gen) ;
303
304  /*! \brief Set action state for use of reduce and split cut generator. */
305
306  inline void setRedSplitAction(CGControl action)
307  { redSplit_.action_ = action ; } ;
308
309  /*! \brief Obtain a prototype for a 2-MIR cut generator. */
310
311  CGControl getTwomir(CglCutGenerator *&gen) ;
312
313  /*! \brief Set action state for use of 2-MIR cut generator. */
314
315  inline void setTwomirAction(CGControl action)
316  { twomir_.action_ = action ; } ;
317
318
319  /*! \brief Obtain a feasibility pump heuristic.
320 
321    By default, any existing object is deleted and a new object is created and
322    loaded with \c model. Set alwaysCreate = false to return an existing object
323    if one exists.
324  */
325 
326  CGControl getFPump(CbcHeuristic *&gen, CbcModel *model,
327                     bool alwaysCreate = true) ;
328
329  /*! \brief Set action state for use of feasibility pump heuristic. */
330
331  inline void setFPumpAction(CGControl action)
332  { fpump_.action_ = action ; } ;
333
334  /*! \brief Obtain a local search/combine heuristic.
335 
336    By default, any existing object is deleted and a new object is created and
337    loaded with \c model. Set alwaysCreate = false to return an existing object
338    if one exists.
339  */
340
341  CGControl getCombine(CbcHeuristic *&gen, CbcModel *model,
342                        bool alwaysCreate = true) ;
343
344  /*! \brief Set action state for use of local search/combine heuristic. */
345
346  inline void setCombineAction(CGControl action)
347  { combine_.action_ = action ; } ;
348
349  /*! \brief Obtain a greedy cover heuristic.
350 
351    By default, any existing object is deleted and a new object is created and
352    loaded with \c model. Set alwaysCreate = false to return an existing object
353    if one exists.
354  */
355
356  CGControl getGreedyCover(CbcHeuristic *&gen, CbcModel *model,
357                            bool alwaysCreate = true) ;
358
359  /*! \brief Set action state for use of greedy cover heuristic. */
360
361  inline void setGreedyCoverAction(CGControl action)
362  { greedyCover_.action_ = action ; } ;
363
364  /*! \brief Obtain a greedy equality heuristic.
365 
366    By default, any existing object is deleted and a new object is created and
367    loaded with \c model. Set alwaysCreate = false to return an existing object
368    if one exists.
369  */
370
371  CGControl getGreedyEquality(CbcHeuristic *&gen, CbcModel *model,
372                               bool alwaysCreate = true) ;
373
374  /*! \brief Set action state for use of greedy equality heuristic. */
375
376  inline void setGreedyEqualityAction(CGControl action)
377  { greedyEquality_.action_ = action ; } ;
378
379  /*! \brief Obtain a simple rounding heuristic.
380 
381    By default, any existing object is deleted and a new object is created and
382    loaded with \c model. Set alwaysCreate = false to return an existing object
383    if one exists.
384  */
385
386  CGControl getRounding(CbcHeuristic *&gen, CbcModel *model,
387                        bool alwaysCreate = true) ;
388
389  /*! \brief Set action state for use of simple rounding heuristic. */
390
391  inline void setRoundingAction(CGControl action)
392  { rounding_.action_ = action ; } ;
393
394  /*! \brief Obtain a local search tree object
395 
396    By default, any existing object is deleted and a new object is created and
397    loaded with \c model. Set alwaysCreate = false to return an existing object
398    if one exists.
399  */
400
401  CGControl getTreeLocal(CbcTreeLocal *&localTree, CbcModel *model,
402                         bool alwaysCreate = true) ;
403
404  /*! \brief Set action state for use of local tree. */
405
406  inline void setTreeLocalAction(CGControl action)
407  { localTree_.action_ = action ; } ;
408
409//@}
410
411/*! \brief Convenience routines for status codes. */
412//@{
413
414  /*! \brief Set the result of branch-and-cut search */
415
416  inline void setBaBStatus(BACMajor majorStatus, BACMinor minorStatus,
417                           BACWhere where, bool haveAnswer,
418                           OsiSolverInterface *answerSolver)
419  { bab_.majorStatus_ = majorStatus ;
420    bab_.minorStatus_ = minorStatus ;
421    bab_.where_ = where ;
422    bab_.haveAnswer_ = haveAnswer ;
423    bab_.answerSolver_ = answerSolver ; }
424
425  /*! \brief Set the result of branch-and-cut search
426 
427    This version will extract the necessary information from the CbcModel
428    object and set appropriate status based on the value passed for where.
429  */
430  void setBaBStatus(const CbcModel *model, BACWhere where,
431                    bool haveAnswer = false,
432                    OsiSolverInterface *answerSolver = 0) ;
433
434  /*! \brief Translate CbcModel major status to BACMajor
435 
436    See the BACMajor enum for details.
437  */
438  BACMajor translateMajor(int status) ;
439
440  /*!\brief Translate CbcModel minor status to BACMinor
441
442    See the BACMinor enum for details.
443  */
444  BACMinor translateMinor(int status) ;
445
446  /*!\brief Translate OsiSolverInterface status to BACMinor
447
448    See the BACMinor enum for details. Optimal, infeasible, and unbounded
449    get their own codes; everything else maps to BACmOther.
450  */
451  BACMinor translateMinor(const OsiSolverInterface *osi) ;
452
453  /*! \brief Print the status block */
454
455  void printBaBStatus() ;
456
457//@}
458
459/*! \name Parameter parsing, input/output, and such like. */
460//@{
461  /*! \brief cbc-generic version */
462
463  std::string version_ ;
464
465  /*! \brief Default directory prefix */
466
467  std::string dfltDirectory_ ;
468
469  /*! \brief Last MPS input file */
470
471  std::string lastMpsIn_ ;
472
473  /*! \brief Allow/disallow errors when importing a model */
474  bool allowImportErrors_ ;
475
476  /*! \brief Last solution output file */
477
478  std::string lastSolnOut_ ;
479
480  /*! \brief Solution printing mode
481
482    Controls the amount of information printed when printing a solution.
483    Coding is set by the keyword declarations for the printingOptions
484    command.
485  */
486  int printMode_ ;
487
488  /*! \brief Print mask
489
490    Used to specify row/column names to be printed. Not implemented as of
491    060920.
492  */
493  std::string printMask_ ;
494
495  /*! \brief The parameter vector */
496
497  CoinParamVec *paramVec_ ;
498
499  /*! \brief Start and end of cbc-generic parameters in parameter vector */
500
501  struct { int first_ ;
502           int last_ ; } genParams_ ;
503
504  /*! \brief Start and end of CbcModel parameters in parameter vector */
505
506  struct { int first_ ;
507           int last_ ; } cbcParams_ ;
508
509  /*! \brief Start and end of OsiSolverInterface  parameters in parameter
510             vector
511  */
512
513  struct { int first_ ;
514           int last_ ; } osiParams_ ;
515
516  /*! \brief Verbosity level for help messages.
517 
518    Interpretation is bitwise:
519    - (0): short help
520    - (1): long help
521    - (2): unused (for compatibility with cbc; indicates AMPL)
522    - (3): show parameters with display = false.
523  */
524
525  int verbose_ ;
526
527  /*! \brief Number of parameters processed */
528
529  int paramsProcessed_ ;
530
531  /*! \brief Record of parameters changed by the user command */
532
533  std::vector<bool> setByUser_ ;
534
535  /*! \brief False if the user has made nontrivial modifications to the
536             default control settings.
537
538    Initially true. Specifying DJFIX, TIGHTENFACTOR, or any cut or heuristic
539    parameter will set this to false.
540  */
541  bool defaultSettings_ ;
542
543  /*! \brief Control debug file creation
544
545    At the conclusion of branch-and-cut, dump the full solution in a binary
546    format to debug.file in the current directory.  When set to
547    "createAfterPre", the solution is dumped before integer presolve
548    transforms are removed.  When set to "create", the solution is dumped
549    after integer presolve transforms are backed out.
550  */
551  std::string debugCreate_ ;
552
553  /*! \brief Last debug input file
554 
555    The file is expected to be in a binary format understood by
556    activateRowCutDebugger.
557  */
558
559  std::string debugFile_ ;
560
561  /*! \brief Array of primal variable values for debugging
562
563    Used to provide a known optimal solution to activateRowCutDebugger().
564  */
565
566  struct { int numCols_ ;
567           double *values_ ; } debugSol_ ;
568
569  /*! \brief When greater than 0, presolve gives more information and
570             branch-and-cut provides statistics.
571  */
572
573  int printOpt_ ;
574
575//@}
576
577/* \name Timing */
578//@{
579
580  /*! \brief Total elapsed time for this run. */
581
582  double totalTime_ ;
583
584//@}
585
586/*! \name Models of various flavours */
587//@{
588
589  /*! \brief The reference CbcModel object.
590
591    This is the CbcModel created when cbc-generic boots up. It holds the
592    default solver with the current constraint system. CbcCbcParam parameters
593    are applied here, and CbcOsiParam parameters are applied to the solver.
594    Major modifications for branch-and-cut (integer preprocessing,
595    installation of heuristics and cut generators) are performed on a clone.
596    The solution is transferred back into this object.
597  */
598
599  CbcModel *model_ ;
600
601  /*! \brief The current default LP solver
602 
603    This is a pointer to a reference copy. If you want the solver associated
604    with #model_, ask for it directly.
605  */
606
607  OsiSolverInterface *dfltSolver_ ;
608
609  /*! \brief True if we have a valid model loaded, false otherwise. */
610
611  bool goodModel_ ;
612
613  /*! \brief State of branch-and-cut
614
615    Major and minor status codes, and a solver holding the answer, assuming
616    we have a valid answer. See the documentation with the BACMajor,
617    BACMinor, and BACWhere enums for the meaning of the codes.
618  */
619
620  struct { BACMajor majorStatus_ ;
621           BACMinor minorStatus_ ;
622           BACWhere where_ ;
623           bool haveAnswer_ ;
624           OsiSolverInterface *answerSolver_ ; } bab_ ;
625
626//@}
627
628/*! \name Various algorithm control variables and settings */
629//@{
630
631  /*! \brief Control use of reduced cost fixing prior to B&C
632
633    This heuristic fixes variables whose reduced cost for the root
634    relaxtion exceeds the specified threshold. This is purely a heuristic,
635    performed before there's any incumbent solution. It may well fix variables
636    at the wrong bound!
637  */
638
639  struct { bool action_ ;
640           double threshold_ ; } djFix_ ;
641
642  /*! \brief Control the assignment of branching priorities to integer
643             variables.
644  */
645  BPControl priorityAction_ ;
646
647//@}
648
649/*! \name Branching Method Control
650    \brief Usage control and prototypes for branching methods.
651
652    Looking to the future, this covers only OsiChoose methods.
653*/
654//@{
655
656  /*! \brief Control variables for a strong branching method.
657 
658    Consult OsiChooseVariable and CbcModel for details. An artifact of the
659    changeover from CbcObjects to OsiObjects is that the number of uses before
660    pseudo costs are trusted (numBeforeTrust_) and the number of variables
661    evaluated with strong branching (numStrong_) are parameters of CbcModel.
662  */
663  struct { int numBeforeTrust_ ;
664           int numStrong_ ;
665           int shadowPriceMode_ ; } chooseStrong_ ;
666//@}
667
668private:
669
670/*! \name Cut Generator and Heuristic Control
671    \brief Usage control and prototypes for cut generators and heuristics.
672*/
673//@{
674
675  /*! \brief Control integer preprocessing. */
676
677  IPPControl preProcess_ ;
678
679  /*! \brief Control cut generator activity
680 
681    Generators that are active in the tree will be activated when
682    (depth) mod (cutDepth) == 0.
683  */
684
685  int cutDepth_ ;
686
687  /*! \brief Control variable and prototype for probing cut generator */
688  struct { CGControl action_ ;
689           CglProbing *proto_ ;
690           bool usingObjective_ ;
691           int maxPass_ ;
692           int maxPassRoot_ ;
693           int maxProbe_ ;
694           int maxProbeRoot_ ;
695           int maxLook_ ;
696           int maxLookRoot_ ;
697           int maxElements_ ;
698           int rowCuts_ ; } probing_ ;
699
700  /*! \brief Control variable and prototype for clique cut generator */
701  struct { CGControl action_ ;
702           CglClique *proto_ ;
703           bool starCliqueReport_ ;
704           bool rowCliqueReport_ ;
705           double minViolation_ ; } clique_ ;
706
707  /*! \brief Control variable and prototype for flow cover cut generator */
708  struct { CGControl action_ ;
709           CglFlowCover *proto_ ; } flow_ ;
710
711  /*! \brief Control variable and prototype for Gomory cut generator */
712  struct { CGControl action_ ;
713           CglGomory *proto_ ;
714           int limit_ ;
715           int limitAtRoot_ ; } gomory_ ;
716
717/*   \brief Control variable and prototype for lift-and-project cut
718             generator
719   struct { CGControl action_ ;
720           CglLandP *proto_ ; } landp_ ;
721*/
722
723  /*! \brief Control variable and prototype for knapsack cover cut generator */
724  struct { CGControl action_ ;
725           CglKnapsackCover *proto_ ; } knapsack_ ;
726
727  /*! \brief Control variable and prototype for MIR cut generator */
728  struct { CGControl action_ ;
729           CglMixedIntegerRounding2 *proto_ ; } mir_ ;
730
731  /*! \brief Control variable and prototype for odd hole cut generator */
732  struct { CGControl action_ ;
733           CglOddHole *proto_ ; } oddHole_ ;
734
735  /*! \brief Control variable and prototype for reduce-and-split
736             cut generator
737  */
738  struct { CGControl action_ ;
739           CglRedSplit *proto_ ; } redSplit_ ;
740
741  /*! \brief Control variable and prototype for Two-MIR cut generator */
742  struct { CGControl action_ ;
743           CglTwomir *proto_ ;
744           int maxElements_ ; } twomir_ ;
745
746  /*! \brief Control variable and prototype for feasibility pump heuristic */
747  struct { CGControl action_ ;
748           CbcHeuristicFPump *proto_ ;
749           int iters_ ; } fpump_ ;
750
751  /*! \brief Control variable and prototype for combine heuristic */
752  struct { CGControl action_ ;
753           CbcHeuristicLocal *proto_ ;
754           int trySwap_ ; } combine_ ;
755
756  /*! \brief Control variable and prototype for greedy cover heuristic */
757  struct { CGControl action_ ;
758           CbcHeuristicGreedyCover *proto_ ; } greedyCover_ ;
759
760  /*! \brief Control variable and prototype for greedy equality heuristic */
761  struct { CGControl action_ ;
762           CbcHeuristicGreedyEquality *proto_ ; } greedyEquality_ ;
763
764  /*! \brief Control variable and prototype for simple rounding heuristic */
765  struct { CGControl action_ ;
766           CbcRounding *proto_ ; } rounding_ ;
767
768
769  /*! \brief Control variables for local tree
770 
771    This is a bit different --- getTreeLocal() takes a CbcModel as a parameter
772    and installs a local tree object. But we can keep the parameters here and
773    hide the details. Consult CbcTreeLocal.hpp for details.
774  */
775  struct { CGControl action_ ;
776           CbcTreeLocal *proto_ ;
777           double *soln_ ;
778           int range_ ;
779           int typeCuts_ ;
780           int maxDiverge_ ;
781           int timeLimit_ ;
782           int nodeLimit_ ;
783           bool refine_ ; } localTree_ ;
784
785//@}
786
787} ;
788
789
790#endif
Note: See TracBrowser for help on using the repository browser.