summaryrefslogtreecommitdiff
path: root/thirdparty/linux/include/coin/CbcOrClpParam.cpp
diff options
context:
space:
mode:
authorHarpreet2016-09-03 00:36:51 +0530
committerHarpreet2016-09-03 00:36:51 +0530
commita0d9443af147e949c1e6a01ac24749d12593ec5b (patch)
tree1a1955c5482ae608fd7f618b06f4ecc6a0d39a23 /thirdparty/linux/include/coin/CbcOrClpParam.cpp
parent4b64cf486f5c999fd8167758cae27839f3b50848 (diff)
downloadFOSSEE-Optim-toolbox-development-a0d9443af147e949c1e6a01ac24749d12593ec5b.tar.gz
FOSSEE-Optim-toolbox-development-a0d9443af147e949c1e6a01ac24749d12593ec5b.tar.bz2
FOSSEE-Optim-toolbox-development-a0d9443af147e949c1e6a01ac24749d12593ec5b.zip
cbcintlinprog added
Diffstat (limited to 'thirdparty/linux/include/coin/CbcOrClpParam.cpp')
-rw-r--r--thirdparty/linux/include/coin/CbcOrClpParam.cpp4104
1 files changed, 4104 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CbcOrClpParam.cpp b/thirdparty/linux/include/coin/CbcOrClpParam.cpp
new file mode 100644
index 0000000..1d45c35
--- /dev/null
+++ b/thirdparty/linux/include/coin/CbcOrClpParam.cpp
@@ -0,0 +1,4104 @@
+/* $Id: CbcOrClpParam.cpp 2148 2015-06-22 16:14:57Z tkr $ */
+// 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
+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;
+}
+// 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;
+
+ 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);
+ 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 (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");
+ 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
generated by cgit (git 2.34.1) at 2024-12-22 04:25:23 +0000