/home/coin/SVN-release/CoinAll-1.1.0/Bcps/examples/Blis/BlisParams.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Bcps Linear Solver (BLIS).                       *
 *                                                                           *
 * BLIS is distributed under the Common Public License as part of the        *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           * 
 *                                                                           *
 * Copyright (C) 2001-2005, International Business Machines                  *
 * Corporation, Lehigh University, Yan Xu, Ted Ralphs, Matthew Salzman and   *
 * others. All Rights Reserved.                                              *
 *===========================================================================*/

#ifndef BlisParams_h
#define BlisParams_h

#include "AlpsKnowledge.h"
#include "AlpsParameterBase.h"


//#############################################################################
//#############################################################################

//** Parameters used in Blis. */
class BlisParams : public AlpsParameterSet {
 public:
  enum boolParams{
    useCons,
    useHeuristics,
    cutDuringRampup,
    //
    endOfBoolParams
  };
  
  enum intParams{
      strongCandSize,


      branchStrategy,

      heurRound,

      cutClique,
      cutGomory,
      cutFlowCover,
      cutKnapsack,
      cutMir,
      cutOddHole,
      cutProbing,
      cutTwoMir,
      pseudoRelibility,
      lookAhead,
      //
      endOfIntParams
  };

  enum dblParams{
    integerTol,

    cutoffInc,
    
    optimalRelGap,

    optimalAbsGap,

    pseudoWeight,

    cutFactor,

    denseConFactor,

    scaleConFactor,
    //
    endOfDblParams
  };

  enum strParams{
    strDummy,
    //
    endOfStrParams
  };

  enum strArrayParams{
    strArrayDummy,
    //
    endOfStrArrayParams
  };

 public:
  BlisParams() :
    AlpsParameterSet(
                     static_cast<int>(endOfBoolParams),
                     static_cast<int>(endOfIntParams),
                     static_cast<int>(endOfDblParams),
                     static_cast<int>(endOfStrParams),
                     static_cast<int>(endOfStrArrayParams)
                     )
    {
      createKeywordList();
      setDefaultEntries();
    }
  virtual void createKeywordList();
  virtual void setDefaultEntries();
 public:
  //===========================================================================
  //===========================================================================

  

  inline bool entry(const boolParams key) const { return bpar_[key]; }
  inline int entry(const intParams key) const { return ipar_[key]; }
  inline double  entry(const dblParams key) const { return dpar_[key]; }
  inline const std::string&
    entry(const strParams key) const { return spar_[key]; }
  inline const std::vector<std::string>&
    entry(const strArrayParams key) const { return sapar_[key]; }
  //---------------------------------------------------------------------------
  void setEntry(const boolParams key, const char * val) {
          bpar_[key] = atoi(val) ? true : false; }
  void setEntry(const boolParams key, const char val) {
          bpar_[key] = val ? true : false; }
  void setEntry(const boolParams key, const bool val) {
    bpar_[key] = val; }
  void setEntry(const intParams key, const char * val) {
    ipar_[key] = atoi(val); }
  void setEntry(const intParams key, const int val) {
    ipar_[key] = val; }
  void setEntry(const dblParams key, const char * val) {
    dpar_[key] = atof(val); }
  void setEntry(const dblParams key, const double val) {
    dpar_[key] = val; }
  void setEntry(const strParams key, const char * val) {
    spar_[key] = val; }
  void setEntry(const strArrayParams key, const char *val) {
    sapar_[key].push_back(val); }

  //---------------------------------------------------------------------------

  void pack(AlpsEncoded& buf) {
    buf.writeRep(bpar_, endOfBoolParams)
      .writeRep(ipar_, endOfIntParams)
      .writeRep(dpar_, endOfDblParams);
    for (int i = 0; i < endOfStrParams; ++i)
      buf.writeRep(spar_[i]);
    for (int i = 0; i < endOfStrArrayParams; ++i) {
      buf.writeRep(sapar_[i].size());
      for (size_t j = 0; j < sapar_[i].size(); ++j)
        buf.writeRep(sapar_[i][j]);
    }
  }
  void unpack(AlpsEncoded& buf) {
    int dummy;
    // No need to allocate the arrays, they are of fixed length
    dummy = static_cast<int>(endOfBoolParams);
    buf.readRep(bpar_, dummy, false);
    dummy = static_cast<int>(endOfIntParams);
    buf.readRep(ipar_, dummy, false);
    dummy = static_cast<int>(endOfDblParams);
    buf.readRep(dpar_, dummy, false);
    for (int i = 0; i < endOfStrParams; ++i)
      buf.readRep(spar_[i]);
    for (int i = 0; i < endOfStrArrayParams; ++i) {
      size_t str_size;
      buf.readRep(str_size);
      sapar_[i].reserve(str_size);
      for (size_t j = 0; j < str_size; ++j){
        //      sapar_[i].unchecked_push_back(std::string());
        sapar_[i].push_back(std::string());
        buf.readRep(sapar_[i].back());
      }
    }
  }
};

#endif

---