ruby-cbc 0.1.9

data/ext/ruby-cbc/install/include/coin/CbcOrClpParam.cpp

@@ -0,0 +1,4134 @@
+/* $Id: CbcOrClpParam.cpp 2175 2015-10-06 08:56:43Z forrest $ */
+// 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).
+
+#include "CoinPragma.hpp"
+#include "CoinTime.hpp"
+#include "CbcOrClpParam.hpp"
+
+#include <string>
+#include <iostream>
+#include <cassert>
+
+#ifdef COIN_HAS_CBC
+#ifdef COIN_HAS_CLP
+#include "OsiClpSolverInterface.hpp"
+#include "ClpSimplex.hpp"
+#endif
+#include "CbcModel.hpp"
+#endif
+#include "CoinHelperFunctions.hpp"
+#ifdef COIN_HAS_CLP
+#include "ClpSimplex.hpp"
+#include "ClpFactorization.hpp"
+#endif
+#ifdef COIN_HAS_READLINE
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+#ifdef COIN_HAS_CBC
+// from CoinSolve
+static char coin_prompt[] = "Coin:";
+#else
+static char coin_prompt[] = "Clp:";
+#endif
+#ifdef CLP_CILK
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
+#endif
+#if defined(COIN_HAS_WSMP) && ! defined(USE_EKKWSSMP)
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
+#endif
+#include "ClpConfig.h"
+#ifdef CLP_HAS_ABC
+#include "AbcCommon.hpp"
+#endif
+static bool doPrinting = true;
+static std::string afterEquals = "";
+static char printArray[200];
+#if COIN_INT_MAX==0
+#undef COIN_INT_MAX
+#define COIN_INT_MAX 2147483647
+#endif
+#if FLUSH_PRINT_BUFFER > 2
+int coinFlushBufferFlag=0;
+#endif
+void setCbcOrClpPrinting(bool yesNo)
+{
+     doPrinting = yesNo;
+}
+//#############################################################################
+// Constructors / Destructor / Assignment
+//#############################################################################
+
+//-------------------------------------------------------------------
+// Default Constructor
+//-------------------------------------------------------------------
+CbcOrClpParam::CbcOrClpParam ()
+     : type_(CBC_PARAM_NOTUSED_INVALID),
+       lowerDoubleValue_(0.0),
+       upperDoubleValue_(0.0),
+       lowerIntValue_(0),
+       upperIntValue_(0),
+       lengthName_(0),
+       lengthMatch_(0),
+       definedKeyWords_(),
+       name_(),
+       shortHelp_(),
+       longHelp_(),
+       action_(CBC_PARAM_NOTUSED_INVALID),
+       currentKeyWord_(-1),
+       display_(0),
+       intValue_(-1),
+       doubleValue_(-1.0),
+       stringValue_(""),
+       whereUsed_(7),
+       fakeKeyWord_(-1),
+       fakeValue_(0)
+{
+}
+// Other constructors
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+                              double lower, double upper, CbcOrClpParameterType type,
+                              int display)
+     : type_(type),
+       lowerIntValue_(0),
+       upperIntValue_(0),
+       definedKeyWords_(),
+       name_(name),
+       shortHelp_(help),
+       longHelp_(),
+       action_(type),
+       currentKeyWord_(-1),
+       display_(display),
+       intValue_(-1),
+       doubleValue_(-1.0),
+       stringValue_(""),
+       whereUsed_(7),
+       fakeKeyWord_(-1),
+       fakeValue_(0)
+{
+     lowerDoubleValue_ = lower;
+     upperDoubleValue_ = upper;
+     gutsOfConstructor();
+}
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+                              int lower, int upper, CbcOrClpParameterType type,
+                              int display)
+     : type_(type),
+       lowerDoubleValue_(0.0),
+       upperDoubleValue_(0.0),
+       definedKeyWords_(),
+       name_(name),
+       shortHelp_(help),
+       longHelp_(),
+       action_(type),
+       currentKeyWord_(-1),
+       display_(display),
+       intValue_(-1),
+       doubleValue_(-1.0),
+       stringValue_(""),
+       whereUsed_(7),
+       fakeKeyWord_(-1),
+       fakeValue_(0)
+{
+     gutsOfConstructor();
+     lowerIntValue_ = lower;
+     upperIntValue_ = upper;
+}
+// Other strings will be added by append
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+                              std::string firstValue,
+                              CbcOrClpParameterType type, int whereUsed,
+                              int display)
+     : type_(type),
+       lowerDoubleValue_(0.0),
+       upperDoubleValue_(0.0),
+       lowerIntValue_(0),
+       upperIntValue_(0),
+       definedKeyWords_(),
+       name_(name),
+       shortHelp_(help),
+       longHelp_(),
+       action_(type),
+       currentKeyWord_(0),
+       display_(display),
+       intValue_(-1),
+       doubleValue_(-1.0),
+       stringValue_(""),
+       whereUsed_(whereUsed),
+       fakeKeyWord_(-1),
+       fakeValue_(0)
+{
+     gutsOfConstructor();
+     definedKeyWords_.push_back(firstValue);
+}
+// Action
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+                              CbcOrClpParameterType type, int whereUsed,
+                              int display)
+     : type_(type),
+       lowerDoubleValue_(0.0),
+       upperDoubleValue_(0.0),
+       lowerIntValue_(0),
+       upperIntValue_(0),
+       definedKeyWords_(),
+       name_(name),
+       shortHelp_(help),
+       longHelp_(),
+       action_(type),
+       currentKeyWord_(-1),
+       display_(display),
+       intValue_(-1),
+       doubleValue_(-1.0),
+       stringValue_(""),
+       fakeKeyWord_(-1),
+       fakeValue_(0)
+{
+     whereUsed_ = whereUsed;
+     gutsOfConstructor();
+}
+
+//-------------------------------------------------------------------
+// Copy constructor
+//-------------------------------------------------------------------
+CbcOrClpParam::CbcOrClpParam (const CbcOrClpParam & rhs)
+{
+     type_ = rhs.type_;
+     lowerDoubleValue_ = rhs.lowerDoubleValue_;
+     upperDoubleValue_ = rhs.upperDoubleValue_;
+     lowerIntValue_ = rhs.lowerIntValue_;
+     upperIntValue_ = rhs.upperIntValue_;
+     lengthName_ = rhs.lengthName_;
+     lengthMatch_ = rhs.lengthMatch_;
+     definedKeyWords_ = rhs.definedKeyWords_;
+     name_ = rhs.name_;
+     shortHelp_ = rhs.shortHelp_;
+     longHelp_ = rhs.longHelp_;
+     action_ = rhs.action_;
+     currentKeyWord_ = rhs.currentKeyWord_;
+     display_ = rhs.display_;
+     intValue_ = rhs.intValue_;
+     doubleValue_ = rhs.doubleValue_;
+     stringValue_ = rhs.stringValue_;
+     whereUsed_ = rhs.whereUsed_;
+     fakeKeyWord_ = rhs.fakeKeyWord_;
+     fakeValue_ = rhs.fakeValue_;
+}
+
+//-------------------------------------------------------------------
+// Destructor
+//-------------------------------------------------------------------
+CbcOrClpParam::~CbcOrClpParam ()
+{
+}
+
+//----------------------------------------------------------------
+// Assignment operator
+//-------------------------------------------------------------------
+CbcOrClpParam &
+CbcOrClpParam::operator=(const CbcOrClpParam & rhs)
+{
+     if (this != &rhs) {
+          type_ = rhs.type_;
+          lowerDoubleValue_ = rhs.lowerDoubleValue_;
+          upperDoubleValue_ = rhs.upperDoubleValue_;
+          lowerIntValue_ = rhs.lowerIntValue_;
+          upperIntValue_ = rhs.upperIntValue_;
+          lengthName_ = rhs.lengthName_;
+          lengthMatch_ = rhs.lengthMatch_;
+          definedKeyWords_ = rhs.definedKeyWords_;
+          name_ = rhs.name_;
+          shortHelp_ = rhs.shortHelp_;
+          longHelp_ = rhs.longHelp_;
+          action_ = rhs.action_;
+          currentKeyWord_ = rhs.currentKeyWord_;
+          display_ = rhs.display_;
+          intValue_ = rhs.intValue_;
+          doubleValue_ = rhs.doubleValue_;
+          stringValue_ = rhs.stringValue_;
+          whereUsed_ = rhs.whereUsed_;
+	  fakeKeyWord_ = rhs.fakeKeyWord_;
+	  fakeValue_ = rhs.fakeValue_;
+     }
+     return *this;
+}
+void
+CbcOrClpParam::gutsOfConstructor()
+{
+     std::string::size_type  shriekPos = name_.find('!');
+     lengthName_ = static_cast<unsigned int>(name_.length());
+     if ( shriekPos == std::string::npos ) {
+          //does not contain '!'
+          lengthMatch_ = lengthName_;
+     } else {
+          lengthMatch_ = static_cast<unsigned int>(shriekPos);
+          name_ = name_.substr(0, shriekPos) + name_.substr(shriekPos + 1);
+          lengthName_--;
+     }
+}
+// Sets value of fake keyword to current size of keywords 
+void 
+CbcOrClpParam::setFakeKeyWord(int fakeValue)
+{
+  fakeKeyWord_ = static_cast<int>(definedKeyWords_.size());
+  assert (fakeKeyWord_>0);
+  fakeValue_ = fakeValue;
+  assert (fakeValue_>=0);
+}
+/* Returns current parameter option position
+   but if fake keyword returns fakeValue_
+*/
+int 
+CbcOrClpParam::currentOptionAsInteger (  ) const
+{
+  int fakeInteger;
+  return currentOptionAsInteger(fakeInteger);
+}
+/* Returns current parameter option position
+   but if fake keyword returns fakeValue_ and sets
+   fakeInteger to value
+*/
+int 
+CbcOrClpParam::currentOptionAsInteger ( int & fakeInteger ) const
+{
+  fakeInteger=-COIN_INT_MAX;
+  if (fakeKeyWord_<0) {
+    return currentKeyWord_;
+  } else if (currentKeyWord_>=0&&currentKeyWord_<fakeKeyWord_){
+    return currentKeyWord_;
+  } else {
+    // fake
+    if (currentKeyWord_<0)
+      fakeInteger = currentKeyWord_ + 1000;
+    else
+      fakeInteger = currentKeyWord_ - 1000;
+    return fakeValue_;
+  }
+}
+// Returns length of name for printing
+int
+CbcOrClpParam::lengthMatchName (  ) const
+{
+     if (lengthName_ == lengthMatch_)
+          return lengthName_;
+     else
+          return lengthName_ + 2;
+}
+// Insert string (only valid for keywords)
+void
+CbcOrClpParam::append(std::string keyWord)
+{
+     definedKeyWords_.push_back(keyWord);
+}
+
+int
+CbcOrClpParam::matches (std::string input) const
+{
+     // look up strings to do more elegantly
+     if (input.length() > lengthName_) {
+          return 0;
+     } else {
+          unsigned int i;
+          for (i = 0; i < input.length(); i++) {
+               if (tolower(name_[i]) != tolower(input[i]))
+                    break;
+          }
+          if (i < input.length()) {
+               return 0;
+          } else if (i >= lengthMatch_) {
+               return 1;
+          } else {
+               // matched but too short
+               return 2;
+          }
+     }
+}
+// Returns name which could match
+std::string
+CbcOrClpParam::matchName (  ) const
+{
+     if (lengthMatch_ == lengthName_)
+          return name_;
+     else
+          return name_.substr(0, lengthMatch_) + "(" + name_.substr(lengthMatch_) + ")";
+}
+
+// Returns parameter option which matches (-1 if none)
+int
+CbcOrClpParam::parameterOption ( std::string check ) const
+{
+     int numberItems = static_cast<int>(definedKeyWords_.size());
+     if (!numberItems) {
+          return -1;
+     } else {
+          int whichItem = 0;
+          unsigned int it;
+          for (it = 0; it < definedKeyWords_.size(); it++) {
+               std::string thisOne = definedKeyWords_[it];
+               std::string::size_type  shriekPos = thisOne.find('!');
+               size_t length1 = thisOne.length();
+               size_t length2 = length1;
+               if ( shriekPos != std::string::npos ) {
+                    //contains '!'
+                    length2 = shriekPos;
+                    thisOne = thisOne.substr(0, shriekPos) +
+                              thisOne.substr(shriekPos + 1);
+                    length1 = thisOne.length();
+               }
+               if (check.length() <= length1 && length2 <= check.length()) {
+                    unsigned int i;
+                    for (i = 0; i < check.length(); i++) {
+                         if (tolower(thisOne[i]) != tolower(check[i]))
+                              break;
+                    }
+                    if (i < check.length()) {
+                         whichItem++;
+                    } else if (i >= length2) {
+                         break;
+                    }
+               } else {
+                    whichItem++;
+               }
+          }
+          if (whichItem < numberItems) {
+               return whichItem;
+          } else {
+	    if (fakeKeyWord_<=0)
+	      return -1;
+	    // allow plus or minus
+	    int n;
+	    if (check.substr(0,4)=="plus"||check.substr(0,4)=="PLUS") {
+	      n = 4;
+	    } else if (check.substr(0,5)=="minus"||check.substr(0,5)=="MINUS") {
+	      n = 5;
+	    } else {
+	      return -1;
+	    }
+	    int value = 0;
+	    std::string field=check.substr(n);
+	    if (field != "EOL") {
+	      const char * start = field.c_str();
+	      char * endPointer = NULL;
+	      // check valid
+	      value =  static_cast<int>(strtol(start, &endPointer, 10));
+	      if (*endPointer != '\0') {
+		return -1;
+	      }
+	      if (n==4) 
+		return value + 1000;
+	      else
+		return -value - 1000;
+	    } else {
+	      return -1;
+	    }
+	  }
+     }
+}
+// Prints parameter options
+void
+CbcOrClpParam::printOptions (  ) const
+{
+     std::cout << "<Possible options for " << name_ << " are:";
+     unsigned int it;
+     for (it = 0; it < definedKeyWords_.size(); it++) {
+          std::string thisOne = definedKeyWords_[it];
+          std::string::size_type  shriekPos = thisOne.find('!');
+          if ( shriekPos != std::string::npos ) {
+               //contains '!'
+               thisOne = thisOne.substr(0, shriekPos) +
+                         "(" + thisOne.substr(shriekPos + 1) + ")";
+          }
+          std::cout << " " << thisOne;
+     }
+     assert (currentKeyWord_ >= 0 && currentKeyWord_ < static_cast<int>(definedKeyWords_.size()));
+     std::string current = definedKeyWords_[currentKeyWord_];
+     std::string::size_type  shriekPos = current.find('!');
+     if ( shriekPos != std::string::npos ) {
+          //contains '!'
+          current = current.substr(0, shriekPos) +
+                    "(" + current.substr(shriekPos + 1) + ")";
+     }
+     std::cout << ";\n\tcurrent  " << current << ">" << std::endl;
+}
+// Print action and string
+void
+CbcOrClpParam::printString() const
+{
+     if (name_ == "directory")
+          std::cout << "Current working directory is " << stringValue_ << std::endl;
+     else if (name_.substr(0, 6) == "printM")
+          std::cout << "Current value of printMask is " << stringValue_ << std::endl;
+     else
+          std::cout << "Current default (if $ as parameter) for " << name_
+                    << " is " << stringValue_ << std::endl;
+}
+void CoinReadPrintit(const char * input)
+{
+     int length = static_cast<int>(strlen(input));
+     char temp[101];
+     int i;
+     int n = 0;
+     for (i = 0; i < length; i++) {
+          if (input[i] == '\n') {
+               temp[n] = '\0';
+               std::cout << temp << std::endl;
+               n = 0;
+          } else if (n >= 65 && input[i] == ' ') {
+               temp[n] = '\0';
+               std::cout << temp << std::endl;
+               n = 0;
+          } else if (n || input[i] != ' ') {
+               temp[n++] = input[i];
+          }
+     }
+     if (n) {
+          temp[n] = '\0';
+          std::cout << temp << std::endl;
+     }
+}
+// Print Long help
+void
+CbcOrClpParam::printLongHelp() const
+{
+     if (type_ >= 1 && type_ < 400) {
+          CoinReadPrintit(longHelp_.c_str());
+          if (type_ < CLP_PARAM_INT_SOLVERLOGLEVEL) {
+               printf("<Range of values is %g to %g;\n\tcurrent %g>\n", lowerDoubleValue_, upperDoubleValue_, doubleValue_);
+               assert (upperDoubleValue_ > lowerDoubleValue_);
+          } else if (type_ < CLP_PARAM_STR_DIRECTION) {
+               printf("<Range of values is %d to %d;\n\tcurrent %d>\n", lowerIntValue_, upperIntValue_, intValue_);
+               assert (upperIntValue_ > lowerIntValue_);
+          } else if (type_ < CLP_PARAM_ACTION_DIRECTORY) {
+               printOptions();
+          }
+     }
+}
+#ifdef COIN_HAS_CBC
+int
+CbcOrClpParam::setDoubleParameter (OsiSolverInterface * model, double value)
+{
+     int returnCode;
+     setDoubleParameterWithMessage(model, value, returnCode);
+     if (doPrinting && strlen(printArray))
+          std::cout << printArray << std::endl;
+     return returnCode;
+}
+// Sets double parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage ( OsiSolverInterface * model, double  value , int & returnCode)
+{
+     if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+          sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+                  value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+          std::cout << value << " was provided for " << name_ <<
+                    " - valid range is " << lowerDoubleValue_ << " to " <<
+                    upperDoubleValue_ << std::endl;
+          returnCode = 1;
+     } else {
+          double oldValue = doubleValue_;
+          doubleValue_ = value;
+          switch (type_) {
+          case CLP_PARAM_DBL_DUALTOLERANCE:
+               model->getDblParam(OsiDualTolerance, oldValue);
+               model->setDblParam(OsiDualTolerance, value);
+               break;
+          case CLP_PARAM_DBL_PRIMALTOLERANCE:
+               model->getDblParam(OsiPrimalTolerance, oldValue);
+               model->setDblParam(OsiPrimalTolerance, value);
+               break;
+          default:
+               break;
+          }
+          sprintf(printArray, "%s was changed from %g to %g",
+                  name_.c_str(), oldValue, value);
+          returnCode = 0;
+     }
+     return printArray;
+}
+#endif
+#ifdef COIN_HAS_CLP
+int
+CbcOrClpParam::setDoubleParameter (ClpSimplex * model, double value)
+{
+     int returnCode;
+     setDoubleParameterWithMessage(model, value, returnCode);
+     if (doPrinting && strlen(printArray))
+          std::cout << printArray << std::endl;
+     return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage ( ClpSimplex * model, double value , int & returnCode)
+{
+     double oldValue = doubleValue_;
+     if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+          sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+                  value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+          returnCode = 1;
+     } else {
+          sprintf(printArray, "%s was changed from %g to %g",
+                  name_.c_str(), oldValue, value);
+          returnCode = 0;
+          doubleValue_ = value;
+          switch (type_) {
+          case CLP_PARAM_DBL_DUALTOLERANCE:
+               model->setDualTolerance(value);
+               break;
+          case CLP_PARAM_DBL_PRIMALTOLERANCE:
+               model->setPrimalTolerance(value);
+               break;
+          case CLP_PARAM_DBL_ZEROTOLERANCE:
+               model->setSmallElementValue(value);
+               break;
+          case CLP_PARAM_DBL_DUALBOUND:
+               model->setDualBound(value);
+               break;
+          case CLP_PARAM_DBL_PRIMALWEIGHT:
+               model->setInfeasibilityCost(value);
+               break;
+#ifndef COIN_HAS_CBC
+          case CLP_PARAM_DBL_TIMELIMIT:
+               model->setMaximumSeconds(value);
+               break;
+#endif
+          case CLP_PARAM_DBL_OBJSCALE:
+               model->setObjectiveScale(value);
+               break;
+          case CLP_PARAM_DBL_RHSSCALE:
+               model->setRhsScale(value);
+               break;
+          case CLP_PARAM_DBL_PRESOLVETOLERANCE:
+               model->setDblParam(ClpPresolveTolerance, value);
+               break;
+          default:
+               break;
+          }
+     }
+     return printArray;
+}
+double
+CbcOrClpParam::doubleParameter (ClpSimplex * model) const
+{
+     double value;
+     switch (type_) {
+#ifndef COIN_HAS_CBC
+     case CLP_PARAM_DBL_DUALTOLERANCE:
+          value = model->dualTolerance();
+          break;
+     case CLP_PARAM_DBL_PRIMALTOLERANCE:
+          value = model->primalTolerance();
+          break;
+#endif
+     case CLP_PARAM_DBL_ZEROTOLERANCE:
+          value = model->getSmallElementValue();
+          break;
+     case CLP_PARAM_DBL_DUALBOUND:
+          value = model->dualBound();
+          break;
+     case CLP_PARAM_DBL_PRIMALWEIGHT:
+          value = model->infeasibilityCost();
+          break;
+#ifndef COIN_HAS_CBC
+     case CLP_PARAM_DBL_TIMELIMIT:
+          value = model->maximumSeconds();
+          break;
+#endif
+     case CLP_PARAM_DBL_OBJSCALE:
+          value = model->objectiveScale();
+          break;
+     case CLP_PARAM_DBL_RHSSCALE:
+          value = model->rhsScale();
+          break;
+     default:
+          value = doubleValue_;
+          break;
+     }
+     return value;
+}
+int
+CbcOrClpParam::setIntParameter (ClpSimplex * model, int value)
+{
+     int returnCode;
+     setIntParameterWithMessage(model, value, returnCode);
+     if (doPrinting && strlen(printArray))
+          std::cout << printArray << std::endl;
+     return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage ( ClpSimplex * model, int value , int & returnCode)
+{
+     int oldValue = intValue_;
+     if (value < lowerIntValue_ || value > upperIntValue_) {
+          sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+                  value, name_.c_str(), lowerIntValue_, upperIntValue_);
+          returnCode = 1;
+     } else {
+          intValue_ = value;
+          sprintf(printArray, "%s was changed from %d to %d",
+                  name_.c_str(), oldValue, value);
+          returnCode = 0;
+          switch (type_) {
+          case CLP_PARAM_INT_SOLVERLOGLEVEL:
+               model->setLogLevel(value);
+               if (value > 2)
+                    model->factorization()->messageLevel(8);
+               else
+                    model->factorization()->messageLevel(0);
+               break;
+          case CLP_PARAM_INT_MAXFACTOR:
+               model->factorization()->maximumPivots(value);
+               break;
+          case CLP_PARAM_INT_PERTVALUE:
+               model->setPerturbation(value);
+               break;
+          case CLP_PARAM_INT_MAXITERATION:
+               model->setMaximumIterations(value);
+               break;
+          case CLP_PARAM_INT_SPECIALOPTIONS:
+               model->setSpecialOptions(value);
+               break;
+          case CLP_PARAM_INT_RANDOMSEED:
+	    {
+	      if (value==0) {
+		double time = fabs(CoinGetTimeOfDay());
+		while (time>=COIN_INT_MAX)
+		  time *= 0.5;
+		value = static_cast<int>(time);
+		sprintf(printArray, "using time of day %s was changed from %d to %d",
+                  name_.c_str(), oldValue, value);
+	      }
+	      model->setRandomSeed(value);
+	    }
+               break;
+          case CLP_PARAM_INT_MORESPECIALOPTIONS:
+               model->setMoreSpecialOptions(value);
+	       break;
+#ifndef COIN_HAS_CBC
+#ifdef CBC_THREAD
+          case CBC_PARAM_INT_THREADS:
+               model->setNumberThreads(value);
+               break;
+#endif
+#endif
+          default:
+               break;
+          }
+     }
+     return printArray;
+}
+int
+CbcOrClpParam::intParameter (ClpSimplex * model) const
+{
+     int value;
+     switch (type_) {
+#ifndef COIN_HAS_CBC
+     case CLP_PARAM_INT_SOLVERLOGLEVEL:
+          value = model->logLevel();
+          break;
+#endif
+     case CLP_PARAM_INT_MAXFACTOR:
+          value = model->factorization()->maximumPivots();
+          break;
+          break;
+     case CLP_PARAM_INT_PERTVALUE:
+          value = model->perturbation();
+          break;
+     case CLP_PARAM_INT_MAXITERATION:
+          value = model->maximumIterations();
+          break;
+     case CLP_PARAM_INT_SPECIALOPTIONS:
+          value = model->specialOptions();
+          break;
+     case CLP_PARAM_INT_RANDOMSEED:
+          value = model->randomNumberGenerator()->getSeed();
+          break;
+     case CLP_PARAM_INT_MORESPECIALOPTIONS:
+          value = model->moreSpecialOptions();
+          break;
+#ifndef COIN_HAS_CBC
+#ifdef CBC_THREAD
+     case CBC_PARAM_INT_THREADS:
+          value = model->numberThreads();
+	  break;
+#endif
+#endif
+     default:
+          value = intValue_;
+          break;
+     }
+     return value;
+}
+#endif
+int
+CbcOrClpParam::checkDoubleParameter (double value) const
+{
+     if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+          std::cout << value << " was provided for " << name_ <<
+                    " - valid range is " << lowerDoubleValue_ << " to " <<
+                    upperDoubleValue_ << std::endl;
+          return 1;
+     } else {
+          return 0;
+     }
+}
+#ifdef COIN_HAS_CBC
+double
+CbcOrClpParam::doubleParameter (OsiSolverInterface *
+#ifndef NDEBUG
+                                model
+#endif
+                               ) const
+{
+     double value = 0.0;
+     switch (type_) {
+     case CLP_PARAM_DBL_DUALTOLERANCE:
+          assert(model->getDblParam(OsiDualTolerance, value));
+          break;
+     case CLP_PARAM_DBL_PRIMALTOLERANCE:
+          assert(model->getDblParam(OsiPrimalTolerance, value));
+          break;
+     default:
+          return doubleValue_;
+          break;
+     }
+     return value;
+}
+int
+CbcOrClpParam::setIntParameter (OsiSolverInterface * model, int value)
+{
+     int returnCode;
+     setIntParameterWithMessage(model, value, returnCode);
+     if (doPrinting && strlen(printArray))
+          std::cout << printArray << std::endl;
+     return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage ( OsiSolverInterface * model, int  value , int & returnCode)
+{
+     if (value < lowerIntValue_ || value > upperIntValue_) {
+          sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+                  value, name_.c_str(), lowerIntValue_, upperIntValue_);
+          returnCode = 1;
+     } else {
+          int oldValue = intValue_;
+          intValue_ = oldValue;
+          switch (type_) {
+          case CLP_PARAM_INT_SOLVERLOGLEVEL:
+               model->messageHandler()->setLogLevel(value);
+               break;
+          default:
+               break;
+          }
+          sprintf(printArray, "%s was changed from %d to %d",
+                  name_.c_str(), oldValue, value);
+          returnCode = 0;
+     }
+     return printArray;
+}
+int
+CbcOrClpParam::intParameter (OsiSolverInterface * model) const
+{
+     int value = 0;
+     switch (type_) {
+     case CLP_PARAM_INT_SOLVERLOGLEVEL:
+          value = model->messageHandler()->logLevel();
+          break;
+     default:
+          value = intValue_;
+          break;
+     }
+     return value;
+}
+int
+CbcOrClpParam::setDoubleParameter (CbcModel &model, double value)
+{
+     int returnCode=0;
+     setDoubleParameterWithMessage(model, value, returnCode);
+     if (doPrinting && strlen(printArray))
+          std::cout << printArray << std::endl;
+     return returnCode;
+}
+// Sets double parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage ( CbcModel & model, double  value , int & returnCode)
+{
+     if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+          sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+                  value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+          returnCode = 1;
+     } else {
+          double oldValue = doubleValue_;
+          doubleValue_ = value;
+          switch (type_) {
+          case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
+               oldValue = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
+               model.setDblParam(CbcModel::CbcInfeasibilityWeight, value);
+               break;
+          case CBC_PARAM_DBL_INTEGERTOLERANCE:
+               oldValue = model.getDblParam(CbcModel::CbcIntegerTolerance);
+               model.setDblParam(CbcModel::CbcIntegerTolerance, value);
+               break;
+          case CBC_PARAM_DBL_INCREMENT:
+               oldValue = model.getDblParam(CbcModel::CbcCutoffIncrement);
+               model.setDblParam(CbcModel::CbcCutoffIncrement, value);
+          case CBC_PARAM_DBL_ALLOWABLEGAP:
+               oldValue = model.getDblParam(CbcModel::CbcAllowableGap);
+               model.setDblParam(CbcModel::CbcAllowableGap, value);
+               break;
+          case CBC_PARAM_DBL_GAPRATIO:
+               oldValue = model.getDblParam(CbcModel::CbcAllowableFractionGap);
+               model.setDblParam(CbcModel::CbcAllowableFractionGap, value);
+               break;
+          case CBC_PARAM_DBL_CUTOFF:
+               oldValue = model.getCutoff();
+               model.setCutoff(value);
+               break;
+          case CBC_PARAM_DBL_TIMELIMIT_BAB:
+               oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
+               {
+                    //OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
+                    //ClpSimplex * lpSolver = clpSolver->getModelPtr();
+                    //lpSolver->setMaximumSeconds(value);
+                    model.setDblParam(CbcModel::CbcMaximumSeconds, value) ;
+               }
+               break ;
+          case CLP_PARAM_DBL_DUALTOLERANCE:
+          case CLP_PARAM_DBL_PRIMALTOLERANCE:
+               setDoubleParameter(model.solver(), value);
+               return 0; // to avoid message
+          default:
+               break;
+          }
+          sprintf(printArray, "%s was changed from %g to %g",
+                  name_.c_str(), oldValue, value);
+          returnCode = 0;
+     }
+     return printArray;
+}
+double
+CbcOrClpParam::doubleParameter (CbcModel &model) const
+{
+     double value;
+     switch (type_) {
+     case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
+          value = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
+          break;
+     case CBC_PARAM_DBL_INTEGERTOLERANCE:
+          value = model.getDblParam(CbcModel::CbcIntegerTolerance);
+          break;
+     case CBC_PARAM_DBL_INCREMENT:
+          value = model.getDblParam(CbcModel::CbcCutoffIncrement);
+          break;
+     case CBC_PARAM_DBL_ALLOWABLEGAP:
+          value = model.getDblParam(CbcModel::CbcAllowableGap);
+          break;
+     case CBC_PARAM_DBL_GAPRATIO:
+          value = model.getDblParam(CbcModel::CbcAllowableFractionGap);
+          break;
+     case CBC_PARAM_DBL_CUTOFF:
+          value = model.getCutoff();
+          break;
+     case CBC_PARAM_DBL_TIMELIMIT_BAB:
+          value = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
+          break ;
+     case CLP_PARAM_DBL_DUALTOLERANCE:
+     case CLP_PARAM_DBL_PRIMALTOLERANCE:
+          value = doubleParameter(model.solver());
+          break;
+     default:
+          value = doubleValue_;
+          break;
+     }
+     return value;
+}
+int
+CbcOrClpParam::setIntParameter (CbcModel &model, int value)
+{
+     int returnCode;
+     setIntParameterWithMessage(model, value, returnCode);
+     if (doPrinting && strlen(printArray))
+          std::cout << printArray << std::endl;
+     return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage ( CbcModel & model, int value , int & returnCode)
+{
+     if (value < lowerIntValue_ || value > upperIntValue_) {
+          sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+                  value, name_.c_str(), lowerIntValue_, upperIntValue_);
+          returnCode = 1;
+     } else {
+          printArray[0] = '\0';
+	  if (value==intValue_)
+	    return printArray;
+          int oldValue = intValue_;
+          intValue_ = value;
+          switch (type_) {
+          case CLP_PARAM_INT_LOGLEVEL:
+               oldValue = model.messageHandler()->logLevel();
+               model.messageHandler()->setLogLevel(CoinAbs(value));
+               break;
+          case CLP_PARAM_INT_SOLVERLOGLEVEL:
+               oldValue = model.solver()->messageHandler()->logLevel();
+               model.solver()->messageHandler()->setLogLevel(value);
+               break;
+          case CBC_PARAM_INT_MAXNODES:
+               oldValue = model.getIntParam(CbcModel::CbcMaxNumNode);
+               model.setIntParam(CbcModel::CbcMaxNumNode, value);
+               break;
+          case CBC_PARAM_INT_MAXSOLS:
+               oldValue = model.getIntParam(CbcModel::CbcMaxNumSol);
+               model.setIntParam(CbcModel::CbcMaxNumSol, value);
+               break;
+          case CBC_PARAM_INT_MAXSAVEDSOLS:
+               oldValue = model.maximumSavedSolutions();
+               model.setMaximumSavedSolutions(value);
+               break;
+          case CBC_PARAM_INT_STRONGBRANCHING:
+               oldValue = model.numberStrong();
+               model.setNumberStrong(value);
+               break;
+          case CBC_PARAM_INT_NUMBERBEFORE:
+               oldValue = model.numberBeforeTrust();
+               model.setNumberBeforeTrust(value);
+               break;
+          case CBC_PARAM_INT_NUMBERANALYZE:
+               oldValue = model.numberAnalyzeIterations();
+               model.setNumberAnalyzeIterations(value);
+               break;
+          case CBC_PARAM_INT_CUTPASSINTREE:
+               oldValue = model.getMaximumCutPasses();
+               model.setMaximumCutPasses(value);
+               break;
+          case CBC_PARAM_INT_CUTPASS:
+               oldValue = model.getMaximumCutPassesAtRoot();
+               model.setMaximumCutPassesAtRoot(value);
+               break;
+#ifdef COIN_HAS_CBC
+#ifdef CBC_THREAD
+          case CBC_PARAM_INT_THREADS:
+               oldValue = model.getNumberThreads();
+               model.setNumberThreads(value);
+               break;
+#endif
+          case CBC_PARAM_INT_RANDOMSEED:
+               oldValue = model.getRandomSeed();
+               model.setRandomSeed(value);
+               break;
+#endif
+          default:
+               break;
+          }
+          sprintf(printArray, "%s was changed from %d to %d",
+                  name_.c_str(), oldValue, value);
+          returnCode = 0;
+     }
+     return printArray;
+}
+int
+CbcOrClpParam::intParameter (CbcModel &model) const
+{
+     int value;
+     switch (type_) {
+     case CLP_PARAM_INT_LOGLEVEL:
+          value = model.messageHandler()->logLevel();
+          break;
+     case CLP_PARAM_INT_SOLVERLOGLEVEL:
+          value = model.solver()->messageHandler()->logLevel();
+          break;
+     case CBC_PARAM_INT_MAXNODES:
+          value = model.getIntParam(CbcModel::CbcMaxNumNode);
+          break;
+     case CBC_PARAM_INT_MAXSOLS:
+          value = model.getIntParam(CbcModel::CbcMaxNumSol);
+          break;
+     case CBC_PARAM_INT_MAXSAVEDSOLS:
+          value = model.maximumSavedSolutions();
+	  break;
+     case CBC_PARAM_INT_STRONGBRANCHING:
+          value = model.numberStrong();
+          break;
+     case CBC_PARAM_INT_NUMBERBEFORE:
+          value = model.numberBeforeTrust();
+          break;
+     case CBC_PARAM_INT_NUMBERANALYZE:
+          value = model.numberAnalyzeIterations();
+          break;
+     case CBC_PARAM_INT_CUTPASSINTREE:
+          value = model.getMaximumCutPasses();
+          break;
+     case CBC_PARAM_INT_CUTPASS:
+          value = model.getMaximumCutPassesAtRoot();
+          break;
+#ifdef COIN_HAS_CBC
+#ifdef CBC_THREAD
+     case CBC_PARAM_INT_THREADS:
+          value = model.getNumberThreads();
+#endif
+     case CBC_PARAM_INT_RANDOMSEED:
+          value = model.getRandomSeed();
+          break;
+#endif
+     default:
+          value = intValue_;
+          break;
+     }
+     return value;
+}
+#endif
+// Sets current parameter option using string
+void
+CbcOrClpParam::setCurrentOption ( const std::string value )
+{
+     int action = parameterOption(value);
+     if (action >= 0)
+          currentKeyWord_ = action;
+#if FLUSH_PRINT_BUFFER > 2
+     if (name_=="bufferedMode")
+       coinFlushBufferFlag=action;
+#endif
+}
+// Sets current parameter option
+void
+CbcOrClpParam::setCurrentOption ( int value , bool printIt)
+{
+     if (printIt && value != currentKeyWord_)
+          std::cout << "Option for " << name_ << " changed from "
+                    << definedKeyWords_[currentKeyWord_] << " to "
+                    << definedKeyWords_[value] << std::endl;
+
+#if FLUSH_PRINT_BUFFER > 2
+     if (name_=="bufferedMode")
+       coinFlushBufferFlag=value;
+#endif
+     currentKeyWord_ = value;
+}
+// Sets current parameter option and returns printable string
+const char *
+CbcOrClpParam::setCurrentOptionWithMessage ( int value )
+{
+     if (value != currentKeyWord_) {
+         char current[100];
+	 char newString[100];
+	 if (currentKeyWord_>=0&&(fakeKeyWord_<=0||currentKeyWord_<fakeKeyWord_)) 
+	   strcpy(current,definedKeyWords_[currentKeyWord_].c_str());
+	 else if (currentKeyWord_<0)
+	   sprintf(current,"minus%d",-currentKeyWord_-1000);
+	 else
+	   sprintf(current,"plus%d",currentKeyWord_-1000);
+	 if (value>=0&&(fakeKeyWord_<=0||value<fakeKeyWord_) )
+	   strcpy(newString,definedKeyWords_[value].c_str());
+	 else if (value<0)
+	   sprintf(newString,"minus%d",-value-1000);
+	 else
+	   sprintf(newString,"plus%d",value-1000);
+	 sprintf(printArray, "Option for %s changed from %s to %s",
+		 name_.c_str(), current, newString);
+#if FLUSH_PRINT_BUFFER > 2
+	 if (name_=="bufferedMode")
+	   coinFlushBufferFlag=value;
+#endif
+	 currentKeyWord_ = value;
+     } else {
+          printArray[0] = '\0';
+     }
+     return printArray;
+}
+// Sets current parameter option using string with message
+const char *
+CbcOrClpParam::setCurrentOptionWithMessage ( const std::string value )
+{
+     int action = parameterOption(value);
+     char current[100];
+     printArray[0] = '\0';
+     if (action >= 0) {
+#if FLUSH_PRINT_BUFFER > 2
+       if (name_=="bufferedMode")
+	 coinFlushBufferFlag=action;
+#endif
+         if (action == currentKeyWord_)
+	   return NULL;
+	 if (currentKeyWord_>=0&&(fakeKeyWord_<=0||currentKeyWord_<fakeKeyWord_)) 
+	   strcpy(current,definedKeyWords_[currentKeyWord_].c_str());
+	 else if (currentKeyWord_<0)
+	   sprintf(current,"minus%d",-currentKeyWord_-1000);
+	 else
+	   sprintf(current,"plus%d",currentKeyWord_-1000);
+	 sprintf(printArray, "Option for %s changed from %s to %s",
+		 name_.c_str(), current, value.c_str());
+          currentKeyWord_ = action;
+     } else {
+	 sprintf(printArray, "Option for %s given illegal value %s",
+		 name_.c_str(), value.c_str());
+     }
+     return printArray;
+}
+void
+CbcOrClpParam::setIntValue ( int value )
+{
+     if (value < lowerIntValue_ || value > upperIntValue_) {
+          std::cout << value << " was provided for " << name_ <<
+                    " - valid range is " << lowerIntValue_ << " to " <<
+                    upperIntValue_ << std::endl;
+     } else {
+          intValue_ = value;
+     }
+}
+const char *
+CbcOrClpParam::setIntValueWithMessage ( int value )
+{
+     printArray[0] = '\0';
+     if (value < lowerIntValue_ || value > upperIntValue_) {
+          sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+	       value,name_.c_str(),lowerIntValue_,upperIntValue_);
+     } else {
+         if (value==intValue_)
+	   return NULL;
+          sprintf(printArray, "%s was changed from %d to %d",
+                  name_.c_str(), intValue_, value);
+          intValue_ = value;
+     }
+     return printArray;
+}
+void
+CbcOrClpParam::setDoubleValue ( double value )
+{
+     if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+          std::cout << value << " was provided for " << name_ <<
+                    " - valid range is " << lowerDoubleValue_ << " to " <<
+                    upperDoubleValue_ << std::endl;
+     } else {
+          doubleValue_ = value;
+     }
+}
+const char *
+CbcOrClpParam::setDoubleValueWithMessage ( double value )
+{
+     printArray[0] = '\0';
+     if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+          sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+	       value,name_.c_str(),lowerDoubleValue_,upperDoubleValue_);
+     } else {
+         if (value==doubleValue_)
+	   return NULL;
+          sprintf(printArray, "%s was changed from %g to %g",
+                  name_.c_str(), doubleValue_, value);
+          doubleValue_ = value;
+     }
+     return printArray;
+}
+void
+CbcOrClpParam::setStringValue ( std::string value )
+{
+     stringValue_ = value;
+}
+static char line[1000];
+static char * where = NULL;
+extern int CbcOrClpRead_mode;
+int CbcOrClpEnvironmentIndex = -1;
+static size_t fillEnv()
+{
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+     return 0;
+#else
+     // Don't think it will work on Windows
+     char * environ = getenv("CBC_CLP_ENVIRONMENT");
+     size_t length = 0;
+     if (environ) {
+          length = strlen(environ);
+          if (CbcOrClpEnvironmentIndex < static_cast<int>(length)) {
+               // find next non blank
+               char * whereEnv = environ + CbcOrClpEnvironmentIndex;
+               // munch white space
+               while (*whereEnv == ' ' || *whereEnv == '\t' || *whereEnv < ' ')
+                    whereEnv++;
+               // copy
+               char * put = line;
+               while ( *whereEnv != '\0' ) {
+                    if ( *whereEnv == ' ' || *whereEnv == '\t' || *whereEnv < ' ' ) {
+                         break;
+                    }
+                    *put = *whereEnv;
+                    put++;
+                    assert (put - line < 1000);
+                    whereEnv++;
+               }
+               CbcOrClpEnvironmentIndex = static_cast<int>(whereEnv - environ);
+               *put = '\0';
+               length = strlen(line);
+          } else {
+               length = 0;
+          }
+     }
+     if (!length)
+          CbcOrClpEnvironmentIndex = -1;
+     return length;
+#endif
+}
+extern FILE * CbcOrClpReadCommand;
+// Simple read stuff
+std::string
+CoinReadNextField()
+{
+     std::string field;
+     if (!where) {
+          // need new line
+#ifdef COIN_HAS_READLINE
+          if (CbcOrClpReadCommand == stdin) {
+               // Get a line from the user.
+               where = readline (coin_prompt);
+
+               // If the line has any text in it, save it on the history.
+               if (where) {
+                    if ( *where)
+                         add_history (where);
+                    strcpy(line, where);
+                    free(where);
+               }
+          } else {
+               where = fgets(line, 1000, CbcOrClpReadCommand);
+          }
+#else
+          if (CbcOrClpReadCommand == stdin) {
+	       fputs(coin_prompt,stdout);
+               fflush(stdout);
+          }
+          where = fgets(line, 1000, CbcOrClpReadCommand);
+#endif
+          if (!where)
+               return field; // EOF
+          where = line;
+          // clean image
+          char * lastNonBlank = line - 1;
+          while ( *where != '\0' ) {
+               if ( *where != '\t' && *where < ' ' ) {
+                    break;
+               } else if ( *where != '\t' && *where != ' ') {
+                    lastNonBlank = where;
+               }
+               where++;
+          }
+          where = line;
+          *(lastNonBlank + 1) = '\0';
+     }
+     // munch white space
+     while (*where == ' ' || *where == '\t')
+          where++;
+     char * saveWhere = where;
+     while (*where != ' ' && *where != '\t' && *where != '\0')
+          where++;
+     if (where != saveWhere) {
+          char save = *where;
+          *where = '\0';
+          //convert to string
+          field = saveWhere;
+          *where = save;
+     } else {
+          where = NULL;
+          field = "EOL";
+     }
+     return field;
+}
+
+std::string
+CoinReadGetCommand(int argc, const char *argv[])
+{
+     std::string field = "EOL";
+     // say no =
+     afterEquals = "";
+     while (field == "EOL") {
+          if (CbcOrClpRead_mode > 0) {
+               if ((CbcOrClpRead_mode < argc && argv[CbcOrClpRead_mode]) ||
+                         CbcOrClpEnvironmentIndex >= 0) {
+                    if (CbcOrClpEnvironmentIndex < 0) {
+                         field = argv[CbcOrClpRead_mode++];
+                    } else {
+                         if (fillEnv()) {
+                              field = line;
+                         } else {
+                              // not there
+                              continue;
+                         }
+                    }
+                    if (field == "-") {
+                         std::cout << "Switching to line mode" << std::endl;
+                         CbcOrClpRead_mode = -1;
+                         field = CoinReadNextField();
+                    } else if (field[0] != '-') {
+                         if (CbcOrClpRead_mode != 2) {
+                              // now allow std::cout<<"skipping non-command "<<field<<std::endl;
+                              // field="EOL"; // skip
+                         } else if (CbcOrClpEnvironmentIndex < 0) {
+                              // special dispensation - taken as -import name
+                              CbcOrClpRead_mode--;
+                              field = "import";
+                         }
+                    } else {
+                         if (field != "--") {
+                              // take off -
+                              field = field.substr(1);
+                         } else {
+                              // special dispensation - taken as -import --
+                              CbcOrClpRead_mode--;
+                              field = "import";
+                         }
+                    }
+               } else {
+                    field = "";
+               }
+          } else {
+               field = CoinReadNextField();
+          }
+     }
+     // if = then modify and save
+     std::string::size_type found = field.find('=');
+     if (found != std::string::npos) {
+          afterEquals = field.substr(found + 1);
+          field = field.substr(0, found);
+     }
+     //std::cout<<field<<std::endl;
+     return field;
+}
+std::string
+CoinReadGetString(int argc, const char *argv[])
+{
+     std::string field = "EOL";
+     if (afterEquals == "") {
+          if (CbcOrClpRead_mode > 0) {
+               if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+                    if (CbcOrClpEnvironmentIndex < 0) {
+                         if (argv[CbcOrClpRead_mode][0] != '-') {
+                              field = argv[CbcOrClpRead_mode++];
+                         } else if (!strcmp(argv[CbcOrClpRead_mode], "--")) {
+                              field = argv[CbcOrClpRead_mode++];
+                              // -- means import from stdin
+                              field = "-";
+                         }
+                    } else {
+                         fillEnv();
+                         field = line;
+                    }
+               }
+          } else {
+               field = CoinReadNextField();
+          }
+     } else {
+          field = afterEquals;
+          afterEquals = "";
+     }
+     //std::cout<<field<<std::endl;
+     return field;
+}
+// valid 0 - okay, 1 bad, 2 not there
+int
+CoinReadGetIntField(int argc, const char *argv[], int * valid)
+{
+     std::string field = "EOL";
+     if (afterEquals == "") {
+          if (CbcOrClpRead_mode > 0) {
+               if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+                    if (CbcOrClpEnvironmentIndex < 0) {
+                         // may be negative value so do not check for -
+                         field = argv[CbcOrClpRead_mode++];
+                    } else {
+                         fillEnv();
+                         field = line;
+                    }
+               }
+          } else {
+               field = CoinReadNextField();
+          }
+     } else {
+          field = afterEquals;
+          afterEquals = "";
+     }
+     long int value = 0;
+     //std::cout<<field<<std::endl;
+     if (field != "EOL") {
+          const char * start = field.c_str();
+          char * endPointer = NULL;
+          // check valid
+          value =  strtol(start, &endPointer, 10);
+          if (*endPointer == '\0') {
+               *valid = 0;
+          } else {
+               *valid = 1;
+               std::cout << "String of " << field;
+          }
+     } else {
+          *valid = 2;
+     }
+     return static_cast<int>(value);
+}
+double
+CoinReadGetDoubleField(int argc, const char *argv[], int * valid)
+{
+     std::string field = "EOL";
+     if (afterEquals == "") {
+          if (CbcOrClpRead_mode > 0) {
+               if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+                    if (CbcOrClpEnvironmentIndex < 0) {
+                         // may be negative value so do not check for -
+                         field = argv[CbcOrClpRead_mode++];
+                    } else {
+                         fillEnv();
+                         field = line;
+                    }
+               }
+          } else {
+               field = CoinReadNextField();
+          }
+     } else {
+          field = afterEquals;
+          afterEquals = "";
+     }
+     double value = 0.0;
+     //std::cout<<field<<std::endl;
+     if (field != "EOL") {
+          const char * start = field.c_str();
+          char * endPointer = NULL;
+          // check valid
+          value =  strtod(start, &endPointer);
+          if (*endPointer == '\0') {
+               *valid = 0;
+          } else {
+               *valid = 1;
+               std::cout << "String of " << field;
+          }
+     } else {
+          *valid = 2;
+     }
+     return value;
+}
+/*
+  Subroutine to establish the cbc parameter array. See the description of
+  class CbcOrClpParam for details. Pulled from C..Main() for clarity.
+*/
+void
+establishParams (int &numberParameters, CbcOrClpParam *const parameters)
+{
+     numberParameters = 0;
+     parameters[numberParameters++] =
+          CbcOrClpParam("?", "For help", CBC_PARAM_GENERALQUERY, 7, 0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("???", "For help", CBC_PARAM_FULLGENERALQUERY, 7, 0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("-", "From stdin",
+                        CLP_PARAM_ACTION_STDIN, 3, 0);
+#ifdef ABC_INHERIT
+      parameters[numberParameters++] =
+          CbcOrClpParam("abc", "Whether to visit Aboca",
+                        "off", CLP_PARAM_STR_ABCWANTED, 7, 0);
+     parameters[numberParameters-1].append("one");
+     parameters[numberParameters-1].append("two");
+     parameters[numberParameters-1].append("three");
+     parameters[numberParameters-1].append("four");
+     parameters[numberParameters-1].append("five");
+     parameters[numberParameters-1].append("six");
+     parameters[numberParameters-1].append("seven");
+     parameters[numberParameters-1].append("eight");
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("decide");
+     parameters[numberParameters-1].setFakeKeyWord(10);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Decide whether to use A Basic Optimization Code (Accelerated?) \
+and whether to try going parallel!"
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("allC!ommands", "Whether to print less used commands",
+                        "no", CLP_PARAM_STR_ALLCOMMANDS);
+     parameters[numberParameters-1].append("more");
+     parameters[numberParameters-1].append("all");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "For the sake of your sanity, only the more useful and simple commands \
+are printed out on ?."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("allow!ableGap", "Stop when gap between best possible and \
+best less than this",
+                        0.0, 1.0e20, CBC_PARAM_DBL_ALLOWABLEGAP);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If the gap between best solution and best possible solution is less than this \
+then the search will be terminated.  Also see ratioGap."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("allS!lack", "Set basis back to all slack and reset solution",
+                        CLP_PARAM_ACTION_ALLSLACK, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Mainly useful for tuning purposes.  Normally the first dual or primal will be using an all slack \
+basis anyway."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("artif!icialCost", "Costs >= this treated as artificials in feasibility pump",
+                        0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "0.0 off - otherwise variables with costs >= this are treated as artificials and fixed to lower bound in feasibility pump"
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("auto!Scale", "Whether to scale objective, rhs and bounds of problem if they look odd",
+                        "off", CLP_PARAM_STR_AUTOSCALE, 7, 0);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If you think you may get odd objective values or large equality rows etc then\
+ it may be worth setting this true.  It is still experimental and you may prefer\
+ to use objective!Scale and rhs!Scale."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("barr!ier", "Solve using primal dual predictor corrector algorithm",
+                        CLP_PARAM_ACTION_BARRIER);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This command solves the current model using the  primal dual predictor \
+corrector algorithm.  You may want to link in an alternative \
+ordering and factorization.  It will also solve models \
+with quadratic objectives."
+
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("basisI!n", "Import basis from bas file",
+                        CLP_PARAM_ACTION_BASISIN, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will read an MPS format basis file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  If you have libz then it can read compressed\
+ files 'xxxxxxxx.gz' or xxxxxxxx.bz2."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("basisO!ut", "Export basis as bas file",
+                        CLP_PARAM_ACTION_BASISOUT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will write an MPS format basis file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.bas'."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("biasLU", "Whether factorization biased towards U",
+                        "UU", CLP_PARAM_STR_BIASLU, 2, 0);
+     parameters[numberParameters-1].append("UX");
+     parameters[numberParameters-1].append("LX");
+     parameters[numberParameters-1].append("LL");
+     parameters[numberParameters-1].setCurrentOption("LX");
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("branch!AndCut", "Do Branch and Cut",
+                        CBC_PARAM_ACTION_BAB);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This does branch and cut.  There are many parameters which can affect the performance.  \
+First just try with default settings and look carefully at the log file.  Did cuts help?  Did they take too long?  \
+Look at output to see which cuts were effective and then do some tuning.  You will see that the \
+options for cuts are off, on, root and ifmove, forceon.  Off is \
+obvious, on means that this cut generator will be tried in the branch and cut tree (you can fine tune using \
+'depth').  Root means just at the root node while 'ifmove' means that cuts will be used in the tree if they \
+look as if they are doing some good and moving the objective value.  Forceon is same as on but forces code to use \
+cut generator at every node.  For probing forceonbut just does fixing probing in tree - not strengthening etc.  \
+If pre-processing reduced the size of the \
+problem or strengthened many coefficients then it is probably wise to leave it on.  Switch off heuristics \
+which did not provide solutions.  The other major area to look at is the search.  Hopefully good solutions \
+were obtained fairly early in the search so the important point is to select the best variable to branch on.  \
+See whether strong branching did a good job - or did it just take a lot of iterations.  Adjust the strongBranching \
+and trustPseudoCosts parameters.  If cuts did a good job, then you may wish to \
+have more rounds of cuts - see passC!uts and passT!ree."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("bscale", "Whether to scale in barrier (and ordering speed)",
+                        "off", CLP_PARAM_STR_BARRIERSCALE, 7, 0);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("off1");
+     parameters[numberParameters-1].append("on1");
+     parameters[numberParameters-1].append("off2");
+     parameters[numberParameters-1].append("on2");
+#if FLUSH_PRINT_BUFFER > 2
+     parameters[numberParameters++] =
+          CbcOrClpParam("buff!eredMode", "Whether to flush print buffer",
+                        "on", CLP_PARAM_STR_BUFFER_MODE);
+     parameters[numberParameters-1].append("off");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Default is on, off switches on unbuffered output"
+     );
+     parameters[numberParameters-1].setIntValue(0);
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("chol!esky", "Which cholesky algorithm",
+                        "native", CLP_PARAM_STR_CHOLESKY, 7);
+     parameters[numberParameters-1].append("dense");
+     //#ifdef FOREIGN_BARRIER
+#ifdef COIN_HAS_WSMP
+     parameters[numberParameters-1].append("fudge!Long");
+     parameters[numberParameters-1].append("wssmp");
+#else
+     parameters[numberParameters-1].append("fudge!Long_dummy");
+     parameters[numberParameters-1].append("wssmp_dummy");
+#endif
+#if defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD) || defined(COIN_HAS_GLPK)
+     parameters[numberParameters-1].append("Uni!versityOfFlorida");
+#else
+     parameters[numberParameters-1].append("Uni!versityOfFlorida_dummy");
+#endif
+#ifdef TAUCS_BARRIER
+     parameters[numberParameters-1].append("Taucs");
+#else
+     parameters[numberParameters-1].append("Taucs_dummy");
+#endif
+#ifdef COIN_HAS_MUMPS
+     parameters[numberParameters-1].append("Mumps");
+#else
+     parameters[numberParameters-1].append("Mumps_dummy");
+#endif
+     parameters[numberParameters-1].setLonghelp
+     (
+          "For a barrier code to be effective it needs a good Cholesky ordering and factorization.  \
+The native ordering and factorization is not state of the art, although acceptable.  \
+You may want to link in one from another source.  See Makefile.locations for some \
+possibilities."
+     );
+     //#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("clique!Cuts", "Whether to use Clique cuts",
+                        "off", CBC_PARAM_STR_CLIQUECUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on clique cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("combine!Solutions", "Whether to use combine solution heuristic",
+                        "off", CBC_PARAM_STR_COMBINE);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].append("onquick");
+     parameters[numberParameters-1].append("bothquick");
+     parameters[numberParameters-1].append("beforequick");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on a heuristic which does branch and cut on the problem given by just \
+using variables which have appeared in one or more solutions. \
+It obviously only tries after two or more solutions. \
+See Rounding for meaning of on,both,before"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("combine2!Solutions", "Whether to use crossover solution heuristic",
+                        "off", CBC_PARAM_STR_CROSSOVER2);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on a heuristic which does branch and cut on the problem given by \
+fixing variables which have same value in two or more solutions. \
+It obviously only tries after two or more solutions. \
+See Rounding for meaning of on,both,before"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("constraint!fromCutoff", "Whether to use cutoff as constraint",
+                        "off", CBC_PARAM_STR_CUTOFF_CONSTRAINT);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("variable");
+     parameters[numberParameters-1].append("forcevariable");
+     parameters[numberParameters-1].append("conflict");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This adds the objective as a constraint with best solution as RHS"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("cost!Strategy", "How to use costs as priorities",
+                        "off", CBC_PARAM_STR_COSTSTRATEGY);
+     parameters[numberParameters-1].append("pri!orities");
+     parameters[numberParameters-1].append("column!Order?");
+     parameters[numberParameters-1].append("01f!irst?");
+     parameters[numberParameters-1].append("01l!ast?");
+     parameters[numberParameters-1].append("length!?");
+     parameters[numberParameters-1].append("singletons");
+     parameters[numberParameters-1].append("nonzero");
+     parameters[numberParameters-1].append("general!Force?");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This orders the variables in order of their absolute costs - with largest cost ones being branched on \
+first.  This primitive strategy can be surprsingly effective.  The column order\
+ option is obviously not on costs but easy to code here."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("cplex!Use", "Whether to use Cplex!",
+                        "off", CBC_PARAM_STR_CPX);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          " If the user has Cplex, but wants to use some of Cbc's heuristics \
+then you can!  If this is on, then Cbc will get to the root node and then \
+hand over to Cplex.  If heuristics find a solution this can be significantly \
+quicker.  You will probably want to switch off Cbc's cuts as Cplex thinks \
+they are genuine constraints.  It is also probable that you want to switch \
+off preprocessing, although for difficult problems it is worth trying \
+both."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("cpp!Generate", "Generates C++ code",
+                        -1, 50000, CLP_PARAM_INT_CPP, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Once you like what the stand-alone solver does then this allows \
+you to generate user_driver.cpp which approximates the code.  \
+0 gives simplest driver, 1 generates saves and restores, 2 \
+generates saves and restores even for variables at default value. \
+4 bit in cbc generates size dependent code rather than computed values.  \
+This is now deprecated as you can call stand-alone solver - see \
+Cbc/examples/driver4.cpp."
+     );
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("crash", "Whether to create basis for problem",
+                        "off", CLP_PARAM_STR_CRASH);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("so!low_halim");
+     parameters[numberParameters-1].append("lots");
+#ifdef CLP_INHERIT_MODE
+     parameters[numberParameters-1].append("dual");
+     parameters[numberParameters-1].append("dw");
+     parameters[numberParameters-1].append("idiot");
+#else
+     parameters[numberParameters-1].append("idiot1");
+     parameters[numberParameters-1].append("idiot2");
+     parameters[numberParameters-1].append("idiot3");
+     parameters[numberParameters-1].append("idiot4");
+     parameters[numberParameters-1].append("idiot5");
+     parameters[numberParameters-1].append("idiot6");
+     parameters[numberParameters-1].append("idiot7");
+#endif
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If crash is set on and there is an all slack basis then Clp will flip or put structural\
+ variables into basis with the aim of getting dual feasible.  On the whole dual seems to be\
+ better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
+I have also added a variant due to Solow and Halim which is as on but just flip.");
+     parameters[numberParameters++] =
+          CbcOrClpParam("cross!over", "Whether to get a basic solution after barrier",
+                        "on", CLP_PARAM_STR_CROSSOVER);
+     parameters[numberParameters-1].append("off");
+     parameters[numberParameters-1].append("maybe");
+     parameters[numberParameters-1].append("presolve");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Interior point algorithms do not obtain a basic solution (and \
+the feasibility criterion is a bit suspect (JJF)).  This option will crossover \
+to a basic solution suitable for ranging or branch and cut.  With the current state \
+of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \
+presolve as well) - the option maybe does this."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("csv!Statistics", "Create one line of statistics",
+                        CLP_PARAM_ACTION_CSVSTATISTICS, 2, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This appends statistics to given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  Adds header if file empty or does not exist."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("cutD!epth", "Depth in tree at which to do cuts",
+                        -1, 999999, CBC_PARAM_INT_CUTDEPTH);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Cut generators may be - off, on only at root, on if they look possible \
+and on.  If they are done every node then that is that, but it may be worth doing them \
+every so often.  The original method was every so many nodes but it is more logical \
+to do it whenever depth in tree is a multiple of K.  This option does that and defaults \
+to -1 (off -> code decides)."
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("cutL!ength", "Length of a cut",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_CUTLENGTH);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "At present this only applies to Gomory cuts. -1 (default) leaves as is. \
+Any value >0 says that all cuts <= this length can be generated both at \
+root node and in tree. 0 says to use some dynamic lengths.  If value >=10,000,000 \
+then the length in tree is value%10000000 - so 10000100 means unlimited length \
+at root and 100 in tree."
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("cuto!ff", "All solutions must be better than this",
+                        -1.0e60, 1.0e60, CBC_PARAM_DBL_CUTOFF);
+     parameters[numberParameters-1].setDoubleValue(1.0e50);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "All solutions must be better than this value (in a minimization sense).  \
+This is also set by code whenever it obtains a solution and is set to value of \
+objective for solution minus cutoff increment."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("cuts!OnOff", "Switches all cuts on or off",
+                        "off", CBC_PARAM_STR_CUTSSTRATEGY);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This can be used to switch on or off all cuts (apart from Reduce and Split).  Then you can do \
+individual ones off or on \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("debug!In", "read valid solution from file",
+                        CLP_PARAM_ACTION_DEBUG, 7, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will read a solution file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.\n\n\
+If set to create it will create a file called debug.file  after search.\n\n\
+The idea is that if you suspect a bad cut generator \
+you can do a good run with debug set to 'create' and then switch on the cuts you suspect and \
+re-run with debug set to 'debug.file'  The create case has same effect as saveSolution."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("decomp!ose", "Whether to try decomposition",
+                        -COIN_INT_MAX, COIN_INT_MAX, CLP_PARAM_INT_DECOMPOSE_BLOCKS, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "0 - off, 1 choose blocks >1 use as blocks \
+Dantzig Wolfe if primal, Benders if dual \
+- uses sprint pass for number of passes"
+     );
+     parameters[numberParameters-1].setIntValue(0);
+#if CLP_MULTIPLE_FACTORIZATIONS >0
+     parameters[numberParameters++] =
+          CbcOrClpParam("dense!Threshold", "Whether to use dense factorization",
+                        -1, 10000, CBC_PARAM_INT_DENSE, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If processed problem <= this use dense factorization"
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+#endif
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("depth!MiniBab", "Depth at which to try mini BAB",
+                        -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_DEPTHMINIBAB);
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Rather a complicated parameter but can be useful. -1 means off for large problems but on as if -12 for problems where rows+columns<500, -2 \
+means use Cplex if it is linked in.  Otherwise if negative then go into depth first complete search fast branch and bound when depth>= -value-2 (so -3 will use this at depth>=1).  This mode is only switched on after 500 nodes.  If you really want to switch it off for small problems then set this to -999.  If >=0 the value doesn't matter very much.  The code will do approximately 100 nodes of fast branch and bound every now and then at depth>=5.  The actual logic is too twisted to describe here."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dextra3", "Extra double parameter 3",
+                        -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA3, 0);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("dextra4", "Extra double parameter 4",
+                        -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA4, 0);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("dextra5", "Extra double parameter 5",
+                        -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA5, 0);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("Dins", "Whether to try Distance Induced Neighborhood Search",
+                        "off", CBC_PARAM_STR_DINS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].append("often");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on Distance induced neighborhood Search. \
+See Rounding for meaning of on,both,before"
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("direction", "Minimize or Maximize",
+                        "min!imize", CLP_PARAM_STR_DIRECTION);
+     parameters[numberParameters-1].append("max!imize");
+     parameters[numberParameters-1].append("zero");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is minimize - use 'direction maximize' for maximization.\n\
+You can also use the parameters 'maximize' or 'minimize'."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("directory", "Set Default directory for import etc.",
+                        CLP_PARAM_ACTION_DIRECTORY);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sets the directory which import, export, saveModel, restoreModel etc will use.\
+  It is initialized to './'"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dirSample", "Set directory where the COIN-OR sample problems are.",
+                        CLP_PARAM_ACTION_DIRSAMPLE, 7, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sets the directory where the COIN-OR sample problems reside. It is\
+ used only when -unitTest is passed to clp. clp will pick up the test problems\
+ from this directory.\
+ It is initialized to '../../Data/Sample'"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dirNetlib", "Set directory where the netlib problems are.",
+                        CLP_PARAM_ACTION_DIRNETLIB, 7, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sets the directory where the netlib problems reside. One can get\
+ the netlib problems from COIN-OR or from the main netlib site. This\
+ parameter is used only when -netlib is passed to clp. clp will pick up the\
+ netlib problems from this directory. If clp is built without zlib support\
+ then the problems must be uncompressed.\
+ It is initialized to '../../Data/Netlib'"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dirMiplib", "Set directory where the miplib 2003 problems are.",
+                        CBC_PARAM_ACTION_DIRMIPLIB, 7, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sets the directory where the miplib 2003 problems reside. One can\
+ get the miplib problems from COIN-OR or from the main miplib site. This\
+ parameter is used only when -miplib is passed to cbc. cbc will pick up the\
+ miplib problems from this directory. If cbc is built without zlib support\
+ then the problems must be uncompressed.\
+ It is initialized to '../../Data/miplib3'"
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("diveO!pt", "Diving options",
+                        -1, 200000, CBC_PARAM_INT_DIVEOPT, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If >2 && <20 then modify diving options - \
+	 \n\t3 only at root and if no solution,  \
+	 \n\t4 only at root and if this heuristic has not got solution, \
+	 \n\t5 decay only if no solution, \
+	 \n\t6 if depth <3 or decay, \
+	 \n\t7 run up to 2 times if solution found 4 otherwise, \
+	 \n\t>10 All only at root (DivingC normal as value-10), \
+	 \n\t>20 All with value-20)."
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("diveS!olves", "Diving solve option",
+                        -1, 200000, CBC_PARAM_INT_DIVEOPTSOLVES, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If >0 then do up to this many solves.  Last digit is ignored \
+and used for extra options - \
+	 \n\t1-3 allow fixing of satisfied integers (but not at bound) \
+	 \n\t1 switch off above for that dive if goes infeasible \
+	 \n\t2 switch off above permanently if goes infeasible"
+     );
+     parameters[numberParameters-1].setIntValue(100);
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingS!ome", "Whether to try Diving heuristics",
+                        "off", CBC_PARAM_STR_DIVINGS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on a random diving heuristic at various times. \
+C - Coefficient, F - Fractional, G - Guided, L - LineSearch, P - PseudoCost, V - VectorLength. \
+You may prefer to use individual on/off \
+See Rounding for meaning of on,both,before"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingC!oefficient", "Whether to try DiveCoefficient",
+                        "off", CBC_PARAM_STR_DIVINGC);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingF!ractional", "Whether to try DiveFractional",
+                        "off", CBC_PARAM_STR_DIVINGF);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingG!uided", "Whether to try DiveGuided",
+                        "off", CBC_PARAM_STR_DIVINGG);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingL!ineSearch", "Whether to try DiveLineSearch",
+                        "off", CBC_PARAM_STR_DIVINGL);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingP!seudoCost", "Whether to try DivePseudoCost",
+                        "off", CBC_PARAM_STR_DIVINGP);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters++] =
+          CbcOrClpParam("DivingV!ectorLength", "Whether to try DiveVectorLength",
+                        "off", CBC_PARAM_STR_DIVINGV);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters++] =
+          CbcOrClpParam("doH!euristic", "Do heuristics before any preprocessing",
+                        CBC_PARAM_ACTION_DOHEURISTIC, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally heuristics are done in branch and bound.  It may be useful to do them outside. \
+Only those heuristics with 'both' or 'before' set will run.  \
+Doing this may also set cutoff, which can help with preprocessing."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("dualB!ound", "Initially algorithm acts as if no \
+gap between bounds exceeds this value",
+                        1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALBOUND);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The dual algorithm in Clp is a single phase algorithm as opposed to a two phase\
+ algorithm where you first get feasible then optimal.  If a problem has both upper and\
+ lower bounds then it is trivial to get dual feasible by setting non basic variables\
+ to correct bound.  If the gap between the upper and lower bounds of a variable is more\
+ than the value of dualBound Clp introduces fake bounds so that it can make the problem\
+ dual feasible.  This has the same effect as a composite objective function in the\
+ primal algorithm.  Too high a value may mean more iterations, while too low a bound means\
+ the code may go all the way and then have to increase the bounds.  OSL had a heuristic to\
+ adjust bounds, maybe we need that here."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dualize", "Solves dual reformulation",
+                        0, 4, CLP_PARAM_INT_DUALIZE, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Don't even think about it."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dualP!ivot", "Dual pivot choice algorithm",
+                        "auto!matic", CLP_PARAM_STR_DUALPIVOT, 7, 1);
+     parameters[numberParameters-1].append("dant!zig");
+     parameters[numberParameters-1].append("partial");
+     parameters[numberParameters-1].append("steep!est");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Clp can use any pivot selection algorithm which the user codes as long as it\
+ implements the features in the abstract pivot base class.  The Dantzig method is implemented\
+ to show a simple method but its use is deprecated.  Steepest is the method of choice and there\
+ are two variants which keep all weights updated but only scan a subset each iteration.\
+ Partial switches this on while automatic decides at each iteration based on information\
+ about the factorization."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("dualS!implex", "Do dual simplex algorithm",
+                        CLP_PARAM_ACTION_DUALSIMPLEX);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This command solves the continuous relaxation of the current model using the dual steepest edge algorithm.\
+The time and iterations may be affected by settings such as presolve, scaling, crash\
+ and also by dual pivot method, fake bound on variables and dual and primal tolerances."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("dualT!olerance", "For an optimal solution \
+no dual infeasibility may exceed this value",
+                        1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally the default tolerance is fine, but you may want to increase it a\
+ bit if a dual run seems to be having a hard time.  One method which can be faster is \
+to use a large tolerance e.g. 1.0e-4 and dual and then clean up problem using primal and the \
+correct tolerance (remembering to switch off presolve for this final short clean up phase)."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("dw!Heuristic", "Whether to try DW heuristic",
+                        "off", CBC_PARAM_STR_DW);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+      "See Rounding for meaning of on,both,before"
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("either!Simplex", "Do dual or primal simplex algorithm",
+                        CLP_PARAM_ACTION_EITHERSIMPLEX);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This command solves the continuous relaxation of the current model using the dual or primal algorithm,\
+ based on a dubious analysis of model."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("end", "Stops clp execution",
+                        CLP_PARAM_ACTION_EXIT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This stops execution ; end, exit, quit and stop are synonyms"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("environ!ment", "Read commands from environment",
+                        CLP_PARAM_ACTION_ENVIRONMENT, 7, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This starts reading from environment variable CBC_CLP_ENVIRONMENT."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("error!sAllowed", "Whether to allow import errors",
+                        "off", CLP_PARAM_STR_ERRORSALLOWED, 3);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is not to use any model which had errors when reading the mps file.\
+  Setting this to 'on' will allow all errors from which the code can recover\
+ simply by ignoring the error.  There are some errors from which the code can not recover \
+e.g. no ENDATA.  This has to be set before import i.e. -errorsAllowed on -import xxxxxx.mps."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("exit", "Stops clp execution",
+                        CLP_PARAM_ACTION_EXIT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This stops the execution of Clp, end, exit, quit and stop are synonyms"
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("exper!iment", "Whether to use testing features",
+                        -1, 200, CBC_PARAM_INT_EXPERIMENT, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Defines how adventurous you want to be in using new ideas. \
+0 then no new ideas, 1 fairly sensible, 2 a bit dubious, 3 you are on your own!"
+     );
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("expensive!Strong", "Whether to do even more strong branching",
+                        0, COIN_INT_MAX, CBC_PARAM_INT_STRONG_STRATEGY, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+      "Strategy for extra strong branching \n\
+\n\t0 - normal\n\
+\n\twhen to do all fractional\n\
+\n\t1 - root node\n\
+\n\t2 - depth less than modifier\n\
+\n\t4 - if objective == best possible\n\
+\n\t6 - as 2+4\n\
+\n\twhen to do all including satisfied\n\
+\n\t10 - root node etc.\n\
+\n\tIf >=100 then do when depth <= strategy/100 (otherwise 5)"
+     );
+     parameters[numberParameters-1].setIntValue(0);
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("export", "Export model as mps file",
+                        CLP_PARAM_ACTION_EXPORT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will write an MPS format file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.mps'.  \
+It can be useful to get rid of the original names and go over to using Rnnnnnnn and Cnnnnnnn.  This can be done by setting 'keepnames' off before importing mps file."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("extra1", "Extra integer parameter 1",
+                        -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA1, 0);
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("extra2", "Extra integer parameter 2",
+                        -100, COIN_INT_MAX, CBC_PARAM_INT_EXTRA2, 0);
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("extra3", "Extra integer parameter 3",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA3, 0);
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("extra4", "Extra integer parameter 4",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA4, 0);
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on yet more special options!! \
+The bottom digit is a strategy when to used shadow price stuff e.g. 3 \
+means use until a solution is found.  The next two digits say what sort \
+of dual information to use.  After that it goes back to powers of 2 so -\n\
+\n\t1000 - switches on experimental hotstart\n\
+\n\t2,4,6000 - switches on experimental methods of stopping cuts\n\
+\n\t8000 - increase minimum drop gradually\n\
+\n\t16000 - switches on alternate gomory criterion"
+     );
+     parameters[numberParameters++] =
+       CbcOrClpParam("extraV!ariables", "Allow creation of extra integer variables",
+		     -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA_VARIABLES, 0);
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on creation of extra integer variables \
+to gather all variables with same cost."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("fact!orization", "Which factorization to use",
+                        "normal", CLP_PARAM_STR_FACTORIZATION);
+     parameters[numberParameters-1].append("dense");
+     parameters[numberParameters-1].append("simple");
+     parameters[numberParameters-1].append("osl");
+     parameters[numberParameters-1].setLonghelp
+     (
+#ifndef ABC_INHERIT
+          "The default is to use the normal CoinFactorization, but \
+other choices are a dense one, osl's or one designed for small problems."
+#else
+          "Normally the default is to use the normal CoinFactorization, but \
+other choices are a dense one, osl's or one designed for small problems. \
+However if at Aboca then the default is CoinAbcFactorization and other choices are \
+a dense one, one designed for small problems or if enabled a long factorization."
+#endif
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("fakeB!ound", "All bounds <= this value - DEBUG",
+                        1.0, 1.0e15, CLP_PARAM_ACTION_FAKEBOUND, 0);
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("feas!ibilityPump", "Whether to try Feasibility Pump",
+                        "off", CBC_PARAM_STR_FPUMP);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on feasibility pump heuristic at root. This is due to Fischetti, Lodi and Glover \
+and uses a sequence of Lps to try and get an integer feasible solution. \
+Some fine tuning is available by passFeasibilityPump and also pumpTune. \
+See Rounding for meaning of on,both,before"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("fix!OnDj", "Try heuristic based on fixing variables with \
+reduced costs greater than this",
+                        -1.0e20, 1.0e20, CBC_PARAM_DBL_DJFIX, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If this is set integer variables with reduced costs greater than this will be fixed \
+before branch and bound - use with extreme caution!"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("flow!CoverCuts", "Whether to use Flow Cover cuts",
+                        "off", CBC_PARAM_STR_FLOWCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].setFakeKeyWord(3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on flow cover cuts (either at root or in entire tree) \
+See branchAndCut for information on options. \
+Can also enter testing values by plusnn (==ifmove)"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("force!Solution", "Whether to use given solution as crash for BAB",
+                        -1, 20000000, CLP_PARAM_INT_USESOLUTION);
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
+If 0 then just tries to set as best solution \
+If >1 then also does that many nodes on fixed problem."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("fraction!forBAB", "Fraction in feasibility pump",
+                        1.0e-5, 1.1, CBC_PARAM_DBL_SMALLBAB, 1);
+     parameters[numberParameters-1].setDoubleValue(0.5);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "After a pass in feasibility pump, variables which have not moved \
+about are fixed and if the preprocessed model is small enough a few nodes \
+of branch and bound are done on reduced problem.  Small problem has to be less than this fraction of original."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("gamma!(Delta)", "Whether to regularize barrier",
+                        "off", CLP_PARAM_STR_GAMMA, 7, 1);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("gamma");
+     parameters[numberParameters-1].append("delta");
+     parameters[numberParameters-1].append("onstrong");
+     parameters[numberParameters-1].append("gammastrong");
+     parameters[numberParameters-1].append("deltastrong");
+#endif
+#ifdef COIN_HAS_CBC
+      parameters[numberParameters++] =
+          CbcOrClpParam("GMI!Cuts", "Whether to use alternative Gomory cuts",
+                        "off", CBC_PARAM_STR_GMICUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("endonly");
+     parameters[numberParameters-1].append("long");
+     parameters[numberParameters-1].append("longroot");
+     parameters[numberParameters-1].append("longifmove");
+     parameters[numberParameters-1].append("forceLongOn");
+     parameters[numberParameters-1].append("longendonly");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on an alternative Gomory cut generator (either at root or in entire tree) \
+This version is by Giacomo Nannicini and may be more robust \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("gomory!Cuts", "Whether to use Gomory cuts",
+                        "off", CBC_PARAM_STR_GOMORYCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].append("forceandglobal");
+     parameters[numberParameters-1].append("forceLongOn");
+     parameters[numberParameters-1].append("long");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The original cuts - beware of imitations!  Having gone out of favor, they are now more \
+fashionable as LP solvers are more robust and they interact well with other cuts.  They will almost always \
+give cuts (although in this executable they are limited as to number of variables in cut).  \
+However the cuts may be dense so it is worth experimenting (Long allows any length). \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("greedy!Heuristic", "Whether to use a greedy heuristic",
+                        "off", CBC_PARAM_STR_GREEDY);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     //parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Switches on a greedy heuristic which will try and obtain a solution.  It may just fix a \
+percentage of variables and then try a small branch and cut run. \
+See Rounding for meaning of on,both,before"
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
+                        CLP_PARAM_ACTION_GMPL_SOLUTION);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Will write a glpk solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
+If problem created from gmpl model - will do any reports."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("heur!isticsOnOff", "Switches most heuristics on or off",
+                        "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This can be used to switch on or off all heuristics.  Then you can do \
+individual ones off or on.  CbcTreeLocal is not included as it dramatically \
+alters search."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("help", "Print out version, non-standard options and some help",
+                        CLP_PARAM_ACTION_HELP, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This prints out some help to get user started.  If you have printed this then \
+you should be past that stage:-)"
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("hOp!tions", "Heuristic options",
+                        -9999999, 9999999, CBC_PARAM_INT_HOPTIONS, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "1 says stop heuristic immediately allowable gap reached. \
+Others are for feasibility pump - \
+2 says do exact number of passes given, \
+4 only applies if initial cutoff given and says relax after 50 passes, \
+while 8 will adapt cutoff rhs after first solution if it looks as if code is stalling."
+     );
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("hot!StartMaxIts", "Maximum iterations on hot start",
+                        0, COIN_INT_MAX, CBC_PARAM_INT_MAXHOTITS);
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("idiot!Crash", "Whether to try idiot crash",
+                        -1, 99999999, CLP_PARAM_INT_IDIOT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This is a type of 'crash' which works well on some homogeneous problems.\
+ It works best on problems with unit elements and rhs but will do something to any model.  It should only be\
+ used before primal.  It can be set to -1 when the code decides for itself whether to use it,\
+ 0 to switch off or n > 0 to do n passes."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("import", "Import model from mps file",
+                        CLP_PARAM_ACTION_IMPORT, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will read an MPS format file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  If you have libgz then it can read compressed\
+ files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'.  \
+If 'keepnames' is off, then names are dropped -> Rnnnnnnn and Cnnnnnnn."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("inc!rement", "A valid solution must be at least this \
+much better than last integer solution",
+                        -1.0e20, 1.0e20, CBC_PARAM_DBL_INCREMENT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Whenever a solution is found the bound on solutions is set to solution (in a minimization\
+sense) plus this.  If it is not set then the code will try and work one out e.g. if \
+all objective coefficients are multiples of 0.01 and only integer variables have entries in \
+objective then this can be set to 0.01.  Be careful if you set this negative!"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("inf!easibilityWeight", "Each integer infeasibility is expected \
+to cost this much",
+                        0.0, 1.0e20, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "A primitive way of deciding which node to explore next.  Satisfying each integer infeasibility is \
+expected to cost this much."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("initialS!olve", "Solve to continuous",
+                        CLP_PARAM_ACTION_SOLVECONTINUOUS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This just solves the problem to continuous - without adding any cuts"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("integerT!olerance", "For an optimal solution \
+no integer variable may be this away from an integer value",
+                        1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Beware of setting this smaller than the primal tolerance."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("keepN!ames", "Whether to keep names from import",
+                        "on", CLP_PARAM_STR_KEEPNAMES);
+     parameters[numberParameters-1].append("off");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "It saves space to get rid of names so if you need to you can set this to off.  \
+This needs to be set before the import of model - so -keepnames off -import xxxxx.mps."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("KKT", "Whether to use KKT factorization",
+                        "off", CLP_PARAM_STR_KKT, 7, 1);
+     parameters[numberParameters-1].append("on");
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("knapsack!Cuts", "Whether to use Knapsack cuts",
+                        "off", CBC_PARAM_STR_KNAPSACKCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].append("forceandglobal");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on knapsack cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
+                        "off", CBC_PARAM_STR_LAGOMORYCUTS);
+     parameters[numberParameters-1].append("endonlyroot");
+     parameters[numberParameters-1].append("endcleanroot");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("endonly");
+     parameters[numberParameters-1].append("endclean");
+     parameters[numberParameters-1].append("endboth");
+     parameters[numberParameters-1].append("onlyaswell");
+     parameters[numberParameters-1].append("cleanaswell");
+     parameters[numberParameters-1].append("bothaswell");
+     parameters[numberParameters-1].append("onlyinstead");
+     parameters[numberParameters-1].append("cleaninstead");
+     parameters[numberParameters-1].append("bothinstead");
+     parameters[numberParameters-1].append("onlyaswellroot");
+     parameters[numberParameters-1].append("cleanaswellroot");
+     parameters[numberParameters-1].append("bothaswellroot");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
+by Matteo Fischetti & Domenico Salvagnin.  This simplification \
+just uses original constraints while modifying objective using other cuts. \
+So you don't use messy constraints generated by Gomory etc. \
+A variant is to allow non messy cuts e.g. clique cuts. \
+So 'only' does this while clean also allows integral valued cuts.  \
+'End' is recommended which waits until other cuts have finished and then \
+does a few passes. \
+The length options for gomory cuts are used."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
+                        "off", CBC_PARAM_STR_LATWOMIRCUTS);
+     parameters[numberParameters-1].append("endonlyroot");
+     parameters[numberParameters-1].append("endcleanroot");
+     parameters[numberParameters-1].append("endbothroot");
+     parameters[numberParameters-1].append("endonly");
+     parameters[numberParameters-1].append("endclean");
+     parameters[numberParameters-1].append("endboth");
+     parameters[numberParameters-1].append("onlyaswell");
+     parameters[numberParameters-1].append("cleanaswell");
+     parameters[numberParameters-1].append("bothaswell");
+     parameters[numberParameters-1].append("onlyinstead");
+     parameters[numberParameters-1].append("cleaninstead");
+     parameters[numberParameters-1].append("bothinstead");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This is a lagrangean relaxation for TwoMir cuts.  See \
+lagomoryCuts for description of options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
+                        "off", CBC_PARAM_STR_LANDPCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Lift and project cuts. \
+May be slow \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("local!TreeSearch", "Whether to use local treesearch",
+                        "off", CBC_PARAM_STR_LOCALTREE);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on a local search algorithm when a solution is found.  This is from \
+Fischetti and Lodi and is not really a heuristic although it can be used as one. \
+When used from Coin solve it has limited functionality.  It is not switched on when \
+heuristics are switched on."
+     );
+#endif
+#ifndef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("log!Level", "Level of detail in Solver output",
+                        -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
+#else
+     parameters[numberParameters++] =
+          CbcOrClpParam("log!Level", "Level of detail in Coin branch and Cut output",
+                        -63, 63, CLP_PARAM_INT_LOGLEVEL);
+     parameters[numberParameters-1].setIntValue(1);
+#endif
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If 0 then there should be no output in normal circumstances.  1 is probably the best\
+ value for most uses, while 2 and 3 give more information."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("max!imize", "Set optimization direction to maximize",
+                        CLP_PARAM_ACTION_MAXIMIZE, 7);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is minimize - use 'maximize' for maximization.\n\
+You can also use the parameters 'direction maximize'."
+     );
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("maxF!actor", "Maximum number of iterations between \
+refactorizations",
+                        1, 999999, CLP_PARAM_INT_MAXFACTOR);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If this is at its initial value of 200 then in this executable clp will guess at a\
+ value to use.  Otherwise the user can set a value.  The code may decide to re-factorize\
+ earlier for accuracy."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("maxIt!erations", "Maximum number of iterations before \
+stopping",
+                        0, 2147483647, CLP_PARAM_INT_MAXITERATION);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This can be used for testing purposes.  The corresponding library call\n\
+      \tsetMaximumIterations(value)\n can be useful.  If the code stops on\
+ seconds or by an interrupt this will be treated as stopping on maximum iterations.  This is ignored in branchAndCut - use maxN!odes."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("maxN!odes", "Maximum number of nodes to do",
+                        -1, 2147483647, CBC_PARAM_INT_MAXNODES);
+     parameters[numberParameters-1].setLonghelp 
+     (
+          "This is a repeatable way to limit search.  Normally using time is easier \
+but then the results may not be repeatable."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("maxSaved!Solutions", "Maximum number of solutions to save",
+                        0, 2147483647, CBC_PARAM_INT_MAXSAVEDSOLS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Number of solutions to save."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("maxSo!lutions", "Maximum number of solutions to get",
+                        1, 2147483647, CBC_PARAM_INT_MAXSOLS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "You may want to stop after (say) two solutions or an hour.  \
+This is checked every node in tree, so it is possible to get more solutions from heuristics."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("min!imize", "Set optimization direction to minimize",
+                        CLP_PARAM_ACTION_MINIMIZE, 7);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is minimize - use 'maximize' for maximization.\n\
+This should only be necessary if you have previously set maximization \
+You can also use the parameters 'direction minimize'."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("mipO!ptions", "Dubious options for mip",
+                        0, COIN_INT_MAX, CBC_PARAM_INT_MIPOPTIONS, 0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("more!MipOptions", "More dubious options for mip",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMIPOPTIONS, 0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("more2!MipOptions", "More more dubious options for mip",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMOREMIPOPTIONS, 0);
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("mixed!IntegerRoundingCuts", "Whether to use Mixed Integer Rounding cuts",
+                        "off", CBC_PARAM_STR_MIXEDCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on mixed integer rounding cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("mess!ages", "Controls if Clpnnnn is printed",
+                        "off", CLP_PARAM_STR_MESSAGES);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     ("The default behavior is to put out messages such as:\n\
+   Clp0005 2261  Objective 109.024 Primal infeas 944413 (758)\n\
+but this program turns this off to make it look more friendly.  It can be useful\
+ to turn them back on if you want to be able to 'grep' for particular messages or if\
+ you intend to override the behavior of a particular message.  This only affects Clp not Cbc."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("miplib", "Do some of miplib test set",
+                        CBC_PARAM_ACTION_MIPLIB, 3, 1);
+#ifdef COIN_HAS_CBC
+      parameters[numberParameters++] =
+          CbcOrClpParam("mips!tart", "reads an initial feasible solution from file",
+                        CBC_PARAM_ACTION_MIPSTART);
+     parameters[numberParameters-1].setLonghelp
+     ("\
+The MIPStart allows one to enter an initial integer feasible solution \
+to CBC. Values of the main decision variables which are active (have \
+non-zero values) in this solution are specified in a text  file. The \
+text file format used is the same of the solutions saved by CBC, but \
+not all fields are required to be filled. First line may contain the \
+solution status and will be ignored, remaining lines contain column \
+indexes, names and values as in this example:\n\
+\n\
+Stopped on iterations - objective value 57597.00000000\n\
+      0  x(1,1,2,2)               1 \n\
+      1  x(3,1,3,2)               1 \n\
+      5  v(5,1)                   2 \n\
+      33 x(8,1,5,2)               1 \n\
+      ...\n\
+\n\
+Column indexes are also ignored since pre-processing can change them. \
+There is no need to include values for continuous or integer auxiliary \
+variables, since they can be computed based on main decision variables. \
+Starting CBC with an integer feasible solution can dramatically improve \
+its performance: several MIP heuristics (e.g. RINS) rely on having at \
+least one feasible solution available and can start immediately if the \
+user provides one. Feasibility Pump (FP) is a heuristic which tries to \
+overcome the problem of taking too long to find feasible solution (or \
+not finding at all), but it not always succeeds. If you provide one \
+starting solution you will probably save some time by disabling FP. \
+\n\n\
+Knowledge specific to your problem can be considered to write an \
+external module to quickly produce an initial feasible solution - some \
+alternatives are the implementation of simple greedy heuristics or the \
+solution (by CBC for example) of a simpler model created just to find \
+a feasible solution. \
+\n\n\
+Question and suggestions regarding MIPStart can be directed to\n\
+haroldo.santos@gmail.com.\
+");
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("moreS!pecialOptions", "Yet more dubious options for Simplex - see ClpSimplex.hpp",
+                        0, COIN_INT_MAX, CLP_PARAM_INT_MORESPECIALOPTIONS, 0);
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("moreT!une", "Yet more dubious ideas for feasibility pump",
+                        0, 100000000, CBC_PARAM_INT_FPUMPTUNE2, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Yet more ideas for Feasibility Pump \n\
+\t/100000 == 1 use box constraints and original obj in cleanup\n\
+\t/1000 == 1 Pump will run twice if no solution found\n\
+\t/1000 == 2 Pump will only run after root cuts if no solution found\n\
+\t/1000 >10 as above but even if solution found\n\
+\t/100 == 1,3.. exact 1.0 for objective values\n\
+\t/100 == 2,3.. allow more iterations per pass\n\
+\t n fix if value of variable same for last n iterations."
+     );
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions",
+                        0, 100000000, CBC_PARAM_INT_MULTIPLEROOTS, 0);
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Do (in parallel if threads enabled) the root phase this number of times \
+ and collect all solutions and cuts generated.  The actual format is aabbcc \
+where aa is number of extra passes, if bb is non zero \
+then it is number of threads to use (otherwise uses threads setting) and \
+cc is number of times to do root phase.  Yet another one from the Italian idea factory \
+(This time - Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \
+and Andrea Tramontani). \
+The solvers do not interact with each other.  However if extra passes are specified \
+then cuts are collected and used in later passes - so there is interaction there." 
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("naive!Heuristics", "Whether to try some stupid heuristic",
+                        "off", CBC_PARAM_STR_NAIVE, 7, 1);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Really silly stuff e.g. fix all integers with costs to zero!. \
+Doh option does heuristic before preprocessing"     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("netlib", "Solve entire netlib test set",
+                        CLP_PARAM_ACTION_NETLIB_EITHER, 3, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This exercises the unit test for clp and then solves the netlib test set using dual or primal.\
+The user can set options before e.g. clp -presolve off -netlib"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("netlibB!arrier", "Solve entire netlib test set with barrier",
+                        CLP_PARAM_ACTION_NETLIB_BARRIER, 3, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This exercises the unit test for clp and then solves the netlib test set using barrier.\
+The user can set options before e.g. clp -kkt on -netlib"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("netlibD!ual", "Solve entire netlib test set (dual)",
+                        CLP_PARAM_ACTION_NETLIB_DUAL, 3, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This exercises the unit test for clp and then solves the netlib test set using dual.\
+The user can set options before e.g. clp -presolve off -netlib"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("netlibP!rimal", "Solve entire netlib test set (primal)",
+                        CLP_PARAM_ACTION_NETLIB_PRIMAL, 3, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This exercises the unit test for clp and then solves the netlib test set using primal.\
+The user can set options before e.g. clp -presolve off -netlibp"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("netlibT!une", "Solve entire netlib test set with 'best' algorithm",
+                        CLP_PARAM_ACTION_NETLIB_TUNE, 3, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This exercises the unit test for clp and then solves the netlib test set using whatever \
+works best.  I know this is cheating but it also stresses the code better by doing a \
+mixture of stuff.  The best algorithm was chosen on a Linux ThinkPad using native cholesky \
+with University of Florida ordering."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("network", "Tries to make network matrix",
+                        CLP_PARAM_ACTION_NETWORK, 7, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Clp will go faster if the matrix can be converted to a network.  The matrix\
+ operations may be a bit faster with more efficient storage, but the main advantage\
+ comes from using a network factorization.  It will probably not be as fast as a \
+specialized network code."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("nextB!estSolution", "Prints next best saved solution to file",
+                        CLP_PARAM_ACTION_NEXTBESTSOLUTION);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "To write best solution, just use solution.  This prints next best (if exists) \
+ and then deletes it. \
+ This will write a primitive solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'stdout'.  The amount of output can be varied using printi!ngOptions or printMask."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("node!Strategy", "What strategy to use to select nodes",
+                        "hybrid", CBC_PARAM_STR_NODESTRATEGY);
+     parameters[numberParameters-1].append("fewest");
+     parameters[numberParameters-1].append("depth");
+     parameters[numberParameters-1].append("upfewest");
+     parameters[numberParameters-1].append("downfewest");
+     parameters[numberParameters-1].append("updepth");
+     parameters[numberParameters-1].append("downdepth");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally before a solution the code will choose node with fewest infeasibilities. \
+You can choose depth as the criterion.  You can also say if up or down branch must \
+be done first (the up down choice will carry on after solution). \
+Default has now been changed to hybrid which is breadth first on small depth nodes then fewest."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("numberA!nalyze", "Number of analysis iterations",
+                        -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_NUMBERANALYZE, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This says how many iterations to spend at root node analyzing problem. \
+This is a first try and will hopefully become more sophisticated."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("objective!Scale", "Scale factor to apply to objective",
+                        -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If the objective function has some very large values, you may wish to scale them\
+ internally by this amount.  It can also be set by autoscale.  It is applied after scaling.  You are unlikely to need this."
+     );
+     parameters[numberParameters-1].setDoubleValue(1.0);
+#endif
+#ifdef COIN_HAS_CBC
+#ifdef COIN_HAS_NTY
+     parameters[numberParameters++] =
+          CbcOrClpParam("Orbit!alBranching", "Whether to try orbital branching",
+                        "off", CBC_PARAM_STR_ORBITAL);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("strong");
+     parameters[numberParameters-1].append("force");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on Orbital branching. \
+On just adds orbital, strong tries extra fixing in strong branching");
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("outDup!licates", "takes duplicate rows etc out of integer model",
+                        CLP_PARAM_ACTION_OUTDUPROWS, 7, 0);
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("output!Format", "Which output format to use",
+                        1, 6, CLP_PARAM_INT_OUTPUTFORMAT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally export will be done using normal representation for numbers and two values\
+ per line.  You may want to do just one per line (for grep or suchlike) and you may wish\
+ to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal.\
+ otherwise odd values gives one value per line, even two.  Values 1,2 give normal format, 3,4\
+ gives greater precision, while 5,6 give IEEE values.  When used for exporting a basis 1 does not save \
+values, 2 saves values, 3 with greater accuracy and 4 in IEEE."
+     );
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("para!metrics", "Import data from file and do parametrics",
+                        CLP_PARAM_ACTION_PARAMETRICS, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will read a file with parametric data from the given file name \
+and then do parametrics.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  This can not read from compressed files. \
+File is in modified csv format - a line ROWS will be followed by rows data \
+while a line COLUMNS will be followed by column data.  The last line \
+should be ENDATA. The ROWS line must exist and is in the format \
+ROWS, inital theta, final theta, interval theta, n where n is 0 to get \
+CLPI0062 message at interval or at each change of theta \
+and 1 to get CLPI0063 message at each iteration.  If interval theta is 0.0 \
+or >= final theta then no interval reporting.  n may be missed out when it is \
+taken as 0.  If there is Row data then \
+there is a headings line with allowed headings - name, number, \
+lower(rhs change), upper(rhs change), rhs(change).  Either the lower and upper \
+fields should be given or the rhs field. \
+The optional COLUMNS line is followed by a headings line with allowed \
+headings - name, number, objective(change), lower(change), upper(change). \
+ Exactly one of name and number must be given for either section and \
+missing ones have value 0.0."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("passC!uts", "Number of cut passes at root node",
+                        -9999999, 9999999, CBC_PARAM_INT_CUTPASS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is 100 passes if less than 500 columns, 100 passes (but \
+stop if drop small if less than 5000 columns, 20 otherwise"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("passF!easibilityPump", "How many passes in feasibility pump",
+                        0, 10000, CBC_PARAM_INT_FPUMPITS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This fine tunes Feasibility Pump by doing more or fewer passes."
+     );
+     parameters[numberParameters-1].setIntValue(20);
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("passP!resolve", "How many passes in presolve",
+                        -200, 100, CLP_PARAM_INT_PRESOLVEPASS, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally Presolve does 10 passes but you may want to do less to make it\
+ more lightweight or do more if improvements are still being made.  As Presolve will return\
+ if nothing is being taken out, you should not normally need to use this fine tuning."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("passT!reeCuts", "Number of cut passes in tree",
+                        -9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is one pass"
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("pertV!alue", "Method of perturbation",
+                        -5000, 102, CLP_PARAM_INT_PERTVALUE, 1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("perturb!ation", "Whether to perturb problem",
+                        "on", CLP_PARAM_STR_PERTURBATION);
+     parameters[numberParameters-1].append("off");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Perturbation helps to stop cycling, but Clp uses other measures for this.\
+  However large problems and especially ones with unit elements and unit rhs or costs\
+ benefit from perturbation.  Normally Clp tries to be intelligent, but you can switch this off.\
+  The Clp library has this off by default.  This program has it on by default."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("PFI", "Whether to use Product Form of Inverse in simplex",
+                        "off", CLP_PARAM_STR_PFI, 7, 0);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "By default clp uses Forrest-Tomlin L-U update.  If you are masochistic you can switch it off."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("pivotAndC!omplement", "Whether to try Pivot and Complement heuristic",
+                        "off", CBC_PARAM_STR_PIVOTANDCOMPLEMENT);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "stuff needed. \
+Doh option does heuristic before preprocessing"     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("pivotAndF!ix", "Whether to try Pivot and Fix heuristic",
+                        "off", CBC_PARAM_STR_PIVOTANDFIX);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "stuff needed. \
+Doh option does heuristic before preprocessing"     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("plus!Minus", "Tries to make +- 1 matrix",
+                        CLP_PARAM_ACTION_PLUSMINUS, 7, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Clp will go slightly faster if the matrix can be converted so that the elements are\
+ not stored and are known to be unit.  The main advantage is memory use.  Clp may automatically\
+ see if it can convert the problem so you should not need to use this."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("pO!ptions", "Dubious print options",
+                        0, COIN_INT_MAX, CLP_PARAM_INT_PRINTOPTIONS, 1);
+     parameters[numberParameters-1].setIntValue(0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If this is > 0 then presolve will give more information and branch and cut will give statistics"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("preO!pt", "Presolve options",
+                        0, COIN_INT_MAX, CLP_PARAM_INT_PRESOLVEOPTIONS, 0);
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("presolve", "Whether to presolve problem",
+                        "on", CLP_PARAM_STR_PRESOLVE);
+     parameters[numberParameters-1].append("off");
+     parameters[numberParameters-1].append("more");
+     parameters[numberParameters-1].append("file");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Presolve analyzes the model to find such things as redundant equations, equations\
+ which fix some variables, equations which can be transformed into bounds etc etc.  For the\
+ initial solve of any problem this is worth doing unless you know that it will have no effect.  \
+on will normally do 5 passes while using 'more' will do 10.  If the problem is very large you may need \
+to write the original to file using 'file'."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("preprocess", "Whether to use integer preprocessing",
+                        "off", CBC_PARAM_STR_PREPROCESS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("save");
+     parameters[numberParameters-1].append("equal");
+     parameters[numberParameters-1].append("sos");
+     parameters[numberParameters-1].append("trysos");
+     parameters[numberParameters-1].append("equalall");
+     parameters[numberParameters-1].append("strategy");
+     parameters[numberParameters-1].append("aggregate");
+     parameters[numberParameters-1].append("forcesos");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This tries to reduce size of model in a similar way to presolve and \
+it also tries to strengthen the model - this can be very useful and is worth trying. \
+ Save option saves on file presolved.mps.  equal will turn <= cliques into \
+==.  sos will create sos sets if all 0-1 in sets (well one extra is allowed) \
+and no overlaps.  trysos is same but allows any number extra.  equalall will turn all \
+valid inequalities into equalities with integer slacks.  strategy is as \
+on but uses CbcStrategy."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("preT!olerance", "Tolerance to use in presolve",
+                        1.0e-20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says the problem is \
+infeasible and you have awkward numbers and you are sure the problem is really feasible."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("primalP!ivot", "Primal pivot choice algorithm",
+                        "auto!matic", CLP_PARAM_STR_PRIMALPIVOT, 7, 1);
+     parameters[numberParameters-1].append("exa!ct");
+     parameters[numberParameters-1].append("dant!zig");
+     parameters[numberParameters-1].append("part!ial");
+     parameters[numberParameters-1].append("steep!est");
+     parameters[numberParameters-1].append("change");
+     parameters[numberParameters-1].append("sprint");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Clp can use any pivot selection algorithm which the user codes as long as it\
+ implements the features in the abstract pivot base class.  The Dantzig method is implemented\
+ to show a simple method but its use is deprecated.  Exact devex is the method of choice and there\
+ are two variants which keep all weights updated but only scan a subset each iteration.\
+ Partial switches this on while change initially does dantzig until the factorization\
+ becomes denser.  This is still a work in progress."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("primalS!implex", "Do primal simplex algorithm",
+                        CLP_PARAM_ACTION_PRIMALSIMPLEX);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This command solves the continuous relaxation of the current model using the primal algorithm.\
+  The default is to use exact devex.\
+ The time and iterations may be affected by settings such as presolve, scaling, crash\
+ and also by column selection  method, infeasibility weight and dual and primal tolerances."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("primalT!olerance", "For an optimal solution \
+no primal infeasibility may exceed this value",
+                        1.0e-20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally the default tolerance is fine, but you may want to increase it a\
+ bit if a primal run seems to be having a hard time"
+     );
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("primalW!eight", "Initially algorithm acts as if it \
+costs this much to be infeasible",
+                        1.0e-20, 1.0e20, CLP_PARAM_DBL_PRIMALWEIGHT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\
+ algorithm where you first get feasible then optimal.  So Clp is minimizing this weight times\
+ the sum of primal infeasibilities plus the true objective function (in minimization sense).\
+  Too high a value may mean more iterations, while too low a bound means\
+ the code may go all the way and then have to increase the weight in order to get feasible.\
+  OSL had a heuristic to\
+ adjust bounds, maybe we need that here."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("printi!ngOptions", "Print options",
+                        "normal", CLP_PARAM_STR_INTPRINT, 3);
+     parameters[numberParameters-1].append("integer");
+     parameters[numberParameters-1].append("special");
+     parameters[numberParameters-1].append("rows");
+     parameters[numberParameters-1].append("all");
+     parameters[numberParameters-1].append("csv");
+     parameters[numberParameters-1].append("bound!ranging");
+     parameters[numberParameters-1].append("rhs!ranging");
+     parameters[numberParameters-1].append("objective!ranging");
+     parameters[numberParameters-1].append("stats");
+     parameters[numberParameters-1].append("boundsint");
+     parameters[numberParameters-1].append("boundsall");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This changes the amount and format of printing a solution:\nnormal - nonzero column variables \n\
+integer - nonzero integer column variables\n\
+special - in format suitable for OsiRowCutDebugger\n\
+rows - nonzero column variables and row activities\n\
+all - all column variables and row activities.\n\
+\nFor non-integer problems 'integer' and 'special' act like 'normal'.  \
+Also see printMask for controlling output."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("printM!ask", "Control printing of solution on a  mask",
+                        CLP_PARAM_ACTION_PRINTMASK, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If set then only those names which match mask are printed in a solution. \
+'?' matches any character and '*' matches any set of characters. \
+ The default is '' i.e. unset so all variables are printed. \
+This is only active if model has names."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("prio!rityIn", "Import priorities etc from file",
+                        CBC_PARAM_ACTION_PRIORITYIN, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will read a file with priorities from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  This can not read from compressed files. \
+File is in csv format with allowed headings - name, number, priority, direction, up, down, solution.  Exactly one of\
+ name and number must be given."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("probing!Cuts", "Whether to use Probing cuts",
+                        "off", CBC_PARAM_STR_PROBINGCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].append("forceonglobal");
+     parameters[numberParameters-1].append("forceOnBut");
+     parameters[numberParameters-1].append("forceOnStrong");
+     parameters[numberParameters-1].append("forceOnButStrong");
+     parameters[numberParameters-1].append("strongRoot");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on probing cuts (either at root or in entire tree) \
+See branchAndCut for information on options. \
+but strong options do more probing"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("proximity!Search", "Whether to do proximity search heuristic",
+                        "off", CBC_PARAM_STR_PROXIMITY);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].append("10");
+     parameters[numberParameters-1].append("100");
+     parameters[numberParameters-1].append("300");
+     // but allow numbers after this (returning 1)
+     parameters[numberParameters-1].setFakeKeyWord(1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on a heuristic which looks for a solution close \
+to incumbent solution (Fischetti and Monaci). \
+See Rounding for meaning of on,both,before. \
+Can also set different maxNode settings by plusnnnn (and are 'on'(on==30))."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("pumpC!utoff", "Fake cutoff for use in feasibility pump",
+                        -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKECUTOFF);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "0.0 off - otherwise add a constraint forcing objective below this value\
+ in feasibility pump"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("pumpI!ncrement", "Fake increment for use in feasibility pump",
+                        -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKEINCREMENT, 1);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "0.0 off - otherwise use as absolute increment to cutoff \
+when solution found in feasibility pump"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("pumpT!une", "Dubious ideas for feasibility pump",
+                        0, 100000000, CBC_PARAM_INT_FPUMPTUNE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This fine tunes Feasibility Pump \n\
+\t>=10000000 use as objective weight switch\n\
+\t>=1000000 use as accumulate switch\n\
+\t>=1000 use index+1 as number of large loops\n\
+\t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR fakeCutoff if set\n\
+\t%100 == 10,20 affects how each solve is done\n\
+\t1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds. \
+If accumulate is on then after a major pass, variables which have not moved \
+are fixed and a small branch and bound is tried."
+     );
+     parameters[numberParameters-1].setIntValue(0);
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("quit", "Stops clp execution",
+                        CLP_PARAM_ACTION_EXIT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This stops the execution of Clp, end, exit, quit and stop are synonyms"
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("randomC!bcSeed", "Random seed for Cbc",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_RANDOMSEED);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sets a random seed for Cbc \
+- 0 says use time of day, -1 is as now."
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("randomi!zedRounding", "Whether to try randomized rounding heuristic",
+                        "off", CBC_PARAM_STR_RANDROUND);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "stuff needed. \
+Doh option does heuristic before preprocessing"     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("randomS!eed", "Random seed for Clp",
+                        0, COIN_INT_MAX, CLP_PARAM_INT_RANDOMSEED);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sets a random seed for Clp \
+- 0 says use time of day."
+     );
+     parameters[numberParameters-1].setIntValue(1234567);
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("ratio!Gap", "Stop when gap between best possible and \
+best less than this fraction of larger of two",
+                        0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);
+     parameters[numberParameters-1].setDoubleValue(0.0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If the gap between best solution and best possible solution is less than this fraction \
+of the objective value at the root node then the search will terminate.  See 'allowableGap' for a \
+way of using absolute value rather than fraction."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("restoreS!olution", "reads solution from file",
+                        CLP_PARAM_ACTION_RESTORESOL);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will read a binary solution file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'solution.file'.  This reads in a file from saveSolution"
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("readSt!ored", "Import stored cuts from file",
+                        CLP_PARAM_ACTION_STOREDFILE, 3, 0);
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("reallyO!bjectiveScale", "Scale factor to apply to objective in place",
+                        -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE2, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "You can set this to -1.0 to test maximization or other to stress code"
+     );
+     parameters[numberParameters-1].setDoubleValue(1.0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("reallyS!cale", "Scales model in place",
+                        CLP_PARAM_ACTION_REALLY_SCALE, 7, 0);
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("reduce!AndSplitCuts", "Whether to use Reduce-and-Split cuts",
+                        "off", CBC_PARAM_STR_REDSPLITCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on reduce and split  cuts (either at root or in entire tree). \
+May be slow \
+See branchAndCut for information on options."
+     );
+      parameters[numberParameters++] =
+          CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
+                        "off", CBC_PARAM_STR_REDSPLIT2CUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("longOn");
+     parameters[numberParameters-1].append("longRoot");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on reduce and split  cuts (either at root or in entire tree) \
+This version is by Giacomo Nannicini based on Francois Margot's version \
+Standard setting only uses rows in tableau <=256, long uses all \
+May be slow \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
+                        "off", CBC_PARAM_STR_REDSPLIT2CUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("longOn");
+     parameters[numberParameters-1].append("longRoot");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on reduce and split  cuts (either at root or in entire tree) \
+This version is by Giacomo Nannicini based on Francois Margot's version \
+Standard setting only uses rows in tableau <=256, long uses all \
+See branchAndCut for information on options."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("residual!CapacityCuts", "Whether to use Residual Capacity cuts",
+                        "off", CBC_PARAM_STR_RESIDCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Residual capacity cuts. \
+See branchAndCut for information on options."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("restore!Model", "Restore model from binary file",
+                        CLP_PARAM_ACTION_RESTORE, 7, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This reads data save by saveModel from the given file.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.prob'."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("reverse", "Reverses sign of objective",
+                        CLP_PARAM_ACTION_REVERSE, 7, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Useful for testing if maximization works correctly"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("rhs!Scale", "Scale factor to apply to rhs and bounds",
+                        -1.0e20, 1.0e20, CLP_PARAM_DBL_RHSSCALE, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
+ internally by this amount.  It can also be set by autoscale.  This should not be needed."
+     );
+     parameters[numberParameters-1].setDoubleValue(1.0);
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("Rens", "Whether to try Relaxation Enforced Neighborhood Search",
+                        "off", CBC_PARAM_STR_RENS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].append("200");
+     parameters[numberParameters-1].append("1000");
+     parameters[numberParameters-1].append("10000");
+     parameters[numberParameters-1].append("dj");
+     parameters[numberParameters-1].append("djbefore");
+     parameters[numberParameters-1].append("usesolution");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on Relaxation enforced neighborhood Search. \
+on just does 50 nodes \
+200 or 1000 does that many nodes. \
+Doh option does heuristic before preprocessing"     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("Rins", "Whether to try Relaxed Induced Neighborhood Search",
+                        "off", CBC_PARAM_STR_RINS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].append("often");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on Relaxed induced neighborhood Search. \
+Doh option does heuristic before preprocessing"     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("round!ingHeuristic", "Whether to use Rounding heuristic",
+                        "off", CBC_PARAM_STR_ROUNDING);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on a simple (but effective) rounding heuristic at each node of tree.  \
+On means do in solve i.e. after preprocessing, \
+Before means do if doHeuristics used, off otherwise, \
+and both means do if doHeuristics and in solve."
+     );
+
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("saveM!odel", "Save model to binary file",
+                        CLP_PARAM_ACTION_SAVE, 7, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will save the problem to the given file name for future use\
+ by restoreModel.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.prob'."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("saveS!olution", "saves solution to file",
+                        CLP_PARAM_ACTION_SAVESOL);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will write a binary solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'solution.file'.  To read the file use fread(int) twice to pick up number of rows \
+and columns, then fread(double) to pick up objective value, then pick up row activities, row duals, column \
+activities and reduced costs - see bottom of CbcOrClpParam.cpp for code that reads or writes file. \
+If name contains '_fix_read_' then does not write but reads and will fix all variables"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("scal!ing", "Whether to scale problem",
+                        "off", CLP_PARAM_STR_SCALING);
+     parameters[numberParameters-1].append("equi!librium");
+     parameters[numberParameters-1].append("geo!metric");
+     parameters[numberParameters-1].append("auto!matic");
+     parameters[numberParameters-1].append("dynamic");
+     parameters[numberParameters-1].append("rows!only");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Scaling can help in solving problems which might otherwise fail because of lack of\
+ accuracy.  It can also reduce the number of iterations.  It is not applied if the range\
+ of elements is small.  When unscaled it is possible that there may be small primal and/or\
+ infeasibilities."
+     );
+     parameters[numberParameters-1].setCurrentOption(3); // say auto
+#ifndef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("sec!onds", "Maximum seconds",
+                        -1.0, 1.0e12, CLP_PARAM_DBL_TIMELIMIT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "After this many seconds clp will act as if maximum iterations had been reached \
+(if value >=0)."
+     );
+#else
+     parameters[numberParameters++] =
+          CbcOrClpParam("sec!onds", "maximum seconds",
+                        -1.0, 1.0e12, CBC_PARAM_DBL_TIMELIMIT_BAB);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "After this many seconds coin solver will act as if maximum nodes had been reached."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("sleep", "for debug",
+                        CLP_PARAM_ACTION_DUMMY, 7, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("slow!cutpasses", "Maximum number of tries for slower cuts",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Some cut generators are fairly slow - this limits the number of times they are tried."
+     );
+     parameters[numberParameters-1].setIntValue(10);
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("slp!Value", "Number of slp passes before primal",
+                        -50000, 50000, CLP_PARAM_INT_SLPVALUE, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If you are solving a quadratic problem using primal then it may be helpful to do some \
+sequential Lps to get a good approximate solution."
+     );
+#if CLP_MULTIPLE_FACTORIZATIONS > 0
+     parameters[numberParameters++] =
+          CbcOrClpParam("small!Factorization", "Whether to use small factorization",
+                        -1, 10000, CBC_PARAM_INT_SMALLFACT, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If processed problem <= this use small factorization"
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+#endif
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("solu!tion", "Prints solution to file",
+                        CLP_PARAM_ACTION_SOLUTION);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This will write a primitive solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'stdout'.  The amount of output can be varied using printi!ngOptions or printMask."
+     );
+#ifdef COIN_HAS_CLP
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("solv!e", "Solve problem",
+                        CBC_PARAM_ACTION_BAB);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If there are no integer variables then this just solves LP.  If there are integer variables \
+this does branch and cut."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("sos!Options", "Whether to use SOS from AMPL",
+                        "off", CBC_PARAM_STR_SOS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setCurrentOption("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally if AMPL says there are SOS variables they should be used, but sometime sthey should\
+ be turned off - this does so."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("slog!Level", "Level of detail in (LP) Solver output",
+                        -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If 0 then there should be no output in normal circumstances.  1 is probably the best\
+ value for most uses, while 2 and 3 give more information.  This parameter is only used inside MIP - for Clp use 'log'"
+     );
+#else
+     // allow solve as synonym for possible dual
+     parameters[numberParameters++] =
+       CbcOrClpParam("solv!e", "Solve problem using dual simplex (probably)",
+                        CLP_PARAM_ACTION_EITHERSIMPLEX);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Just so can use solve for clp as well as in cbc"
+     );
+#endif
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("spars!eFactor", "Whether factorization treated as sparse",
+                        "on", CLP_PARAM_STR_SPARSEFACTOR, 7, 0);
+     parameters[numberParameters-1].append("off");
+     parameters[numberParameters++] =
+          CbcOrClpParam("special!Options", "Dubious options for Simplex - see ClpSimplex.hpp",
+                        0, COIN_INT_MAX, CLP_PARAM_INT_SPECIALOPTIONS, 0);
+     parameters[numberParameters++] =
+          CbcOrClpParam("sprint!Crash", "Whether to try sprint crash",
+                        -1, 5000000, CLP_PARAM_INT_SPRINT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "For long and thin problems this program may solve a series of small problems\
+ created by taking a subset of the columns.  I introduced the idea as 'Sprint' after\
+ an LP code of that name of the 60's which tried the same tactic (not totally successfully).\
+  Cplex calls it 'sifting'.  -1 is automatic choice, 0 is off, n is number of passes"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("stat!istics", "Print some statistics",
+                        CLP_PARAM_ACTION_STATISTICS);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This command prints some statistics for the current model.\
+ If log level >1 then more is printed.\
+ These are for presolved model if presolve on (and unscaled)."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("stop", "Stops clp execution",
+                        CLP_PARAM_ACTION_EXIT);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This stops the execution of Clp, end, exit, quit and stop are synonyms"
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("strat!egy", "Switches on groups of features",
+                        0, 2, CBC_PARAM_INT_STRATEGY);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This turns on newer features. \
+Use 0 for easy problems, 1 is default, 2 is aggressive. \
+1 uses Gomory cuts using tolerance of 0.01 at root, \
+does a possible restart after 100 nodes if can fix many \
+and activates a diving and RINS heuristic and makes feasibility pump \
+more aggressive. \
+This does not apply to unit tests (where 'experiment' may have similar effects)."
+     );
+     parameters[numberParameters-1].setIntValue(1);
+#ifdef CBC_KEEP_DEPRECATED
+     parameters[numberParameters++] =
+          CbcOrClpParam("strengthen", "Create strengthened problem",
+                        CBC_PARAM_ACTION_STRENGTHEN, 3);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This creates a new problem by applying the root node cuts.  All tight constraints \
+will be in resulting problem"
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("strong!Branching", "Number of variables to look at in strong branching",
+                        0, COIN_INT_MAX, CBC_PARAM_INT_STRONGBRANCHING);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "In order to decide which variable to branch on, the code will choose up to this number \
+of unsatisfied variables to do mini up and down branches on.  Then the most effective one is chosen. \
+If a variable is branched on many times then the previous average up and down costs may be used - \
+see number before trust."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("subs!titution", "How long a column to substitute for in presolve",
+                        0, 10000, CLP_PARAM_INT_SUBSTITUTION, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Normally Presolve gets rid of 'free' variables when there are no more than 3 \
+ variables in column.  If you increase this the number of rows may decrease but number of \
+ elements may increase."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("testO!si", "Test OsiObject stuff",
+                        -1, COIN_INT_MAX, CBC_PARAM_INT_TESTOSI, 0);
+#endif
+#ifdef CBC_THREAD
+     parameters[numberParameters++] =
+          CbcOrClpParam("thread!s", "Number of threads to try and use",
+                        -100, 100000, CBC_PARAM_INT_THREADS, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "To use multiple threads, set threads to number wanted.  It may be better \
+to use one or two more than number of cpus available.  If 100+n then n threads and \
+search is repeatable (maybe be somewhat slower), \
+if 200+n use threads for root cuts, 400+n threads used in sub-trees."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("tighten!Factor", "Tighten bounds using this times largest \
+activity at continuous solution",
+                        1.0e-3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This sleazy trick can help on some problems."
+     );
+#endif
+#ifdef COIN_HAS_CLP
+     parameters[numberParameters++] =
+          CbcOrClpParam("tightLP", "Poor person's preSolve for now",
+                        CLP_PARAM_ACTION_TIGHTEN, 7, 0);
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("timeM!ode", "Whether to use CPU or elapsed time",
+                        "cpu", CLP_PARAM_STR_TIME_MODE);
+     parameters[numberParameters-1].append("elapsed");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "cpu uses CPU time for stopping, while elapsed uses elapsed time. \
+(On Windows, elapsed time is always used)."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
+                        -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Using strong branching computes pseudo-costs.  After this many times for a variable we just \
+trust the pseudo costs and do not do any more strong branching."
+     );
+#endif
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("tune!PreProcess", "Dubious tuning parameters",
+                        0, 2000000000, CLP_PARAM_INT_PROCESSTUNE, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+	  "Format aabbcccc - \n If aa then this is number of major passes (i.e. with presolve) \n \
+If bb and bb>0 then this is number of minor passes (if unset or 0 then 10) \n \
+cccc is bit set \n 0 - 1 Heavy probing \n 1 - 2 Make variables integer if possible (if obj value)\n \
+2 - 4 As above but even if zero objective value\n \
+7 - 128 Try and create cliques\n 8 - 256 If all +1 try hard for dominated rows\n \
+10 - 1024 Use a larger feasibility tolerance in presolve\n \
+11 - 2048 Try probing before creating cliques"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("two!MirCuts", "Whether to use Two phase Mixed Integer Rounding cuts",
+                        "off", CBC_PARAM_STR_TWOMIRCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].append("forceandglobal");
+     parameters[numberParameters-1].append("forceLongOn");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on two phase mixed integer rounding  cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("unitTest", "Do unit test",
+                        CLP_PARAM_ACTION_UNITTEST, 3, 1);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This exercises the unit test for clp"
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("userClp", "Hand coded Clp stuff",
+                        CLP_PARAM_ACTION_USERCLP, 0, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
+Look for USERCLP in main driver and modify sample code."
+     );
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("userCbc", "Hand coded Cbc stuff",
+                        CBC_PARAM_ACTION_USERCBC, 0, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
+Look for USERCBC in main driver and modify sample code. \
+It is possible you can get same effect by using example driver4.cpp."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("Vnd!VariableNeighborhoodSearch", "Whether to try Variable Neighborhood Search",
+                        "off", CBC_PARAM_STR_VND);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("both");
+     parameters[numberParameters-1].append("before");
+     parameters[numberParameters-1].append("intree");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on variable neighborhood Search. \
+Doh option does heuristic before preprocessing"     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("vector", "Whether to use vector? Form of matrix in simplex",
+                        "off", CLP_PARAM_STR_VECTOR, 7, 0);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If this is on ClpPackedMatrix uses extra column copy in odd format."
+     );
+     parameters[numberParameters++] =
+          CbcOrClpParam("verbose", "Switches on longer help on single ?",
+                        0, 31, CLP_PARAM_INT_VERBOSE, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "Set to 1 to get short help with ? list, 2 to get long help, 3 for both.  (add 4 to just get ampl ones)."
+     );
+     parameters[numberParameters-1].setIntValue(0);
+#ifdef COIN_HAS_CBC
+     parameters[numberParameters++] =
+          CbcOrClpParam("vub!heuristic", "Type of vub heuristic",
+                        -2, 20, CBC_PARAM_INT_VUBTRY, 0);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "If set will try and fix some integer variables"
+     );
+     parameters[numberParameters-1].setIntValue(-1);
+     parameters[numberParameters++] =
+          CbcOrClpParam("zero!HalfCuts", "Whether to use zero half cuts",
+                        "off", CBC_PARAM_STR_ZEROHALFCUTS);
+     parameters[numberParameters-1].append("on");
+     parameters[numberParameters-1].append("root");
+     parameters[numberParameters-1].append("ifmove");
+     parameters[numberParameters-1].append("forceOn");
+     parameters[numberParameters-1].append("onglobal");
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This switches on zero-half cuts (either at root or in entire tree) \
+See branchAndCut for information on options.  This implementation was written by \
+Alberto Caprara."
+     );
+#endif
+     parameters[numberParameters++] =
+          CbcOrClpParam("zeroT!olerance", "Kill all coefficients \
+whose absolute value is less than this value",
+                        1.0e-100, 1.0e-5, CLP_PARAM_DBL_ZEROTOLERANCE);
+     parameters[numberParameters-1].setLonghelp
+     (
+          "This applies to reading mps files (and also lp files \
+if KILL_ZERO_READLP defined)"
+     );
+     parameters[numberParameters-1].setDoubleValue(1.0e-20);
+     assert(numberParameters < CBCMAXPARAMETERS);
+}
+// Given a parameter type - returns its number in list
+int whichParam (CbcOrClpParameterType name,
+                int numberParameters, CbcOrClpParam *const parameters)
+{
+     int i;
+     for (i = 0; i < numberParameters; i++) {
+          if (parameters[i].type() == name)
+               break;
+     }
+     assert (i < numberParameters);
+     return i;
+}
+#ifdef COIN_HAS_CLP
+/* Restore a solution from file.
+   mode 0 normal, 1 swap rows and columns and primal and dual
+   if 2 set then also change signs
+*/
+void restoreSolution(ClpSimplex * lpSolver, std::string fileName, int mode)
+{
+     FILE * fp = fopen(fileName.c_str(), "rb");
+     if (fp) {
+          int numberRows = lpSolver->numberRows();
+          int numberColumns = lpSolver->numberColumns();
+          int numberRowsFile;
+          int numberColumnsFile;
+          double objectiveValue;
+          size_t nRead;
+          nRead = fread(&numberRowsFile, sizeof(int), 1, fp);
+          if (nRead != 1)
+               throw("Error in fread");
+          nRead = fread(&numberColumnsFile, sizeof(int), 1, fp);
+          if (nRead != 1)
+               throw("Error in fread");
+          nRead = fread(&objectiveValue, sizeof(double), 1, fp);
+          if (nRead != 1)
+               throw("Error in fread");
+          double * dualRowSolution = lpSolver->dualRowSolution();
+          double * primalRowSolution = lpSolver->primalRowSolution();
+          double * dualColumnSolution = lpSolver->dualColumnSolution();
+          double * primalColumnSolution = lpSolver->primalColumnSolution();
+          if (mode) {
+               // swap
+               int k = numberRows;
+               numberRows = numberColumns;
+               numberColumns = k;
+               double * temp;
+               temp = dualRowSolution;
+               dualRowSolution = primalColumnSolution;
+               primalColumnSolution = temp;
+               temp = dualColumnSolution;
+               dualColumnSolution = primalRowSolution;
+               primalRowSolution = temp;
+          }
+          if (numberRows > numberRowsFile || numberColumns > numberColumnsFile) {
+               std::cout << "Mismatch on rows and/or columns - giving up" << std::endl;
+          } else {
+               lpSolver->setObjectiveValue(objectiveValue);
+               if (numberRows == numberRowsFile && numberColumns == numberColumnsFile) {
+                    nRead = fread(primalRowSolution, sizeof(double), numberRows, fp);
+                    if (nRead != static_cast<size_t>(numberRows))
+                         throw("Error in fread");
+                    nRead = fread(dualRowSolution, sizeof(double), numberRows, fp);
+                    if (nRead != static_cast<size_t>(numberRows))
+                         throw("Error in fread");
+                    nRead = fread(primalColumnSolution, sizeof(double), numberColumns, fp);
+                    if (nRead != static_cast<size_t>(numberColumns))
+                         throw("Error in fread");
+                    nRead = fread(dualColumnSolution, sizeof(double), numberColumns, fp);
+                    if (nRead != static_cast<size_t>(numberColumns))
+                         throw("Error in fread");
+               } else {
+                    std::cout << "Mismatch on rows and/or columns - truncating" << std::endl;
+                    double * temp = new double [CoinMax(numberRowsFile, numberColumnsFile)];
+                    nRead = fread(temp, sizeof(double), numberRowsFile, fp);
+                    if (nRead != static_cast<size_t>(numberRowsFile))
+                         throw("Error in fread");
+                    CoinMemcpyN(temp, numberRows, primalRowSolution);
+                    nRead = fread(temp, sizeof(double), numberRowsFile, fp);
+                    if (nRead != static_cast<size_t>(numberRowsFile))
+                         throw("Error in fread");
+                    CoinMemcpyN(temp, numberRows, dualRowSolution);
+                    nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
+                    if (nRead != static_cast<size_t>(numberColumnsFile))
+                         throw("Error in fread");
+                    CoinMemcpyN(temp, numberColumns, primalColumnSolution);
+                    nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
+                    if (nRead != static_cast<size_t>(numberColumnsFile))
+                         throw("Error in fread");
+                    CoinMemcpyN(temp, numberColumns, dualColumnSolution);
+                    delete [] temp;
+			   }
+               if (mode == 3) {
+                    int i;
+                    for (i = 0; i < numberRows; i++) {
+                         primalRowSolution[i] = -primalRowSolution[i];
+                         dualRowSolution[i] = -dualRowSolution[i];
+                    }
+                    for (i = 0; i < numberColumns; i++) {
+                         primalColumnSolution[i] = -primalColumnSolution[i];
+                         dualColumnSolution[i] = -dualColumnSolution[i];
+                    }
+               }
+          }
+          fclose(fp);
+     } else {
+          std::cout << "Unable to open file " << fileName << std::endl;
+     }
+}
+// Dump a solution to file
+void saveSolution(const ClpSimplex * lpSolver, std::string fileName)
+{
+     if (strstr(fileName.c_str(), "_fix_read_")) {
+          FILE * fp = fopen(fileName.c_str(), "rb");
+          if (fp) {
+               ClpSimplex * solver = const_cast<ClpSimplex *>(lpSolver);
+               restoreSolution(solver, fileName, 0);
+               // fix all
+               int logLevel = solver->logLevel();
+               int iColumn;
+               int numberColumns = solver->numberColumns();
+               double * primalColumnSolution =
+                    solver->primalColumnSolution();
+               double * columnLower = solver->columnLower();
+               double * columnUpper = solver->columnUpper();
+               for (iColumn = 0; iColumn < numberColumns; iColumn++) {
+                    double value = primalColumnSolution[iColumn];
+                    if (value > columnUpper[iColumn]) {
+                         if (value > columnUpper[iColumn] + 1.0e-6 && logLevel > 1)
+                              printf("%d value of %g - bounds %g %g\n",
+                                     iColumn, value, columnLower[iColumn], columnUpper[iColumn]);
+                         value = columnUpper[iColumn];
+                    } else if (value < columnLower[iColumn]) {
+                         if (value < columnLower[iColumn] - 1.0e-6 && logLevel > 1)
+                              printf("%d value of %g - bounds %g %g\n",
+                                     iColumn, value, columnLower[iColumn], columnUpper[iColumn]);
+                         value = columnLower[iColumn];
+                    }
+                    columnLower[iColumn] = value;
+                    columnUpper[iColumn] = value;
+               }
+               return;
+          }
+     }
+     FILE * fp = fopen(fileName.c_str(), "wb");
+     if (fp) {
+          int numberRows = lpSolver->numberRows();
+          int numberColumns = lpSolver->numberColumns();
+          double objectiveValue = lpSolver->objectiveValue();
+          size_t nWrite;
+          nWrite = fwrite(&numberRows, sizeof(int), 1, fp);
+          if (nWrite != 1)
+               throw("Error in fwrite");
+          nWrite = fwrite(&numberColumns, sizeof(int), 1, fp);
+          if (nWrite != 1)
+               throw("Error in fwrite");
+          nWrite = fwrite(&objectiveValue, sizeof(double), 1, fp);
+          if (nWrite != 1)
+               throw("Error in fwrite");
+          double * dualRowSolution = lpSolver->dualRowSolution();
+          double * primalRowSolution = lpSolver->primalRowSolution();
+          nWrite = fwrite(primalRowSolution, sizeof(double), numberRows, fp);
+          if (nWrite != static_cast<size_t>(numberRows))
+               throw("Error in fwrite");
+          nWrite = fwrite(dualRowSolution, sizeof(double), numberRows, fp);
+          if (nWrite != static_cast<size_t>(numberRows))
+               throw("Error in fwrite");
+          double * dualColumnSolution = lpSolver->dualColumnSolution();
+          double * primalColumnSolution = lpSolver->primalColumnSolution();
+          nWrite = fwrite(primalColumnSolution, sizeof(double), numberColumns, fp);
+          if (nWrite != static_cast<size_t>(numberColumns))
+               throw("Error in fwrite");
+          nWrite = fwrite(dualColumnSolution, sizeof(double), numberColumns, fp);
+          if (nWrite != static_cast<size_t>(numberColumns))
+               throw("Error in fwrite");
+          fclose(fp);
+     } else {
+          std::cout << "Unable to open file " << fileName << std::endl;
+     }
+}
+#endif