SbbParam.cpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif

#include <string>
#include <iostream>
#include <cassert>

#include "SbbParam.hpp"

//#############################################################################
// Constructors / Destructor / Assignment
//#############################################################################

//-------------------------------------------------------------------
// Default Constructor 
//-------------------------------------------------------------------
SbbParam::SbbParam () 
  : type_(INVALID),
    lowerDoubleValue_(0.0),
    upperDoubleValue_(0.0),
    lowerIntValue_(0),
    upperIntValue_(0),
    lengthName_(0),
    lengthMatch_(0),
    definedKeyWords_(),
    name_(),
    shortHelp_(),
    longHelp_(),
    action_(INVALID),
    currentKeyWord_(-1)
{
}
// Other constructors
SbbParam::SbbParam (std::string name, std::string help,
           double lower, double upper, SbbParameterType type)
  : type_(type),
    lowerIntValue_(0),
    upperIntValue_(0),
    definedKeyWords_(),
    name_(name),
    shortHelp_(help),
    longHelp_(),
    action_(type),
    currentKeyWord_(-1)
{
  lowerDoubleValue_ = lower;
  upperDoubleValue_ = upper;
  gutsOfConstructor();
}
SbbParam::SbbParam (std::string name, std::string help,
           int lower, int upper, SbbParameterType type)
  : type_(type),
    lowerDoubleValue_(0.0),
    upperDoubleValue_(0.0),
    definedKeyWords_(),
    name_(name),
    shortHelp_(help),
    longHelp_(),
    action_(type),
    currentKeyWord_(-1)
{
  gutsOfConstructor();
  lowerIntValue_ = lower;
  upperIntValue_ = upper;
}
// Other strings will be added by append
SbbParam::SbbParam (std::string name, std::string help, 
                  std::string defaultValue,
                  SbbParameterType type)
  : type_(type),
    lowerDoubleValue_(0.0),
    upperDoubleValue_(0.0),
    lowerIntValue_(0),
    upperIntValue_(0),
    definedKeyWords_(),
    name_(name),
    shortHelp_(help),
    longHelp_(),
    action_(type),
    currentKeyWord_(0)
{
  gutsOfConstructor();
  definedKeyWords_.push_back(defaultValue);
}
// Action
SbbParam::SbbParam (std::string name, std::string help,
           SbbParameterType type)
  : type_(type),
    lowerDoubleValue_(0.0),
    upperDoubleValue_(0.0),
    lowerIntValue_(0),
    upperIntValue_(0),
    definedKeyWords_(),
    name_(name),
    shortHelp_(help),
    longHelp_(),
    action_(type),
    currentKeyWord_(-1)
{
  gutsOfConstructor();
}

//-------------------------------------------------------------------
// Copy constructor 
//-------------------------------------------------------------------
SbbParam::SbbParam (const SbbParam & 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_;
  
}

//-------------------------------------------------------------------
// Destructor 
//-------------------------------------------------------------------
SbbParam::~SbbParam ()
{
}

//----------------------------------------------------------------
// Assignment operator 
//-------------------------------------------------------------------
SbbParam &
SbbParam::operator=(const SbbParam& 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_;
  }
  return *this;
}
void 
SbbParam::gutsOfConstructor()
{
  unsigned int  shriekPos = name_.find('!');
  lengthName_ = name_.length();
  if ( shriekPos==std::string::npos ) {
    //does not contain '!'
    lengthMatch_= lengthName_;
  } else {
    lengthMatch_=shriekPos;
    name_ = name_.substr(0,shriekPos)+name_.substr(shriekPos+1);
    lengthName_--;
  }
}
// Insert string (only valid for keywords)
void 
SbbParam::append(std::string keyWord)
{
  definedKeyWords_.push_back(keyWord);
}

int 
SbbParam::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 
SbbParam::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 
SbbParam::parameterOption ( std::string check ) const
{
  int numberItems = 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];
      unsigned int  shriekPos = thisOne.find('!');
      unsigned int length1 = thisOne.length();
      unsigned int 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) {
        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
      return -1;
  }
}
// Prints parameter options
void 
SbbParam::printOptions (  ) const
{
  std::cout<<"Possible options for "<<name_<<" are:"<<std::endl;
  unsigned int it;
  for (it=0;it<definedKeyWords_.size();it++) {
    std::string thisOne = definedKeyWords_[it];
    unsigned int  shriekPos = thisOne.find('!');
    if ( shriekPos!=std::string::npos ) {
      //contains '!'
      thisOne = thisOne.substr(0,shriekPos)+
        "("+thisOne.substr(shriekPos+1)+")";
    }
    std::cout<<thisOne<<std::endl;
  }
}
int
SbbParam::setDoubleParameter (OsiSolverInterface * model,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 {
    double oldValue;
    switch(type_) {
    case DUALTOLERANCE:
      model->getDblParam(OsiDualTolerance,oldValue);
      model->setDblParam(OsiDualTolerance,value);
      break;
    case PRIMALTOLERANCE:
      model->getDblParam(OsiPrimalTolerance,oldValue);
      model->setDblParam(OsiPrimalTolerance,value);
      break;
    default:
      oldValue=0.0; // to avoid compiler message
      abort();
    }
    std::cout<<name_<<" was changed from "<<oldValue<<" to "
             <<value<<std::endl;
    return 0;
  }
}
int
SbbParam::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;
  }
}
double 
SbbParam::doubleParameter (OsiSolverInterface * model) const
{
  double value;
  switch(type_) {
  case DUALTOLERANCE:
    assert(model->getDblParam(OsiDualTolerance,value));
    break;
  case PRIMALTOLERANCE:
    assert(model->getDblParam(OsiPrimalTolerance,value));
    break;
  default:
    abort();
  }
  return value;
}
int 
SbbParam::setIntParameter (OsiSolverInterface * model,int value) const
{
  if (value<lowerIntValue_||value>upperIntValue_) {
    std::cout<<value<<" was provided for "<<name_<<
      " - valid range is "<<lowerIntValue_<<" to "<<
      upperIntValue_<<std::endl;
    return 1;
  } else {
    int oldValue;
    switch(type_) {
    case LOGLEVEL:
      model->messageHandler()->setLogLevel(value);
      break;
    default:
      oldValue=0; // to avoid compiler message
      abort();
    }
    std::cout<<name_<<" was changed from "<<oldValue<<" to "
             <<value<<std::endl;
    return 0;
  }
}
int 
SbbParam::intParameter (OsiSolverInterface * model) const
{
  int value=0;
  switch(type_) {
  case LOGLEVEL:
    //value=model->logLevel();
    break;
  default:
    abort();
  }
  return value;
}
int
SbbParam::setDoubleParameter (SbbModel &model,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 {
    double oldValue;
    switch(type_) {
    case INFEASIBILITYWEIGHT:
      oldValue=model.getDblParam(SbbModel::SbbInfeasibilityWeight);
      model.setDblParam(SbbModel::SbbInfeasibilityWeight,value);
      break;
    case INTEGERTOLERANCE:
      oldValue=model.getDblParam(SbbModel::SbbIntegerTolerance);
      model.setDblParam(SbbModel::SbbIntegerTolerance,value);
      break;
    case INCREMENT:
      oldValue=model.getDblParam(SbbModel::SbbCutoffIncrement);
      model.setDblParam(SbbModel::SbbCutoffIncrement,value);
    case ALLOWABLEGAP:
      oldValue=model.getDblParam(SbbModel::SbbAllowableGap);
      model.setDblParam(SbbModel::SbbAllowableGap,value);
      break;
    case TIMELIMIT:
    { oldValue = model.getDblParam(SbbModel::SbbMaximumSeconds) ;
      model.setDblParam(SbbModel::SbbMaximumSeconds,value) ;
      break ; }
    default:
      oldValue=0.0; // to avoid compiler message
      abort();
    }
    std::cout<<name_<<" was changed from "<<oldValue<<" to "
             <<value<<std::endl;
    return 0;
  }
}
double 
SbbParam::doubleParameter (SbbModel &model) const
{
  double value;
  switch(type_) {
  case INFEASIBILITYWEIGHT:
    value=model.getDblParam(SbbModel::SbbInfeasibilityWeight);
    break;
  case INTEGERTOLERANCE:
    value=model.getDblParam(SbbModel::SbbIntegerTolerance);
    break;
  case INCREMENT:
    value=model.getDblParam(SbbModel::SbbCutoffIncrement);
  case ALLOWABLEGAP:
    value=model.getDblParam(SbbModel::SbbAllowableGap);
    break;
  case TIMELIMIT:
  { value = model.getDblParam(SbbModel::SbbMaximumSeconds) ;
    break ; }
  default:
    abort();
  }
  return value;
}
int 
SbbParam::setIntParameter (SbbModel &model,int value) const
{
  if (value<lowerIntValue_||value>upperIntValue_) {
    std::cout<<value<<" was provided for "<<name_<<
      " - valid range is "<<lowerIntValue_<<" to "<<
      upperIntValue_<<std::endl;
    return 1;
  } else {
    int oldValue;
    switch(type_) {
    case LOGLEVEL:
      oldValue = model.messageHandler()->logLevel();
      model.messageHandler()->setLogLevel(value);
      break;
    case SOLVERLOGLEVEL:
      oldValue = model.solver()->messageHandler()->logLevel();
      model.solver()->messageHandler()->setLogLevel(value);
      break;
    case MAXNODES:
      oldValue=model.getIntParam(SbbModel::SbbMaxNumNode);
      model.setIntParam(SbbModel::SbbMaxNumNode,value);
      break;
    case STRONGBRANCHING:
      oldValue=model.numberStrong();
      model.setNumberStrong(value);
      break;
    default:
      oldValue=0; // to avoid compiler message
      abort();
    }
    std::cout<<name_<<" was changed from "<<oldValue<<" to "
             <<value<<std::endl;
    return 0;
  }
}
int 
SbbParam::intParameter (SbbModel &model) const
{
  int value;
  switch(type_) {
  case LOGLEVEL:
    value = model.messageHandler()->logLevel();
      break;
  case SOLVERLOGLEVEL:
    value = model.solver()->messageHandler()->logLevel();
      break;
  case MAXNODES:
    value = model.getIntParam(SbbModel::SbbMaxNumNode);
    break;
  case STRONGBRANCHING:
    value=model.numberStrong();
    break;
  default:
    abort();
  }
  return value;
}

---