casadi 3.6.3__cp35-none-manylinux2010_x86_64.whl → 3.6.5__cp35-none-manylinux2010_x86_64.whl

casadi/include/coin/CbcOrClpParam.hpp

@@ -0,0 +1,585 @@
+
+/* $Id$ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifdef USE_CBCCONFIG
+#include "CbcConfig.h"
+#else
+#include "ClpConfig.h"
+#endif
+
+#ifndef CbcOrClpParam_H
+#define CbcOrClpParam_H
+/**
+   This has parameter handling stuff which can be shared between Cbc and Clp (and Dylp etc).
+
+   This (and .cpp) should be copied so that it is the same in Cbc/Test and Clp/Test.
+   I know this is not elegant but it seems simplest.
+
+   It uses COIN_HAS_CBC for parameters wanted by CBC
+   It uses COIN_HAS_CLP for parameters wanted by CLP (or CBC using CLP)
+   It could use COIN_HAS_DYLP for parameters wanted by DYLP
+   It could use COIN_HAS_DYLP_OR_CLP for parameters wanted by DYLP or CLP etc etc
+
+ */
+class OsiSolverInterface;
+class CbcModel;
+class ClpSimplex;
+/*! \brief Parameter codes
+
+  Parameter type ranges are allocated as follows
+  <ul>
+    <li>   1 -- 100  double parameters
+    <li> 101 -- 200  integer parameters
+    <li> 201 -- 300  Clp string parameters
+    <li> 301 -- 400  Cbc string parameters
+    <li> 401 -- 500  (mostly) Clp actions
+    <li> 501 -- 600  (mostly) Cbc actions
+  </ul>
+
+  `Actions' do not necessarily invoke an immediate action; it's just that they
+  don't fit neatly into the parameters array.
+
+  This coding scheme is in flux.
+*/
+
+enum CbcOrClpParameterType
+
+{
+  CBC_PARAM_GENERALQUERY = -100,
+  CBC_PARAM_FULLGENERALQUERY,
+
+  CLP_PARAM_DBL_PRIMALTOLERANCE = 1,
+  CLP_PARAM_DBL_DUALTOLERANCE,
+  CLP_PARAM_DBL_TIMELIMIT,
+  CLP_PARAM_DBL_DUALBOUND,
+  CLP_PARAM_DBL_PRIMALWEIGHT,
+  CLP_PARAM_DBL_OBJSCALE,
+  CLP_PARAM_DBL_RHSSCALE,
+  CLP_PARAM_DBL_ZEROTOLERANCE,
+  CLP_PARAM_DBL_PSI,
+
+  CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
+  CBC_PARAM_DBL_CUTOFF,
+  CBC_PARAM_DBL_INTEGERTOLERANCE,
+  CBC_PARAM_DBL_INCREMENT,
+  CBC_PARAM_DBL_ALLOWABLEGAP,
+  CBC_PARAM_DBL_TIMELIMIT_BAB,
+  CBC_PARAM_DBL_GAPRATIO,
+
+  CBC_PARAM_DBL_DJFIX = 81,
+  CBC_PARAM_DBL_TIGHTENFACTOR,
+  CLP_PARAM_DBL_PRESOLVETOLERANCE,
+  CLP_PARAM_DBL_OBJSCALE2,
+  CBC_PARAM_DBL_FAKEINCREMENT,
+  CBC_PARAM_DBL_FAKECUTOFF,
+  CBC_PARAM_DBL_ARTIFICIALCOST,
+  CBC_PARAM_DBL_DEXTRA3,
+  CBC_PARAM_DBL_SMALLBAB,
+  CBC_PARAM_DBL_DEXTRA4,
+  CBC_PARAM_DBL_DEXTRA5,
+
+  CLP_PARAM_INT_SOLVERLOGLEVEL = 101,
+#ifndef COIN_HAS_CBC
+  CLP_PARAM_INT_LOGLEVEL = 101,
+#endif
+  CLP_PARAM_INT_MAXFACTOR,
+  CLP_PARAM_INT_PERTVALUE,
+  CLP_PARAM_INT_MAXITERATION,
+  CLP_PARAM_INT_PRESOLVEPASS,
+  CLP_PARAM_INT_IDIOT,
+  CLP_PARAM_INT_SPRINT,
+  CLP_PARAM_INT_OUTPUTFORMAT,
+  CLP_PARAM_INT_SLPVALUE,
+  CLP_PARAM_INT_PRESOLVEOPTIONS,
+  CLP_PARAM_INT_PRINTOPTIONS,
+  CLP_PARAM_INT_SPECIALOPTIONS,
+  CLP_PARAM_INT_SUBSTITUTION,
+  CLP_PARAM_INT_DUALIZE,
+  CLP_PARAM_INT_VERBOSE,
+  CLP_PARAM_INT_CPP,
+  CLP_PARAM_INT_PROCESSTUNE,
+  CLP_PARAM_INT_USESOLUTION,
+  CLP_PARAM_INT_RANDOMSEED,
+  CLP_PARAM_INT_MORESPECIALOPTIONS,
+  CLP_PARAM_INT_DECOMPOSE_BLOCKS,
+  CLP_PARAM_INT_VECTOR_MODE,
+
+  CBC_PARAM_INT_STRONGBRANCHING = 151,
+  CBC_PARAM_INT_CUTDEPTH,
+  CBC_PARAM_INT_MAXNODES,
+  CBC_PARAM_INT_NUMBERBEFORE,
+  CBC_PARAM_INT_NUMBERANALYZE,
+  CBC_PARAM_INT_MIPOPTIONS,
+  CBC_PARAM_INT_MOREMIPOPTIONS,
+  CBC_PARAM_INT_MAXHOTITS,
+  CBC_PARAM_INT_FPUMPITS,
+  CBC_PARAM_INT_MAXSOLS,
+  CBC_PARAM_INT_FPUMPTUNE,
+  CBC_PARAM_INT_TESTOSI,
+  CBC_PARAM_INT_EXTRA1,
+  CBC_PARAM_INT_EXTRA2,
+  CBC_PARAM_INT_EXTRA3,
+  CBC_PARAM_INT_EXTRA4,
+  CBC_PARAM_INT_DEPTHMINIBAB,
+  CBC_PARAM_INT_CUTPASSINTREE,
+  CBC_PARAM_INT_THREADS,
+  CBC_PARAM_INT_CUTPASS,
+  CBC_PARAM_INT_VUBTRY,
+  CBC_PARAM_INT_DENSE,
+  CBC_PARAM_INT_EXPERIMENT,
+  CBC_PARAM_INT_DIVEOPT,
+  CBC_PARAM_INT_DIVEOPTSOLVES,
+  CBC_PARAM_INT_STRATEGY,
+  CBC_PARAM_INT_SMALLFACT,
+  CBC_PARAM_INT_HOPTIONS,
+  CBC_PARAM_INT_CUTLENGTH,
+  CBC_PARAM_INT_FPUMPTUNE2,
+#ifdef COIN_HAS_CBC
+  CLP_PARAM_INT_LOGLEVEL,
+#endif
+  CBC_PARAM_INT_MAXSAVEDSOLS,
+  CBC_PARAM_INT_RANDOMSEED,
+  CBC_PARAM_INT_MULTIPLEROOTS,
+  CBC_PARAM_INT_STRONG_STRATEGY,
+  CBC_PARAM_INT_EXTRA_VARIABLES,
+  CBC_PARAM_INT_MAX_SLOW_CUTS,
+  CBC_PARAM_INT_MOREMOREMIPOPTIONS,
+
+  CLP_PARAM_STR_DIRECTION = 201,
+  CLP_PARAM_STR_DUALPIVOT,
+  CLP_PARAM_STR_SCALING,
+  CLP_PARAM_STR_ERRORSALLOWED,
+  CLP_PARAM_STR_KEEPNAMES,
+  CLP_PARAM_STR_SPARSEFACTOR,
+  CLP_PARAM_STR_PRIMALPIVOT,
+  CLP_PARAM_STR_PRESOLVE,
+  CLP_PARAM_STR_CRASH,
+  CLP_PARAM_STR_BIASLU,
+  CLP_PARAM_STR_PERTURBATION,
+  CLP_PARAM_STR_MESSAGES,
+  CLP_PARAM_STR_AUTOSCALE,
+  CLP_PARAM_STR_CHOLESKY,
+  CLP_PARAM_STR_KKT,
+  CLP_PARAM_STR_BARRIERSCALE,
+  CLP_PARAM_STR_GAMMA,
+  CLP_PARAM_STR_CROSSOVER,
+  CLP_PARAM_STR_PFI,
+  CLP_PARAM_STR_INTPRINT,
+  CLP_PARAM_STR_VECTOR,
+  CLP_PARAM_STR_FACTORIZATION,
+  CLP_PARAM_STR_ALLCOMMANDS,
+  CLP_PARAM_STR_TIME_MODE,
+  CLP_PARAM_STR_ABCWANTED,
+  CLP_PARAM_STR_BUFFER_MODE,
+
+  CBC_PARAM_STR_NODESTRATEGY = 301,
+  CBC_PARAM_STR_BRANCHSTRATEGY,
+  CBC_PARAM_STR_CUTSSTRATEGY,
+  CBC_PARAM_STR_HEURISTICSTRATEGY,
+  CBC_PARAM_STR_GOMORYCUTS,
+  CBC_PARAM_STR_PROBINGCUTS,
+  CBC_PARAM_STR_KNAPSACKCUTS,
+  CBC_PARAM_STR_REDSPLITCUTS,
+  CBC_PARAM_STR_ROUNDING,
+  CBC_PARAM_STR_SOLVER,
+  CBC_PARAM_STR_CLIQUECUTS,
+  CBC_PARAM_STR_COSTSTRATEGY,
+  CBC_PARAM_STR_FLOWCUTS,
+  CBC_PARAM_STR_MIXEDCUTS,
+  CBC_PARAM_STR_TWOMIRCUTS,
+  CBC_PARAM_STR_PREPROCESS,
+  CBC_PARAM_STR_FPUMP,
+  CBC_PARAM_STR_GREEDY,
+  CBC_PARAM_STR_COMBINE,
+  CBC_PARAM_STR_PROXIMITY,
+  CBC_PARAM_STR_LOCALTREE,
+  CBC_PARAM_STR_SOS,
+  CBC_PARAM_STR_LANDPCUTS,
+  CBC_PARAM_STR_RINS,
+  CBC_PARAM_STR_RESIDCUTS,
+  CBC_PARAM_STR_RENS,
+  CBC_PARAM_STR_DIVINGS,
+  CBC_PARAM_STR_DIVINGC,
+  CBC_PARAM_STR_DIVINGF,
+  CBC_PARAM_STR_DIVINGG,
+  CBC_PARAM_STR_DIVINGL,
+  CBC_PARAM_STR_DIVINGP,
+  CBC_PARAM_STR_DIVINGV,
+  CBC_PARAM_STR_DINS,
+  CBC_PARAM_STR_PIVOTANDFIX,
+  CBC_PARAM_STR_RANDROUND,
+  CBC_PARAM_STR_NAIVE,
+  CBC_PARAM_STR_ZEROHALFCUTS,
+  CBC_PARAM_STR_CPX,
+  CBC_PARAM_STR_CROSSOVER2,
+  CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
+  CBC_PARAM_STR_VND,
+  CBC_PARAM_STR_LAGOMORYCUTS,
+  CBC_PARAM_STR_LATWOMIRCUTS,
+  CBC_PARAM_STR_REDSPLIT2CUTS,
+  CBC_PARAM_STR_GMICUTS,
+  CBC_PARAM_STR_CUTOFF_CONSTRAINT,
+  CBC_PARAM_STR_DW,
+  CBC_PARAM_STR_ORBITAL,
+  CBC_PARAM_STR_PREPROCNAMES,
+  CBC_PARAM_STR_SOSPRIORITIZE,
+
+  CLP_PARAM_ACTION_DIRECTORY = 401,
+  CLP_PARAM_ACTION_DIRSAMPLE,
+  CLP_PARAM_ACTION_DIRNETLIB,
+  CBC_PARAM_ACTION_DIRMIPLIB,
+  CLP_PARAM_ACTION_IMPORT,
+  CLP_PARAM_ACTION_EXPORT,
+  CLP_PARAM_ACTION_RESTORE,
+  CLP_PARAM_ACTION_SAVE,
+  CLP_PARAM_ACTION_DUALSIMPLEX,
+  CLP_PARAM_ACTION_PRIMALSIMPLEX,
+  CLP_PARAM_ACTION_EITHERSIMPLEX,
+  CLP_PARAM_ACTION_MAXIMIZE,
+  CLP_PARAM_ACTION_MINIMIZE,
+  CLP_PARAM_ACTION_EXIT,
+  CLP_PARAM_ACTION_STDIN,
+  CLP_PARAM_ACTION_UNITTEST,
+  CLP_PARAM_ACTION_NETLIB_EITHER,
+  CLP_PARAM_ACTION_NETLIB_DUAL,
+  CLP_PARAM_ACTION_NETLIB_PRIMAL,
+  CLP_PARAM_ACTION_SOLUTION,
+  CLP_PARAM_ACTION_SAVESOL,
+  CLP_PARAM_ACTION_TIGHTEN,
+  CLP_PARAM_ACTION_FAKEBOUND,
+  CLP_PARAM_ACTION_HELP,
+  CLP_PARAM_ACTION_PLUSMINUS,
+  CLP_PARAM_ACTION_NETWORK,
+  CLP_PARAM_ACTION_ALLSLACK,
+  CLP_PARAM_ACTION_REVERSE,
+  CLP_PARAM_ACTION_BARRIER,
+  CLP_PARAM_ACTION_NETLIB_BARRIER,
+  CLP_PARAM_ACTION_NETLIB_TUNE,
+  CLP_PARAM_ACTION_REALLY_SCALE,
+  CLP_PARAM_ACTION_BASISIN,
+  CLP_PARAM_ACTION_BASISOUT,
+  CLP_PARAM_ACTION_SOLVECONTINUOUS,
+  CLP_PARAM_ACTION_CLEARCUTS,
+  CLP_PARAM_ACTION_VERSION,
+  CLP_PARAM_ACTION_STATISTICS,
+  CLP_PARAM_ACTION_DEBUG,
+  CLP_PARAM_ACTION_DUMMY,
+  CLP_PARAM_ACTION_PRINTMASK,
+  CLP_PARAM_ACTION_OUTDUPROWS,
+  CLP_PARAM_ACTION_USERCLP,
+  CLP_PARAM_ACTION_MODELIN,
+  CLP_PARAM_ACTION_CSVSTATISTICS,
+  CLP_PARAM_ACTION_STOREDFILE,
+  CLP_PARAM_ACTION_ENVIRONMENT,
+  CLP_PARAM_ACTION_PARAMETRICS,
+  CLP_PARAM_ACTION_GMPL_SOLUTION,
+  CLP_PARAM_ACTION_RESTORESOL,
+  CLP_PARAM_ACTION_GUESS,
+
+  CBC_PARAM_ACTION_BAB = 501,
+  CBC_PARAM_ACTION_MIPLIB,
+  CBC_PARAM_ACTION_STRENGTHEN,
+  CBC_PARAM_ACTION_PRIORITYIN,
+  CBC_PARAM_ACTION_MIPSTART,
+  CBC_PARAM_ACTION_USERCBC,
+  CBC_PARAM_ACTION_DOHEURISTIC,
+  CLP_PARAM_ACTION_NEXTBESTSOLUTION,
+
+  CBC_PARAM_NOTUSED_OSLSTUFF = 601,
+  CBC_PARAM_NOTUSED_CBCSTUFF,
+
+  CBC_PARAM_NOTUSED_INVALID = 1000
+};
+#include <vector>
+#include <string>
+
+/// Very simple class for setting parameters
+
+class CbcOrClpParam {
+public:
+  /**@name Constructor and destructor */
+  //@{
+  /// Constructors
+  CbcOrClpParam();
+  CbcOrClpParam(std::string name, std::string help,
+    double lower, double upper, CbcOrClpParameterType type, int display = 2);
+  CbcOrClpParam(std::string name, std::string help,
+    int lower, int upper, CbcOrClpParameterType type, int display = 2);
+  // Other strings will be added by insert
+  CbcOrClpParam(std::string name, std::string help, std::string firstValue,
+    CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
+  // Action
+  CbcOrClpParam(std::string name, std::string help,
+    CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
+  /// Copy constructor.
+  CbcOrClpParam(const CbcOrClpParam &);
+  /// Assignment operator. This copies the data
+  CbcOrClpParam &operator=(const CbcOrClpParam &rhs);
+  /// Destructor
+  ~CbcOrClpParam();
+  //@}
+
+  /**@name stuff */
+  //@{
+  /// Insert string (only valid for keywords)
+  void append(std::string keyWord);
+  /// Adds one help line
+  void addHelp(std::string keyWord);
+  /// Returns name
+  inline std::string name() const
+  {
+    return name_;
+  }
+  /// Returns short help
+  inline std::string shortHelp() const
+  {
+    return shortHelp_;
+  }
+  /// Returns long help
+  inline std::string longHelp() const
+  {
+    return longHelp_;
+  }
+  /// Returns set of valid strings
+  inline const std::vector<std::string>& definedKeywords() const
+  {
+    return definedKeyWords_;
+  }
+  /// Returns the lower bound for a double-valued parameter
+  inline double lowerDoubleValue() const
+  {
+     return lowerDoubleValue_;
+  }
+  /// Returns the upper bound for a double-valued parameter
+  inline double upperDoubleValue() const
+  {
+     return upperDoubleValue_;
+  }
+  /// Returns the lower bound for an int-valued parameter
+  inline int lowerIntValue() const
+  {
+     return lowerIntValue_;
+  }
+  /// Returns the upper bound for an int-valued parameter
+  inline int upperIntValue() const
+  {
+     return upperIntValue_;
+  }
+  /// Sets a double parameter (nonzero code if error)
+  int setDoubleParameter(CbcModel &model, double value);
+  /// Sets double parameter and returns printable string and error code
+  const char *setDoubleParameterWithMessage(CbcModel &model, double value, int &returnCode);
+  /// Gets a double parameter
+  double doubleParameter(CbcModel &model) const;
+  /// Sets a int parameter (nonzero code if error)
+  int setIntParameter(CbcModel &model, int value);
+  /// Sets int parameter and returns printable string and error code
+  const char *setIntParameterWithMessage(CbcModel &model, int value, int &returnCode);
+  /// Gets a int parameter
+  int intParameter(CbcModel &model) const;
+  /// Sets a double parameter (nonzero code if error)
+  int setDoubleParameter(ClpSimplex *model, double value);
+  /// Gets a double parameter
+  double doubleParameter(ClpSimplex *model) const;
+  /// Sets double parameter and returns printable string and error code
+  const char *setDoubleParameterWithMessage(ClpSimplex *model, double value, int &returnCode);
+  /// Sets a int parameter (nonzero code if error)
+  int setIntParameter(ClpSimplex *model, int value);
+  /// Sets int parameter and returns printable string and error code
+  const char *setIntParameterWithMessage(ClpSimplex *model, int value, int &returnCode);
+  /// Gets a int parameter
+  int intParameter(ClpSimplex *model) const;
+  /// Sets a double parameter (nonzero code if error)
+  int setDoubleParameter(OsiSolverInterface *model, double value);
+  /// Sets double parameter and returns printable string and error code
+  const char *setDoubleParameterWithMessage(OsiSolverInterface *model, double value, int &returnCode);
+  /// Gets a double parameter
+  double doubleParameter(OsiSolverInterface *model) const;
+  /// Sets a int parameter (nonzero code if error)
+  int setIntParameter(OsiSolverInterface *model, int value);
+  /// Sets int parameter and returns printable string and error code
+  const char *setIntParameterWithMessage(OsiSolverInterface *model, int value, int &returnCode);
+  /// Gets a int parameter
+  int intParameter(OsiSolverInterface *model) const;
+  /// Checks a double parameter (nonzero code if error)
+  int checkDoubleParameter(double value) const;
+  /// Returns name which could match
+  std::string matchName() const;
+  /// Returns length of name for ptinting
+  int lengthMatchName() const;
+  /// Returns parameter option which matches (-1 if none)
+  int parameterOption(std::string check) const;
+  /// Prints parameter options
+  void printOptions() const;
+  /// Returns current parameter option
+  inline std::string currentOption() const
+  {
+    return definedKeyWords_[currentKeyWord_];
+  }
+  /// Sets current parameter option
+  void setCurrentOption(int value, bool printIt = false);
+  /// Sets current parameter option and returns printable string
+  const char *setCurrentOptionWithMessage(int value);
+  /// Sets current parameter option using string
+  void setCurrentOption(const std::string value);
+  /// Sets current parameter option using string with message
+  const char *setCurrentOptionWithMessage(const std::string value);
+  /// Returns current parameter option position
+  int currentOptionAsInteger() const;
+  /** Returns current parameter option position
+	 but if fake keyword returns a fake value and sets
+	 fakeInteger to true value.  If not fake then fakeInteger is -COIN_INT_MAX
+      */
+  int currentOptionAsInteger(int &fakeInteger) const;
+  /// Sets int value
+  void setIntValue(int value);
+  /// Sets int value with message
+  const char *setIntValueWithMessage(int value);
+  inline int intValue() const
+  {
+    return intValue_;
+  }
+  /// Sets double value
+  void setDoubleValue(double value);
+  /// Sets double value with message
+  const char *setDoubleValueWithMessage(double value);
+  inline double doubleValue() const
+  {
+    return doubleValue_;
+  }
+  /// Sets string value
+  void setStringValue(std::string value);
+  inline std::string stringValue() const
+  {
+    return stringValue_;
+  }
+  /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
+  int matches(std::string input) const;
+  /// type
+  inline CbcOrClpParameterType type() const
+  {
+    return type_;
+  }
+  /// whether to display
+  inline int displayThis() const
+  {
+    return display_;
+  }
+  /// Set Long help
+  inline void setLonghelp(const std::string help)
+  {
+    longHelp_ = help;
+  }
+  /// Print Long help
+  void printLongHelp() const;
+  /// Print action and string
+  void printString() const;
+  /** 7 if used everywhere,
+         1 - used by clp
+         2 - used by cbc
+         4 - used by ampl
+     */
+  inline int whereUsed() const
+  {
+    return whereUsed_;
+  }
+  /// Gets value of fake keyword
+  inline int fakeKeyWord() const
+  {
+    return fakeKeyWord_;
+  }
+  /// Sets value of fake keyword
+  inline void setFakeKeyWord(int value, int fakeValue)
+  {
+    fakeKeyWord_ = value;
+    fakeValue_ = fakeValue;
+  }
+  /// Sets value of fake keyword to current size of keywords
+  void setFakeKeyWord(int fakeValue);
+
+private:
+  /// gutsOfConstructor
+  void gutsOfConstructor();
+  //@}
+  ////////////////// data //////////////////
+private:
+  /**@name data
+      We might as well throw all type data in - could derive?
+     */
+  //@{
+  // Type see CbcOrClpParameterType
+  CbcOrClpParameterType type_;
+  /// If double == okay
+  double lowerDoubleValue_;
+  double upperDoubleValue_;
+  /// If int == okay
+  int lowerIntValue_;
+  int upperIntValue_;
+  // Length of name
+  unsigned int lengthName_;
+  // Minimum match
+  unsigned int lengthMatch_;
+  /// set of valid strings
+  std::vector< std::string > definedKeyWords_;
+  /// Name
+  std::string name_;
+  /// Short help
+  std::string shortHelp_;
+  /// Long help
+  std::string longHelp_;
+  /// Action
+  CbcOrClpParameterType action_;
+  /// Current keyWord (if a keyword parameter)
+  int currentKeyWord_;
+  /// Display on ?
+  int display_;
+  /// Integer parameter - current value
+  int intValue_;
+  /// Double parameter - current value
+  double doubleValue_;
+  /// String parameter - current value
+  std::string stringValue_;
+  /** 7 if used everywhere,
+         1 - used by clp
+         2 - used by cbc
+         4 - used by ampl
+     */
+  int whereUsed_;
+  /** If >=0 then integers allowed as a fake keyword
+	 So minusnnnn would got to -nnnn in currentKeyword_
+	 and plusnnnn would go to fakeKeyword_+nnnn
+     */
+  int fakeKeyWord_;
+  /// Return this as main value if an integer
+  int fakeValue_;
+  //@}
+};
+/// Simple read stuff
+std::string CoinReadNextField();
+
+std::string CoinReadGetCommand(int argc, const char *argv[]);
+std::string CoinReadGetString(int argc, const char *argv[]);
+// valid 0 - okay, 1 bad, 2 not there
+int CoinReadGetIntField(int argc, const char *argv[], int *valid);
+double CoinReadGetDoubleField(int argc, const char *argv[], int *valid);
+void CoinReadPrintit(const char *input);
+void setCbcOrClpPrinting(bool yesNo);
+#define CBCMAXPARAMETERS 250
+/*
+  Subroutine to establish the cbc parameter array. See the description of
+  class CbcOrClpParam for details. Pulled from C..Main() for clarity.
+*/
+void establishParams(std::vector< CbcOrClpParam > &params);
+// Given a parameter type - returns its number in list
+int whichParam(const CbcOrClpParameterType &name,
+  const std::vector< CbcOrClpParam > &parameters);
+// Dump/restore a solution to file
+void saveSolution(const ClpSimplex *lpSolver, std::string fileName);
+void restoreSolution(ClpSimplex *lpSolver, std::string fileName, int mode);
+#endif /* CbcOrClpParam_H */
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/