master.h

Go to the documentation of this file.

#ifndef ABA_MASTER_H
#define ABA_MASTER_H

#include "abacus/global.h"
#include "abacus/optsense.h"
#include "abacus/bstack.h"
#include "abacus/hash.h"
#include "abacus/cputimer.h"
#include "abacus/cowtimer.h"
#include "abacus/string.h"
#include "abacus/standardpool.h"

#ifdef ABACUS_PARALLEL
#include "abacus/message.h"
class ABA_CONVAR;
class ABA_PARMASTER;
class ABA_NOTIFYSERVER;
#endif

class ABA_SUB;
class ABA_BRANCHRULE;
class ABA_VARIABLE;
class ABA_CONSTRAINT;

class ABA_HISTORY;
class ABA_OPENSUB;
class ABA_FIXCAND;
class ABA_LPMASTEROSI;
class OsiSolverInterface;

template<class BaseType, class CoType> class ABA_STANDARDPOOL;

  class  ABA_MASTER :  public ABA_GLOBAL  {
    friend class ABA_SUB;
    friend class ABA_FIXCAND;
#ifdef ABACUS_PARALLEL
    friend ABA_NOTIFYSERVER;
    friend ABA_PARMASTER;
#endif
    public:

      enum STATUS {Optimal, Error, OutOfMemory, Unprocessed, Processing,
                   Guaranteed, MaxLevel, MaxCpuTime,
                   MaxCowTime, ExceptionFathom};

      static const char* STATUS_[];

      enum OUTLEVEL {Silent, Statistics, Subproblem, LinearProgram, Full};


      static const char* OUTLEVEL_[];


      /* \brief The enumeration defining the different enumeration strategies for
       *        the branch and bound algorithm.
       *
       *  \param BestFirst Best-first search, i.e., select the subproblem
       *                  with best dual bound, i.e., the subproblem
       *                  having minimal dual bound for a minimization
       *                  problem, or the subproblem having maximal
       *                  dual bound for a maximization problem.
       *  \param BreadthFirst Breadth-first search, i.e., select the subproblem
       *                     with minimal level in the enumeration tree.
       *  \param DepthFirst Depth-first search, i.e., select the subproblem
       *                    with maximal level in the enumeration tree.
       *  \param DiveAndBest As long as no primal feasible solution is known
       *                    the next subproblem is selected according
       *                    to the depth-first search strategy, otherwise
       *                    the best-first search strategy is applied.
       */
      enum ENUMSTRAT {BestFirst, BreadthFirst, DepthFirst, DiveAndBest};
      static const char *ENUMSTRAT_[];

      enum BRANCHINGSTRAT {CloseHalf, CloseHalfExpensive};

      static const char *BRANCHINGSTRAT_[];

      enum PRIMALBOUNDMODE {NoPrimalBound, Optimum, OptimumOne};

      static const char* PRIMALBOUNDMODE_[];

      enum SKIPPINGMODE{SkipByNode, SkipByLevel};

      static const char* SKIPPINGMODE_[];

      enum CONELIMMODE {NoConElim, NonBinding, Basic};


      static const char* CONELIMMODE_[];

      enum VARELIMMODE {NoVarElim, ReducedCost};

      static const char* VARELIMMODE_[];

      enum VBCMODE {NoVbc, File, Pipe};

      static const char* VBCMODE_[];

/*************************************************************************
 *      These are all solvers supported by OSI, 
 *      see https://projects.coin-or.org/Osi .
 *************************************************************************/
        enum OSISOLVER {Cbc, Clp, CPLEX, DyLP, FortMP, GLPK, MOSEK, OSL, SoPlex, SYMPHONY, Vol, XPRESS_MP};

      static const char* OSISOLVER_[];

      ABA_MASTER(const char *problemName, bool cutting, bool pricing,
                 ABA_OPTSENSE::SENSE optSense = ABA_OPTSENSE::Unknown,
                 double eps = 1.0e-4, double machineEps = 1.0e-7,
                 double infinity = 1.0e30,
                 bool readParamFromFile = true);

      virtual ~ABA_MASTER();
#ifdef ABACUS_PARALLEL

      virtual ABA_CONVAR *unpackConVar(ABA_MESSAGE &msg, int classId) const;

      virtual ABA_BRANCHRULE *unpackBranchrule(ABA_MESSAGE &msg, int classId) const;

      virtual ABA_SUB *unpackSub(ABA_MESSAGE &msg) = 0;
#endif

      STATUS optimize();


      double lowerBound() const;

      double upperBound() const;

      double primalBound() const;
#ifdef ABACUS_PARALLEL

      void primalBound(double x, bool broadcast = true);
#else

      void primalBound(double x);
#endif

      double dualBound() const;

      void dualBound(double x);

      bool betterDual(double x) const;

      bool primalViolated(double x) const;

      bool betterPrimal(double x) const;

      bool feasibleFound() const;

      ENUMSTRAT enumerationStrategy() const;

      void enumerationStrategy(ENUMSTRAT strat);

      virtual int enumerationStrategy(const ABA_SUB *s1, const ABA_SUB *s2);

      bool guaranteed();

      double guarantee();
      void printGuarantee();

      bool check();

      bool knownOptimum(double &optVal);

      virtual void output();

      bool cutting() const;

      bool pricing() const;

      const ABA_OPTSENSE *optSense() const;

      ABA_HISTORY *history() const;

      ABA_OPENSUB *openSub() const;

      ABA_STANDARDPOOL<ABA_CONSTRAINT, ABA_VARIABLE> *conPool() const;

      ABA_STANDARDPOOL<ABA_CONSTRAINT, ABA_VARIABLE> *cutPool() const;

      ABA_STANDARDPOOL<ABA_VARIABLE, ABA_CONSTRAINT> *varPool() const;

      ABA_SUB *root() const;

      ABA_SUB *rRoot() const;

      STATUS status() const;

      const ABA_STRING *problemName() const;

      const ABA_COWTIMER *totalCowTime() const;

      inline bool solveApprox() const;

      const ABA_CPUTIMER *totalTime() const;

      const ABA_CPUTIMER *lpTime() const;

      const ABA_CPUTIMER *lpSolverTime() const;

      const ABA_CPUTIMER *separationTime() const;

      const ABA_CPUTIMER *improveTime() const;

      const ABA_CPUTIMER *pricingTime() const;

      const ABA_CPUTIMER *branchingTime() const;

      int nSub() const;

      int nLp() const;

      int highestLevel() const;

      int nNewRoot() const;

      int nSubSelected() const;

      void printParameters();

      BRANCHINGSTRAT branchingStrategy() const;

      void branchingStrategy(BRANCHINGSTRAT strat);

      OSISOLVER defaultLpSolver() const;

      void defaultLpSolver(OSISOLVER osiSolver);


      ABA_LPMASTEROSI *lpMasterOsi() const 
        { return lpMasterOsi_; }

      int nBranchingVariableCandidates() const;

      void nBranchingVariableCandidates(int n);

      double requiredGuarantee() const;

      void requiredGuarantee(double g);

      int maxLevel() const;

      void maxLevel(int ml);

      const ABA_STRING& maxCpuTime() const;

      void maxCpuTime(const ABA_STRING &t);

      const ABA_STRING& maxCowTime() const;

      void maxCowTime(const ABA_STRING &t);

      bool objInteger() const;

      void objInteger(bool b);

      int tailOffNLp() const;

      void tailOffNLp(int n);

      double tailOffPercent() const;

      void tailOffPercent(double p);

      OUTLEVEL outLevel() const;

      void outLevel(OUTLEVEL mode);

      OUTLEVEL logLevel() const;

      void logLevel(OUTLEVEL mode);

      bool delayedBranching(int nOpt_) const;

      void dbThreshold(int threshold);

      int dbThreshold() const;

      int minDormantRounds() const;

      void minDormantRounds(int nRounds);

      PRIMALBOUNDMODE pbMode() const;

      void pbMode(PRIMALBOUNDMODE mode);

      int pricingFreq () const;

      void pricingFreq(int f);

      int skipFactor() const;

      void skipFactor(int f);

      void skippingMode(SKIPPINGMODE mode);
    
      SKIPPINGMODE skippingMode() const;

      CONELIMMODE conElimMode() const;

      void conElimMode(CONELIMMODE mode);

      VARELIMMODE varElimMode() const;

      void varElimMode(VARELIMMODE mode);

      double conElimEps() const;

      void conElimEps(double eps);

      double varElimEps() const;


      void varElimEps(double eps);
 
      int varElimAge() const;
    
      void varElimAge(int eps);

      int conElimAge() const;

      void conElimAge(int eps);

      bool fixSetByRedCost() const;

      void fixSetByRedCost(bool on);

      bool printLP() const;

      void printLP(bool on);

      int maxConAdd() const;

      void maxConAdd(int max);

      int maxConBuffered() const;

      void maxConBuffered(int max);

      int maxVarAdd() const;

      void maxVarAdd(int max);

      int maxVarBuffered() const;

      void maxVarBuffered(int max);

      int maxIterations() const;

      void maxIterations(int max);

      bool eliminateFixedSet() const;

      void eliminateFixedSet(bool turnOn);

      bool newRootReOptimize() const;

      void newRootReOptimize(bool on);

      const ABA_STRING &optimumFileName() const;

      void optimumFileName(const char *name);

      bool showAverageCutDistance() const;

      void showAverageCutDistance(bool on);

      VBCMODE vbcLog() const;

      void vbcLog(VBCMODE mode);

      virtual bool setSolverParameters(OsiSolverInterface* interface, bool solverIsApprox);

#ifdef ABACUS_PARALLEL
     ABA_PARMASTER *parmaster() const { return parmaster_; }
#endif
    protected:

      virtual void initializePools(ABA_BUFFER<ABA_CONSTRAINT*> &constraints,
                                   ABA_BUFFER<ABA_VARIABLE*> &Variables,
                                   int varPoolSize,
                                   int cutPoolSize,
                                   bool dynamicCutPool = false);

      virtual void initializePools(ABA_BUFFER<ABA_CONSTRAINT*> &constraints,
                                   ABA_BUFFER<ABA_CONSTRAINT*> &cuts,
                                   ABA_BUFFER<ABA_VARIABLE*> &Variables,
                                   int varPoolSize,
                                   int cutPoolSize,
                                   bool dynamicCutPool = false);

      void initializeOptSense(ABA_OPTSENSE::SENSE sense);

      int bestFirstSearch(const ABA_SUB* s1, const ABA_SUB* s2) const;

      virtual int equalSubCompare(const ABA_SUB *s1, const ABA_SUB *s2) const;

      int depthFirstSearch(const ABA_SUB* s1, const ABA_SUB* s2) const;

      int breadthFirstSearch(const ABA_SUB* s1, const ABA_SUB* s2) const;


      int diveAndBestFirstSearch(const ABA_SUB *s1, const ABA_SUB* s2) const;

      virtual void initializeParameters();

      virtual ABA_SUB *firstSub() = 0;

      virtual void initializeOptimization();

      virtual void terminateOptimization();
      
#ifdef ABACUS_PARALLEL
     ABA_PARMASTER *parmaster_;
#endif

    private:

      void _initializeParameters();
      void _createLpMasters();
      void _deleteLpMasters();
      void _initializeLpParameters();

      void _setDefaultLpParameters();

      void _printLpParameters();

      void _outputLpStatistics();

      ABA_SUB   *select();
      int initLP();

      void writeTreeInterface(const char *info, bool time = true) const;

      void treeInterfaceNewNode(ABA_SUB *sub) const;
#ifdef ABACUS_PARALLEL

      void treeInterfaceNewNode(int fatherId, int id) const;
      mutable ACE_Thread_Mutex treeInterfaceMutex_;
#endif

      void treeInterfacePaintNode(int id, int color) const;

      void treeInterfaceLowerBound(double lb) const;

      void treeInterfaceUpperBound(double ub) const;

      void treeInterfaceNodeBounds(int id, double lb, double ub);

      void newSub(int level);
 
      void countLp();

      void newFixed(int n);

      void addCons(int n);

      void removeCons(int n);

      void addVars(int n);

      void removeVars(int n);

      ABA_FIXCAND *fixCand() const;

      void rRoot(ABA_SUB *newRoot, bool reoptimize);

      void status(STATUS stat);

      void rootDualBound(double x);
      void theFuture();

      ABA_STRING      problemName_;
      bool readParamFromFile_;

      ABA_OPTSENSE    optSense_;

      ABA_SUB        *root_;

      ABA_SUB        *rRoot_;

      ABA_OPENSUB    *openSub_;

      ABA_HISTORY    *history_;

      ENUMSTRAT   enumerationStrategy_;

      BRANCHINGSTRAT branchingStrategy_;

      int            nBranchingVariableCandidates_;

      OSISOLVER       defaultLpSolver_;

      ABA_LPMASTEROSI *lpMasterOsi_;

      ABA_STANDARDPOOL<ABA_CONSTRAINT, ABA_VARIABLE> *conPool_;


      ABA_STANDARDPOOL<ABA_CONSTRAINT, ABA_VARIABLE> *cutPool_;

      ABA_STANDARDPOOL<ABA_VARIABLE, ABA_CONSTRAINT> *varPool_;

      double           primalBound_;

      double           dualBound_;

      double            rootDualBound_;

      ABA_FIXCAND         *fixCand_;

      bool             cutting_;

      bool             pricing_;

      bool             solveApprox_;

      int              nSubSelected_;

      VBCMODE          VbcLog_;

      ostream         *treeStream_;

      double      requiredGuarantee_;

      int         maxLevel_;

      ABA_STRING      maxCpuTime_;

      ABA_STRING      maxCowTime_;

      bool        objInteger_;

      int         tailOffNLp_;

      double      tailOffPercent_;

      int         dbThreshold_;

      int         minDormantRounds_;

      OUTLEVEL    outLevel_;

      OUTLEVEL    logLevel_;

      PRIMALBOUNDMODE pbMode_;

      int         pricingFreq_;

      int         skipFactor_;

      SKIPPINGMODE skippingMode_;

      bool             fixSetByRedCost_;

      bool             printLP_;

      int              maxConAdd_;

      int              maxConBuffered_;

      int              maxVarAdd_;

      int              maxVarBuffered_;

      int              maxIterations_;

      bool             eliminateFixedSet_;

      bool             newRootReOptimize_;

      ABA_STRING       optimumFileName_;

      bool             showAverageCutDistance_;

      CONELIMMODE      conElimMode_;

      VARELIMMODE      varElimMode_;

      double           conElimEps_;

      double           varElimEps_;

      int              conElimAge_;

      int              varElimAge_;

      STATUS           status_;

      ABA_COWTIMER  totalCowTime_;

      ABA_CPUTIMER totalTime_;

      ABA_CPUTIMER lpTime_;
      ABA_CPUTIMER lpSolverTime_;

      ABA_CPUTIMER separationTime_;

      ABA_CPUTIMER improveTime_;

      ABA_CPUTIMER pricingTime_;

      ABA_CPUTIMER branchingTime_;

      int nSub_;

      int nLp_;

      int highestLevel_;

      int nFixed_;

      int nAddCons_;

      int nRemCons_;

      int nAddVars_;

      int nRemVars_;

      int nNewRoot_;
      ABA_MASTER(const ABA_MASTER &rhs);
      const ABA_MASTER &operator=(const ABA_MASTER& rhs);
  };


inline double ABA_MASTER::lowerBound() const
  {
    if (optSense_.max()) return primalBound_;
    else                 return dualBound_;
  }

inline double ABA_MASTER::upperBound() const
  {
    if (optSense_.max()) return dualBound_;
    else                 return primalBound_;
  }

inline double ABA_MASTER::primalBound() const
  {
    return primalBound_;
  }

inline double ABA_MASTER::dualBound() const
  {
    return dualBound_;
  }

inline ABA_SUB* ABA_MASTER::root() const
  {
    return root_;
  }

inline ABA_SUB* ABA_MASTER::rRoot() const
  {
    return rRoot_;
  }

inline const ABA_OPTSENSE *ABA_MASTER::optSense() const
  {
    return &optSense_;
  }

inline ABA_HISTORY *ABA_MASTER::history() const
  {
    return history_;
  }

inline ABA_OPENSUB *ABA_MASTER::openSub() const
  {
    return openSub_;
  }

inline ABA_FIXCAND *ABA_MASTER::fixCand() const
  {
    return fixCand_;
  }

inline ABA_STANDARDPOOL<ABA_CONSTRAINT, ABA_VARIABLE> *ABA_MASTER::conPool() const
  {
    return conPool_;
  }

inline ABA_STANDARDPOOL<ABA_CONSTRAINT, ABA_VARIABLE> *ABA_MASTER::cutPool() const
  {
    return cutPool_;
  }

inline ABA_STANDARDPOOL<ABA_VARIABLE, ABA_CONSTRAINT> *ABA_MASTER::varPool() const
  {
    return varPool_;
  }

inline bool ABA_MASTER::cutting() const
  {
    return cutting_;
  }

inline bool ABA_MASTER::pricing() const
  {
    return pricing_;
  }
inline bool ABA_MASTER::solveApprox() const
  {
    return solveApprox_;
  }

inline const ABA_COWTIMER *ABA_MASTER::totalCowTime() const
  {
    return &totalCowTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::totalTime() const
  {
    return &totalTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::lpTime() const
  {
    return &lpTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::lpSolverTime() const
  {
    return &lpSolverTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::separationTime() const
  {
    return &separationTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::improveTime() const
  {
    return &improveTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::pricingTime() const
  {
    return &pricingTime_;
  }

inline const ABA_CPUTIMER *ABA_MASTER::branchingTime() const
  {
    return &branchingTime_;
  }

inline void ABA_MASTER::countLp()
  {
    ++nLp_;
  }

inline void ABA_MASTER::newFixed(int n)
  {
    nFixed_ += n;
  }

inline void ABA_MASTER::addCons(int n)
  {
    nAddCons_ += n;
  }

inline void ABA_MASTER::removeCons(int n)
  {
    nRemCons_ += n;
  }

inline void ABA_MASTER::addVars(int n)
  {
    nAddVars_ += n;
  }

inline void ABA_MASTER::removeVars(int n)
  {
    nRemVars_ += n;
  }

inline int ABA_MASTER::nSub() const
  {
    return nSub_;
  }

inline int ABA_MASTER::nLp() const
  {
    return nLp_;
  }

inline int ABA_MASTER::highestLevel () const
  {
    return highestLevel_;
  }

inline int ABA_MASTER::nNewRoot() const
  {
    return nNewRoot_;
  }

inline int ABA_MASTER::nSubSelected() const
  {
    return nSubSelected_;
  }

inline bool ABA_MASTER::fixSetByRedCost() const
  {
    return fixSetByRedCost_;
  }

inline void ABA_MASTER::fixSetByRedCost(bool on)
  {
    fixSetByRedCost_ = on;
  }

inline bool ABA_MASTER::printLP() const
  {
    return printLP_;
  }

inline void ABA_MASTER::printLP(bool on)
  {
    printLP_ = on;
  }

inline int ABA_MASTER::maxConAdd() const
  {
    return maxConAdd_;
  }

inline void ABA_MASTER::maxConAdd(int max)
  {
    maxConAdd_ = max;
  }

inline int ABA_MASTER::maxConBuffered() const
  {
    return maxConBuffered_;
  }

inline void ABA_MASTER::maxConBuffered(int max) 
  {
    maxConBuffered_ = max;
  }

inline int ABA_MASTER::maxVarAdd() const
  {
    return maxVarAdd_;
  }

inline void ABA_MASTER::maxVarAdd(int max)
  {
    maxVarAdd_ = max;
  }

inline int ABA_MASTER::maxVarBuffered() const
  {
    return maxVarBuffered_;
  }

inline void ABA_MASTER::maxVarBuffered(int max) 
  {
    maxVarBuffered_ = max;
  }

inline int ABA_MASTER::maxIterations() const
  {
    return maxIterations_;
  }

inline void ABA_MASTER::maxIterations(int max)
  {
    maxIterations_ = max;
  }

inline const ABA_STRING &ABA_MASTER::optimumFileName() const
  {
    return optimumFileName_;
  }

inline void ABA_MASTER::optimumFileName(const char *name)
  {
    optimumFileName_ = name;
  }

inline ABA_MASTER::STATUS ABA_MASTER::status() const
  {
    return status_;
  }

inline void ABA_MASTER::status(STATUS stat)
  {
    status_ = stat;
  }

inline bool ABA_MASTER::eliminateFixedSet() const
  {
    return eliminateFixedSet_;
  }

inline void ABA_MASTER::eliminateFixedSet(bool turnOn)
  {
    eliminateFixedSet_ = turnOn;
  }

inline bool ABA_MASTER::newRootReOptimize() const
  {
    return newRootReOptimize_;
  }

inline void ABA_MASTER::newRootReOptimize(bool on)
  {
    newRootReOptimize_ = on;
  }

inline bool ABA_MASTER::showAverageCutDistance() const
  {
    return showAverageCutDistance_;
  }

inline void ABA_MASTER::showAverageCutDistance(bool on)
  {
    showAverageCutDistance_ = on;
  }

inline ABA_MASTER::VBCMODE ABA_MASTER::vbcLog() const
  {
    return VbcLog_;
  }

inline void ABA_MASTER::vbcLog(VBCMODE mode)
  {
    VbcLog_ = mode;
  }

inline ABA_MASTER::CONELIMMODE ABA_MASTER::conElimMode() const
  {
    return conElimMode_;
  }

inline void ABA_MASTER::conElimMode(CONELIMMODE mode)
  {
    conElimMode_ = mode;
  }

inline ABA_MASTER::VARELIMMODE ABA_MASTER::varElimMode() const
  {
    return varElimMode_;
  }

inline void ABA_MASTER::varElimMode(VARELIMMODE mode)
  {
    varElimMode_ = mode;
  }

inline double ABA_MASTER::conElimEps() const
  {
    return conElimEps_;
  }

inline void ABA_MASTER::conElimEps(double eps)
  {
    conElimEps_ = eps;
  }

inline double ABA_MASTER::varElimEps() const
  {
    return varElimEps_;
  }

inline void ABA_MASTER::varElimEps(double eps)
  {
    varElimEps_ = eps;
  }

inline int ABA_MASTER::varElimAge() const
  {
    return varElimAge_;
  }

inline void ABA_MASTER::varElimAge(int age)
  {
    varElimAge_ = age;
  }

inline int ABA_MASTER::conElimAge() const
  {
    return conElimAge_;
  }

inline void ABA_MASTER::conElimAge(int age)
  {
    conElimAge_ = age;
  }

inline ABA_MASTER::ENUMSTRAT ABA_MASTER::enumerationStrategy() const
  {
    return enumerationStrategy_;
  }

inline void ABA_MASTER::enumerationStrategy(ENUMSTRAT strat)
  {
    enumerationStrategy_ = strat;
  }

inline ABA_MASTER::BRANCHINGSTRAT ABA_MASTER::branchingStrategy() const
  {
    return branchingStrategy_;
  }

inline void ABA_MASTER::branchingStrategy(BRANCHINGSTRAT strat)
  {
    branchingStrategy_ = strat;
  }

inline ABA_MASTER::OSISOLVER ABA_MASTER::defaultLpSolver() const
  {
    return defaultLpSolver_;
  }

inline void ABA_MASTER::defaultLpSolver(OSISOLVER lpSolver)
  {
    defaultLpSolver_ = lpSolver;
  }

inline int ABA_MASTER::nBranchingVariableCandidates() const
  {
    return nBranchingVariableCandidates_;
  }

inline double ABA_MASTER::requiredGuarantee() const
  {
    return requiredGuarantee_;
  }

inline int ABA_MASTER::maxLevel() const
  {
    return maxLevel_;
  }

inline const ABA_STRING& ABA_MASTER::maxCpuTime() const
  {
    return maxCpuTime_;
  }

inline void ABA_MASTER::maxCpuTime(const ABA_STRING &t)
  {
    maxCpuTime_ = t;
  }

inline const ABA_STRING& ABA_MASTER::maxCowTime() const
  {
    return maxCowTime_;
  }

inline void ABA_MASTER::maxCowTime(const ABA_STRING &t)
  {
    maxCowTime_ = t;
  }

inline bool ABA_MASTER::objInteger() const
  {
    return objInteger_;
  }

inline void ABA_MASTER::objInteger(bool b)
  {
    objInteger_ = b;
  }

inline int ABA_MASTER::tailOffNLp() const
  {
    return tailOffNLp_;
  }

inline void ABA_MASTER::tailOffNLp(int n)
  {
    tailOffNLp_ = n;
  }

inline double ABA_MASTER::tailOffPercent() const
  {
    return tailOffPercent_;
  }

inline ABA_MASTER::OUTLEVEL ABA_MASTER::outLevel() const
  {
    return outLevel_;
  }

inline void ABA_MASTER::outLevel(OUTLEVEL mode)
  {
    outLevel_ = mode;
  }

inline ABA_MASTER::OUTLEVEL ABA_MASTER::logLevel() const
  {
    return logLevel_;
  }

inline void ABA_MASTER::logLevel(OUTLEVEL mode)
  {
    logLevel_ = mode;
  }

inline void ABA_MASTER::dbThreshold(int threshold)
  {
    dbThreshold_ = threshold;
  }

inline int ABA_MASTER::dbThreshold() const
  {
    return dbThreshold_;
  }

inline int ABA_MASTER::minDormantRounds() const
  {
    return minDormantRounds_;
  }

inline void ABA_MASTER::minDormantRounds(int nRounds)
  {
    minDormantRounds_ = nRounds;
  }

inline ABA_MASTER::PRIMALBOUNDMODE ABA_MASTER::pbMode() const
  {
    return pbMode_;
  }

inline void ABA_MASTER::pbMode(PRIMALBOUNDMODE mode)
  {
    pbMode_ = mode;
  }

inline int ABA_MASTER::pricingFreq() const
  {
    return pricingFreq_;
  }

inline int ABA_MASTER::skipFactor() const
  {
    return skipFactor_;
  }

inline ABA_MASTER::SKIPPINGMODE ABA_MASTER::skippingMode() const
  {
    return skippingMode_;
  }

inline void ABA_MASTER::skippingMode(SKIPPINGMODE mode)
  {
    skippingMode_ = mode;
  }


#endif  // ABA_MASTER_H

---