diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/CbcOrClpParam.cpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/CbcOrClpParam.cpp | 4104 |
1 files changed, 4104 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/CbcOrClpParam.cpp b/thirdparty/linux/include/coin1/CbcOrClpParam.cpp new file mode 100644 index 0000000..b434fe0 --- /dev/null +++ b/thirdparty/linux/include/coin1/CbcOrClpParam.cpp @@ -0,0 +1,4104 @@ +/* $Id: CbcOrClpParam.cpp 2079 2015-01-05 13:11:35Z forrest $ */ +// Copyright (C) 2002, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#include "CoinPragma.hpp" +#include "CoinTime.hpp" +#include "CbcOrClpParam.hpp" + +#include <string> +#include <iostream> +#include <cassert> + +#ifdef COIN_HAS_CBC +#ifdef COIN_HAS_CLP +#include "OsiClpSolverInterface.hpp" +#include "ClpSimplex.hpp" +#endif +#include "CbcModel.hpp" +#endif +#include "CoinHelperFunctions.hpp" +#ifdef COIN_HAS_CLP +#include "ClpSimplex.hpp" +#include "ClpFactorization.hpp" +#endif +#ifdef COIN_HAS_READLINE +#include <readline/readline.h> +#include <readline/history.h> +#endif +#ifdef COIN_HAS_CBC +// from CoinSolve +static char coin_prompt[] = "Coin:"; +#else +static char coin_prompt[] = "Clp:"; +#endif +#ifdef CLP_CILK +#ifndef CBC_THREAD +#define CBC_THREAD +#endif +#endif +#if defined(COIN_HAS_WSMP) && ! defined(USE_EKKWSSMP) +#ifndef CBC_THREAD +#define CBC_THREAD +#endif +#endif +#include "ClpConfig.h" +#ifdef CLP_HAS_ABC +#include "AbcCommon.hpp" +#endif +static bool doPrinting = true; +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&¤tKeyWord_<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 |