source: trunk/Clp/src/CbcOrClpParam.hpp @ 2470

Last change on this file since 2470 was 2459, checked in by stefan, 5 months ago

add getter for long help and bounds, update comment

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 17.2 KB
Line 
1
2/* $Id: CbcOrClpParam.hpp 2459 2019-04-25 09:57: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 */
27class OsiSolverInterface;
28class CbcModel;
29class 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
48enum 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
301class CbcOrClpParam {
302public:
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
332  inline std::string name() const
333  {
334    return name_;
335  }
336  /// Returns short help
337  inline std::string shortHelp() const
338  {
339    return shortHelp_;
340  }
341  /// Returns long help
342  inline std::string longHelp() const
343  {
344    return longHelp_;
345  }
346  /// Returns set of valid strings
347  inline const std::vector<std::string>& definedKeywords() const
348  {
349    return definedKeyWords_;
350  }
351  /// Returns the lower bound for a double-valued parameter
352  inline double lowerDoubleValue() const
353  {
354     return lowerDoubleValue_;
355  }
356  /// Returns the upper bound for a double-valued parameter
357  inline double upperDoubleValue() const
358  {
359     return upperDoubleValue_;
360  }
361  /// Returns the lower bound for an int-valued parameter
362  inline int lowerIntValue() const
363  {
364     return lowerIntValue_;
365  }
366  /// Returns the upper bound for an int-valued parameter
367  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
418  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);
441  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);
449  inline double doubleValue() const
450  {
451    return doubleValue_;
452  }
453  /// Sets string value
454  void setStringValue(std::string value);
455  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
462  inline CbcOrClpParameterType type() const
463  {
464    return type_;
465  }
466  /// whether to display
467  inline int displayThis() const
468  {
469    return display_;
470  }
471  /// Set Long 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     */
485  inline int whereUsed() const
486  {
487    return whereUsed_;
488  }
489  /// Gets value of fake keyword
490  inline int fakeKeyWord() const
491  {
492    return fakeKeyWord_;
493  }
494  /// Sets value of fake keyword
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
503private:
504  /// gutsOfConstructor
505  void gutsOfConstructor();
506  //@}
507  ////////////////// data //////////////////
508private:
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
561std::string CoinReadNextField();
562
563std::string CoinReadGetCommand(int argc, const char *argv[]);
564std::string CoinReadGetString(int argc, const char *argv[]);
565// valid 0 - okay, 1 bad, 2 not there
566int CoinReadGetIntField(int argc, const char *argv[], int *valid);
567double CoinReadGetDoubleField(int argc, const char *argv[], int *valid);
568void CoinReadPrintit(const char *input);
569void 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*/
575void establishParams(std::vector< CbcOrClpParam > &params);
576// Given a parameter type - returns its number in list
577int whichParam(const CbcOrClpParameterType &name,
578  const std::vector< CbcOrClpParam > &parameters);
579// Dump/restore a solution to file
580void saveSolution(const ClpSimplex *lpSolver, std::string fileName);
581void restoreSolution(ClpSimplex *lpSolver, std::string fileName, int mode);
582#endif /* CbcOrClpParam_H */
583
584/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
585*/
Note: See TracBrowser for help on using the repository browser.