1 
2 /* $Id: CbcOrClpParam.hpp 2468 2019-05-03 04:31:14Z stefan $ */
3 // Copyright (C) 2002, International Business Machines
4 // Corporation and others.  All Rights Reserved.
5 // This code is licensed under the terms of the Eclipse Public License (EPL).
6 
7 #ifdef USE_CBCCONFIG
8 #include "CbcConfig.h"
9 #else
10 #include "ClpConfig.h"
11 #endif
12 
13 #ifndef CbcOrClpParam_H
14 #define CbcOrClpParam_H
15 /**
16    This has parameter handling stuff which can be shared between Cbc and Clp (and Dylp etc).
17 
18    This (and .cpp) should be copied so that it is the same in Cbc/Test and Clp/Test.
19    I know this is not elegant but it seems simplest.
20 
21    It uses COIN_HAS_CBC for parameters wanted by CBC
22    It uses COIN_HAS_CLP for parameters wanted by CLP (or CBC using CLP)
23    It could use COIN_HAS_DYLP for parameters wanted by DYLP
24    It could use COIN_HAS_DYLP_OR_CLP for parameters wanted by DYLP or CLP etc etc
25 
26  */
27 class OsiSolverInterface;
28 class CbcModel;
29 class ClpSimplex;
30 /*! \brief Parameter codes
31 
32   Parameter type ranges are allocated as follows
33   <ul>
34     <li>   1 -- 100  double parameters
35     <li> 101 -- 200  integer parameters
36     <li> 201 -- 300  Clp string parameters
37     <li> 301 -- 400  Cbc string parameters
38     <li> 401 -- 500  (mostly) Clp actions
39     <li> 501 -- 600  (mostly) Cbc actions
40   </ul>
41 
42   `Actions' do not necessarily invoke an immediate action; it's just that they
43   don't fit neatly into the parameters array.
44 
45   This coding scheme is in flux.
46 */
47 
48 enum CbcOrClpParameterType
49 
50 {
51   CBC_PARAM_GENERALQUERY = -100,
52   CBC_PARAM_FULLGENERALQUERY,
53 
54   CLP_PARAM_DBL_PRIMALTOLERANCE = 1,
55   CLP_PARAM_DBL_DUALTOLERANCE,
56   CLP_PARAM_DBL_TIMELIMIT,
57   CLP_PARAM_DBL_DUALBOUND,
58   CLP_PARAM_DBL_PRIMALWEIGHT,
59   CLP_PARAM_DBL_OBJSCALE,
60   CLP_PARAM_DBL_RHSSCALE,
61   CLP_PARAM_DBL_ZEROTOLERANCE,
62   CLP_PARAM_DBL_PSI,
63 
64   CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
65   CBC_PARAM_DBL_CUTOFF,
66   CBC_PARAM_DBL_INTEGERTOLERANCE,
67   CBC_PARAM_DBL_INCREMENT,
68   CBC_PARAM_DBL_ALLOWABLEGAP,
69   CBC_PARAM_DBL_TIMELIMIT_BAB,
70   CBC_PARAM_DBL_GAPRATIO,
71 
72   CBC_PARAM_DBL_DJFIX = 81,
73   CBC_PARAM_DBL_TIGHTENFACTOR,
74   CLP_PARAM_DBL_PRESOLVETOLERANCE,
75   CLP_PARAM_DBL_OBJSCALE2,
76   CBC_PARAM_DBL_FAKEINCREMENT,
77   CBC_PARAM_DBL_FAKECUTOFF,
78   CBC_PARAM_DBL_ARTIFICIALCOST,
79   CBC_PARAM_DBL_DEXTRA3,
80   CBC_PARAM_DBL_SMALLBAB,
81   CBC_PARAM_DBL_DEXTRA4,
82   CBC_PARAM_DBL_DEXTRA5,
83 
84   CLP_PARAM_INT_SOLVERLOGLEVEL = 101,
85 #ifndef COIN_HAS_CBC
86   CLP_PARAM_INT_LOGLEVEL = 101,
87 #endif
88   CLP_PARAM_INT_MAXFACTOR,
89   CLP_PARAM_INT_PERTVALUE,
90   CLP_PARAM_INT_MAXITERATION,
91   CLP_PARAM_INT_PRESOLVEPASS,
92   CLP_PARAM_INT_IDIOT,
93   CLP_PARAM_INT_SPRINT,
94   CLP_PARAM_INT_OUTPUTFORMAT,
95   CLP_PARAM_INT_SLPVALUE,
96   CLP_PARAM_INT_PRESOLVEOPTIONS,
97   CLP_PARAM_INT_PRINTOPTIONS,
98   CLP_PARAM_INT_SPECIALOPTIONS,
99   CLP_PARAM_INT_SUBSTITUTION,
100   CLP_PARAM_INT_DUALIZE,
101   CLP_PARAM_INT_VERBOSE,
102   CLP_PARAM_INT_CPP,
103   CLP_PARAM_INT_PROCESSTUNE,
104   CLP_PARAM_INT_USESOLUTION,
105   CLP_PARAM_INT_RANDOMSEED,
106   CLP_PARAM_INT_MORESPECIALOPTIONS,
107   CLP_PARAM_INT_DECOMPOSE_BLOCKS,
108   CLP_PARAM_INT_VECTOR_MODE,
109 
110   CBC_PARAM_INT_STRONGBRANCHING = 151,
111   CBC_PARAM_INT_CUTDEPTH,
112   CBC_PARAM_INT_MAXNODES,
113   CBC_PARAM_INT_NUMBERBEFORE,
114   CBC_PARAM_INT_NUMBERANALYZE,
115   CBC_PARAM_INT_MIPOPTIONS,
116   CBC_PARAM_INT_MOREMIPOPTIONS,
117   CBC_PARAM_INT_MAXHOTITS,
118   CBC_PARAM_INT_FPUMPITS,
119   CBC_PARAM_INT_MAXSOLS,
120   CBC_PARAM_INT_FPUMPTUNE,
121   CBC_PARAM_INT_TESTOSI,
122   CBC_PARAM_INT_EXTRA1,
123   CBC_PARAM_INT_EXTRA2,
124   CBC_PARAM_INT_EXTRA3,
125   CBC_PARAM_INT_EXTRA4,
126   CBC_PARAM_INT_DEPTHMINIBAB,
127   CBC_PARAM_INT_CUTPASSINTREE,
128   CBC_PARAM_INT_THREADS,
129   CBC_PARAM_INT_CUTPASS,
130   CBC_PARAM_INT_VUBTRY,
131   CBC_PARAM_INT_DENSE,
132   CBC_PARAM_INT_EXPERIMENT,
133   CBC_PARAM_INT_DIVEOPT,
134   CBC_PARAM_INT_DIVEOPTSOLVES,
135   CBC_PARAM_INT_STRATEGY,
136   CBC_PARAM_INT_SMALLFACT,
137   CBC_PARAM_INT_HOPTIONS,
138   CBC_PARAM_INT_CUTLENGTH,
139   CBC_PARAM_INT_FPUMPTUNE2,
140 #ifdef COIN_HAS_CBC
141   CLP_PARAM_INT_LOGLEVEL,
142 #endif
143   CBC_PARAM_INT_MAXSAVEDSOLS,
144   CBC_PARAM_INT_RANDOMSEED,
145   CBC_PARAM_INT_MULTIPLEROOTS,
146   CBC_PARAM_INT_STRONG_STRATEGY,
147   CBC_PARAM_INT_EXTRA_VARIABLES,
148   CBC_PARAM_INT_MAX_SLOW_CUTS,
149   CBC_PARAM_INT_MOREMOREMIPOPTIONS,
150 
151   CLP_PARAM_STR_DIRECTION = 201,
152   CLP_PARAM_STR_DUALPIVOT,
153   CLP_PARAM_STR_SCALING,
154   CLP_PARAM_STR_ERRORSALLOWED,
155   CLP_PARAM_STR_KEEPNAMES,
156   CLP_PARAM_STR_SPARSEFACTOR,
157   CLP_PARAM_STR_PRIMALPIVOT,
158   CLP_PARAM_STR_PRESOLVE,
159   CLP_PARAM_STR_CRASH,
160   CLP_PARAM_STR_BIASLU,
161   CLP_PARAM_STR_PERTURBATION,
162   CLP_PARAM_STR_MESSAGES,
163   CLP_PARAM_STR_AUTOSCALE,
164   CLP_PARAM_STR_CHOLESKY,
165   CLP_PARAM_STR_KKT,
166   CLP_PARAM_STR_BARRIERSCALE,
167   CLP_PARAM_STR_GAMMA,
168   CLP_PARAM_STR_CROSSOVER,
169   CLP_PARAM_STR_PFI,
170   CLP_PARAM_STR_INTPRINT,
171   CLP_PARAM_STR_VECTOR,
172   CLP_PARAM_STR_FACTORIZATION,
173   CLP_PARAM_STR_ALLCOMMANDS,
174   CLP_PARAM_STR_TIME_MODE,
175   CLP_PARAM_STR_ABCWANTED,
176   CLP_PARAM_STR_BUFFER_MODE,
177 
178   CBC_PARAM_STR_NODESTRATEGY = 301,
179   CBC_PARAM_STR_BRANCHSTRATEGY,
180   CBC_PARAM_STR_CUTSSTRATEGY,
181   CBC_PARAM_STR_HEURISTICSTRATEGY,
182   CBC_PARAM_STR_GOMORYCUTS,
183   CBC_PARAM_STR_PROBINGCUTS,
184   CBC_PARAM_STR_KNAPSACKCUTS,
185   CBC_PARAM_STR_REDSPLITCUTS,
186   CBC_PARAM_STR_ROUNDING,
187   CBC_PARAM_STR_SOLVER,
188   CBC_PARAM_STR_CLIQUECUTS,
189   CBC_PARAM_STR_COSTSTRATEGY,
190   CBC_PARAM_STR_FLOWCUTS,
191   CBC_PARAM_STR_MIXEDCUTS,
192   CBC_PARAM_STR_TWOMIRCUTS,
193   CBC_PARAM_STR_PREPROCESS,
194   CBC_PARAM_STR_FPUMP,
195   CBC_PARAM_STR_GREEDY,
196   CBC_PARAM_STR_COMBINE,
197   CBC_PARAM_STR_PROXIMITY,
198   CBC_PARAM_STR_LOCALTREE,
199   CBC_PARAM_STR_SOS,
200   CBC_PARAM_STR_LANDPCUTS,
201   CBC_PARAM_STR_RINS,
202   CBC_PARAM_STR_RESIDCUTS,
203   CBC_PARAM_STR_RENS,
204   CBC_PARAM_STR_DIVINGS,
205   CBC_PARAM_STR_DIVINGC,
206   CBC_PARAM_STR_DIVINGF,
207   CBC_PARAM_STR_DIVINGG,
208   CBC_PARAM_STR_DIVINGL,
209   CBC_PARAM_STR_DIVINGP,
210   CBC_PARAM_STR_DIVINGV,
211   CBC_PARAM_STR_DINS,
212   CBC_PARAM_STR_PIVOTANDFIX,
213   CBC_PARAM_STR_RANDROUND,
214   CBC_PARAM_STR_NAIVE,
215   CBC_PARAM_STR_ZEROHALFCUTS,
216   CBC_PARAM_STR_CPX,
217   CBC_PARAM_STR_CROSSOVER2,
218   CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
219   CBC_PARAM_STR_VND,
220   CBC_PARAM_STR_LAGOMORYCUTS,
221   CBC_PARAM_STR_LATWOMIRCUTS,
222   CBC_PARAM_STR_REDSPLIT2CUTS,
223   CBC_PARAM_STR_GMICUTS,
224   CBC_PARAM_STR_CUTOFF_CONSTRAINT,
225   CBC_PARAM_STR_DW,
226   CBC_PARAM_STR_ORBITAL,
227   CBC_PARAM_STR_PREPROCNAMES,
228   CBC_PARAM_STR_SOSPRIORITIZE,
229 
230   CLP_PARAM_ACTION_DIRECTORY = 401,
231   CLP_PARAM_ACTION_DIRSAMPLE,
232   CLP_PARAM_ACTION_DIRNETLIB,
233   CBC_PARAM_ACTION_DIRMIPLIB,
234   CLP_PARAM_ACTION_IMPORT,
235   CLP_PARAM_ACTION_EXPORT,
236   CLP_PARAM_ACTION_RESTORE,
237   CLP_PARAM_ACTION_SAVE,
238   CLP_PARAM_ACTION_DUALSIMPLEX,
239   CLP_PARAM_ACTION_PRIMALSIMPLEX,
240   CLP_PARAM_ACTION_EITHERSIMPLEX,
241   CLP_PARAM_ACTION_MAXIMIZE,
242   CLP_PARAM_ACTION_MINIMIZE,
243   CLP_PARAM_ACTION_EXIT,
244   CLP_PARAM_ACTION_STDIN,
245   CLP_PARAM_ACTION_UNITTEST,
246   CLP_PARAM_ACTION_NETLIB_EITHER,
247   CLP_PARAM_ACTION_NETLIB_DUAL,
248   CLP_PARAM_ACTION_NETLIB_PRIMAL,
249   CLP_PARAM_ACTION_SOLUTION,
250   CLP_PARAM_ACTION_SAVESOL,
251   CLP_PARAM_ACTION_TIGHTEN,
252   CLP_PARAM_ACTION_FAKEBOUND,
253   CLP_PARAM_ACTION_HELP,
254   CLP_PARAM_ACTION_PLUSMINUS,
255   CLP_PARAM_ACTION_NETWORK,
256   CLP_PARAM_ACTION_ALLSLACK,
257   CLP_PARAM_ACTION_REVERSE,
258   CLP_PARAM_ACTION_BARRIER,
259   CLP_PARAM_ACTION_NETLIB_BARRIER,
260   CLP_PARAM_ACTION_NETLIB_TUNE,
261   CLP_PARAM_ACTION_REALLY_SCALE,
262   CLP_PARAM_ACTION_BASISIN,
263   CLP_PARAM_ACTION_BASISOUT,
264   CLP_PARAM_ACTION_SOLVECONTINUOUS,
265   CLP_PARAM_ACTION_CLEARCUTS,
266   CLP_PARAM_ACTION_VERSION,
267   CLP_PARAM_ACTION_STATISTICS,
268   CLP_PARAM_ACTION_DEBUG,
269   CLP_PARAM_ACTION_DUMMY,
270   CLP_PARAM_ACTION_PRINTMASK,
271   CLP_PARAM_ACTION_OUTDUPROWS,
272   CLP_PARAM_ACTION_USERCLP,
273   CLP_PARAM_ACTION_MODELIN,
274   CLP_PARAM_ACTION_CSVSTATISTICS,
275   CLP_PARAM_ACTION_STOREDFILE,
276   CLP_PARAM_ACTION_ENVIRONMENT,
277   CLP_PARAM_ACTION_PARAMETRICS,
278   CLP_PARAM_ACTION_GMPL_SOLUTION,
279   CLP_PARAM_ACTION_RESTORESOL,
280   CLP_PARAM_ACTION_GUESS,
281 
282   CBC_PARAM_ACTION_BAB = 501,
283   CBC_PARAM_ACTION_MIPLIB,
284   CBC_PARAM_ACTION_STRENGTHEN,
285   CBC_PARAM_ACTION_PRIORITYIN,
286   CBC_PARAM_ACTION_MIPSTART,
287   CBC_PARAM_ACTION_USERCBC,
288   CBC_PARAM_ACTION_DOHEURISTIC,
289   CLP_PARAM_ACTION_NEXTBESTSOLUTION,
290 
291   CBC_PARAM_NOTUSED_OSLSTUFF = 601,
292   CBC_PARAM_NOTUSED_CBCSTUFF,
293 
294   CBC_PARAM_NOTUSED_INVALID = 1000
295 };
296 #include <vector>
297 #include <string>
298 
299 /// Very simple class for setting parameters
300 
301 class CbcOrClpParam {
302 public:
303   /**@name Constructor and destructor */
304   //@{
305   /// Constructors
306   CbcOrClpParam();
307   CbcOrClpParam(std::string name, std::string help,
308     double lower, double upper, CbcOrClpParameterType type, int display = 2);
309   CbcOrClpParam(std::string name, std::string help,
310     int lower, int upper, CbcOrClpParameterType type, int display = 2);
311   // Other strings will be added by insert
312   CbcOrClpParam(std::string name, std::string help, std::string firstValue,
313     CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
314   // Action
315   CbcOrClpParam(std::string name, std::string help,
316     CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
317   /// Copy constructor.
318   CbcOrClpParam(const CbcOrClpParam &);
319   /// Assignment operator. This copies the data
320   CbcOrClpParam &operator=(const CbcOrClpParam &rhs);
321   /// Destructor
322   ~CbcOrClpParam();
323   //@}
324 
325   /**@name stuff */
326   //@{
327   /// Insert string (only valid for keywords)
328   void append(std::string keyWord);
329   /// Adds one help line
330   void addHelp(std::string keyWord);
331   /// Returns name
name() const332   inline std::string name() const
333   {
334     return name_;
335   }
336   /// Returns short help
shortHelp() const337   inline std::string shortHelp() const
338   {
339     return shortHelp_;
340   }
341   /// Returns long help
longHelp() const342   inline std::string longHelp() const
343   {
344     return longHelp_;
345   }
346   /// Returns set of valid strings
definedKeywords() const347   inline const std::vector<std::string>& definedKeywords() const
348   {
349     return definedKeyWords_;
350   }
351   /// Returns the lower bound for a double-valued parameter
lowerDoubleValue() const352   inline double lowerDoubleValue() const
353   {
354      return lowerDoubleValue_;
355   }
356   /// Returns the upper bound for a double-valued parameter
upperDoubleValue() const357   inline double upperDoubleValue() const
358   {
359      return upperDoubleValue_;
360   }
361   /// Returns the lower bound for an int-valued parameter
lowerIntValue() const362   inline int lowerIntValue() const
363   {
364      return lowerIntValue_;
365   }
366   /// Returns the upper bound for an int-valued parameter
upperIntValue() const367   inline int upperIntValue() const
368   {
369      return upperIntValue_;
370   }
371   /// Sets a double parameter (nonzero code if error)
372   int setDoubleParameter(CbcModel &model, double value);
373   /// Sets double parameter and returns printable string and error code
374   const char *setDoubleParameterWithMessage(CbcModel &model, double value, int &returnCode);
375   /// Gets a double parameter
376   double doubleParameter(CbcModel &model) const;
377   /// Sets a int parameter (nonzero code if error)
378   int setIntParameter(CbcModel &model, int value);
379   /// Sets int parameter and returns printable string and error code
380   const char *setIntParameterWithMessage(CbcModel &model, int value, int &returnCode);
381   /// Gets a int parameter
382   int intParameter(CbcModel &model) const;
383   /// Sets a double parameter (nonzero code if error)
384   int setDoubleParameter(ClpSimplex *model, double value);
385   /// Gets a double parameter
386   double doubleParameter(ClpSimplex *model) const;
387   /// Sets double parameter and returns printable string and error code
388   const char *setDoubleParameterWithMessage(ClpSimplex *model, double value, int &returnCode);
389   /// Sets a int parameter (nonzero code if error)
390   int setIntParameter(ClpSimplex *model, int value);
391   /// Sets int parameter and returns printable string and error code
392   const char *setIntParameterWithMessage(ClpSimplex *model, int value, int &returnCode);
393   /// Gets a int parameter
394   int intParameter(ClpSimplex *model) const;
395   /// Sets a double parameter (nonzero code if error)
396   int setDoubleParameter(OsiSolverInterface *model, double value);
397   /// Sets double parameter and returns printable string and error code
398   const char *setDoubleParameterWithMessage(OsiSolverInterface *model, double value, int &returnCode);
399   /// Gets a double parameter
400   double doubleParameter(OsiSolverInterface *model) const;
401   /// Sets a int parameter (nonzero code if error)
402   int setIntParameter(OsiSolverInterface *model, int value);
403   /// Sets int parameter and returns printable string and error code
404   const char *setIntParameterWithMessage(OsiSolverInterface *model, int value, int &returnCode);
405   /// Gets a int parameter
406   int intParameter(OsiSolverInterface *model) const;
407   /// Checks a double parameter (nonzero code if error)
408   int checkDoubleParameter(double value) const;
409   /// Returns name which could match
410   std::string matchName() const;
411   /// Returns length of name for ptinting
412   int lengthMatchName() const;
413   /// Returns parameter option which matches (-1 if none)
414   int parameterOption(std::string check) const;
415   /// Prints parameter options
416   void printOptions() const;
417   /// Returns current parameter option
currentOption() const418   inline std::string currentOption() const
419   {
420     return definedKeyWords_[currentKeyWord_];
421   }
422   /// Sets current parameter option
423   void setCurrentOption(int value, bool printIt = false);
424   /// Sets current parameter option and returns printable string
425   const char *setCurrentOptionWithMessage(int value);
426   /// Sets current parameter option using string
427   void setCurrentOption(const std::string value);
428   /// Sets current parameter option using string with message
429   const char *setCurrentOptionWithMessage(const std::string value);
430   /// Returns current parameter option position
431   int currentOptionAsInteger() const;
432   /** Returns current parameter option position
433 	 but if fake keyword returns a fake value and sets
434 	 fakeInteger to true value.  If not fake then fakeInteger is -COIN_INT_MAX
435       */
436   int currentOptionAsInteger(int &fakeInteger) const;
437   /// Sets int value
438   void setIntValue(int value);
439   /// Sets int value with message
440   const char *setIntValueWithMessage(int value);
intValue() const441   inline int intValue() const
442   {
443     return intValue_;
444   }
445   /// Sets double value
446   void setDoubleValue(double value);
447   /// Sets double value with message
448   const char *setDoubleValueWithMessage(double value);
doubleValue() const449   inline double doubleValue() const
450   {
451     return doubleValue_;
452   }
453   /// Sets string value
454   void setStringValue(std::string value);
stringValue() const455   inline std::string stringValue() const
456   {
457     return stringValue_;
458   }
459   /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
460   int matches(std::string input) const;
461   /// type
type() const462   inline CbcOrClpParameterType type() const
463   {
464     return type_;
465   }
466   /// whether to display
displayThis() const467   inline int displayThis() const
468   {
469     return display_;
470   }
471   /// Set Long help
setLonghelp(const std::string help)472   inline void setLonghelp(const std::string help)
473   {
474     longHelp_ = help;
475   }
476   /// Print Long help
477   void printLongHelp() const;
478   /// Print action and string
479   void printString() const;
480   /** 7 if used everywhere,
481          1 - used by clp
482          2 - used by cbc
483          4 - used by ampl
484      */
whereUsed() const485   inline int whereUsed() const
486   {
487     return whereUsed_;
488   }
489   /// Gets value of fake keyword
fakeKeyWord() const490   inline int fakeKeyWord() const
491   {
492     return fakeKeyWord_;
493   }
494   /// Sets value of fake keyword
setFakeKeyWord(int value,int fakeValue)495   inline void setFakeKeyWord(int value, int fakeValue)
496   {
497     fakeKeyWord_ = value;
498     fakeValue_ = fakeValue;
499   }
500   /// Sets value of fake keyword to current size of keywords
501   void setFakeKeyWord(int fakeValue);
502 
503 private:
504   /// gutsOfConstructor
505   void gutsOfConstructor();
506   //@}
507   ////////////////// data //////////////////
508 private:
509   /**@name data
510       We might as well throw all type data in - could derive?
511      */
512   //@{
513   // Type see CbcOrClpParameterType
514   CbcOrClpParameterType type_;
515   /// If double == okay
516   double lowerDoubleValue_;
517   double upperDoubleValue_;
518   /// If int == okay
519   int lowerIntValue_;
520   int upperIntValue_;
521   // Length of name
522   unsigned int lengthName_;
523   // Minimum match
524   unsigned int lengthMatch_;
525   /// set of valid strings
526   std::vector< std::string > definedKeyWords_;
527   /// Name
528   std::string name_;
529   /// Short help
530   std::string shortHelp_;
531   /// Long help
532   std::string longHelp_;
533   /// Action
534   CbcOrClpParameterType action_;
535   /// Current keyWord (if a keyword parameter)
536   int currentKeyWord_;
537   /// Display on ?
538   int display_;
539   /// Integer parameter - current value
540   int intValue_;
541   /// Double parameter - current value
542   double doubleValue_;
543   /// String parameter - current value
544   std::string stringValue_;
545   /** 7 if used everywhere,
546          1 - used by clp
547          2 - used by cbc
548          4 - used by ampl
549      */
550   int whereUsed_;
551   /** If >=0 then integers allowed as a fake keyword
552 	 So minusnnnn would got to -nnnn in currentKeyword_
553 	 and plusnnnn would go to fakeKeyword_+nnnn
554      */
555   int fakeKeyWord_;
556   /// Return this as main value if an integer
557   int fakeValue_;
558   //@}
559 };
560 /// Simple read stuff
561 std::string CoinReadNextField();
562 
563 std::string CoinReadGetCommand(int argc, const char *argv[]);
564 std::string CoinReadGetString(int argc, const char *argv[]);
565 // valid 0 - okay, 1 bad, 2 not there
566 int CoinReadGetIntField(int argc, const char *argv[], int *valid);
567 double CoinReadGetDoubleField(int argc, const char *argv[], int *valid);
568 void CoinReadPrintit(const char *input);
569 void setCbcOrClpPrinting(bool yesNo);
570 #define CBCMAXPARAMETERS 250
571 /*
572   Subroutine to establish the cbc parameter array. See the description of
573   class CbcOrClpParam for details. Pulled from C..Main() for clarity.
574 */
575 void establishParams(std::vector< CbcOrClpParam > &params);
576 // Given a parameter type - returns its number in list
577 int whichParam(const CbcOrClpParameterType &name,
578   const std::vector< CbcOrClpParam > &parameters);
579 // Dump/restore a solution to file
580 void saveSolution(const ClpSimplex *lpSolver, std::string fileName);
581 void restoreSolution(ClpSimplex *lpSolver, std::string fileName, int mode);
582 #endif /* CbcOrClpParam_H */
583 
584 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
585 */
586