/home/coin/SVN-release/CoinAll-1.1.0/Cgl/src/CglLandP/CglLandP.hpp

Go to the documentation of this file.

// Copyright (C) 2005, Pierre Bonami and others.  All Rights Reserved.
// Author:   Pierre Bonami                                                  
//           Tepper School of Business
//           Carnegie Mellon University, Pittsburgh, PA 15213
// Date:     07/21/05
//---------------------------------------------------------------------------
#ifndef CglLandP_H
#define CglLandP_H

//Several level of Debug
// 1 - A few simple sanity check
// 2 - do extra computations on cut quality
// 3 - Output cut in initial non-basic space (only if logLevel >= 3 )
// 4 - Double check (compute in two different ways) reduced cost and f+ f-
//#define LandP_DEBUG 1


#include "CglLandPValidator.hpp"
#include "CglCutGenerator.hpp"
#include "CglParam.hpp"

#ifdef DO_STAT
#include "CglLandPStats.hpp"
#endif
#include <iostream>
#include <fstream>
class CoinWarmStartBasis;
namespace LAP {
enum LapMessagesTypes
{
  BEGIN_ROUND,
  END_ROUND,
  DURING_SEP,
  CUT_REJECTED,
  CUT_FAILED,
  LAP_CUT_FAILED_DO_MIG,
  LAP_MESSAGES_DUMMY_END
};
class LapMessages : public CoinMessages
{
public:
  LapMessages( );
};
class CglLandPSimplex;
}

class CglLandP : public CglCutGenerator
{
  friend void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);

  friend class LAP::CglLandPSimplex;

public:

  enum SelectionRules {
    mostNegativeRc ,
    bestPivot 
  };
  class Parameters : public CglParam {
  public:
    Parameters();
    Parameters(const Parameters &other);
    Parameters & operator=(const Parameters &other);
    
    int pivotLimit;
    int pivotLimitInTree;
    int maxCutPerRound;
    int failedPivotLimit;
    int degeneratePivotLimit;

    double pivotTol;
    double away;
    mutable double timeLimit;
    double singleCutTimeLimit;


    bool useTableauRow;
    bool modularize;
    bool strengthen;
    int reducedSpace;
    bool perturb;
    bool scaleCuts;
    SelectionRules pivotSelection;
  };


   CglLandP(const CglLandP::Parameters &params = CglLandP::Parameters(), 
            const CglValidator &validator = CglValidator());
  ~CglLandP();
   CglLandP(const CglLandP &source);
  CglLandP& operator=(const CglLandP &rhs);
  CglCutGenerator * clone() const;

#ifdef DO_STAT

  void displayStats(){roundsStats_.displaySumUp(*logStream);}

  void setIdString(const std::string &id){roundsStats_.setIdString(id);}
#endif


  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
                            const CglTreeInfo info = CglTreeInfo()) const;


virtual bool needsOptimalBasis() const
{
  return true;
}

        CglValidator & validator(){return validator_;}
  void setLogLevel(int level)
  { handler_->setLogLevel(level);
  }
#ifdef DO_STAT
  void setLogStream(std::ostream & os)
  {
    releaseLogStream();
    logStream = &os;
  }

void openLogStream(std::string name){
  releaseLogStream();
  logStream = new std::ofstream(name.c_str(),std::ios::app);
  logAssignCount = new int;
  (*logAssignCount) = 1;
}

inline void releaseLogStream(){
  if(logAssignCount && *logAssignCount){
    (*logAssignCount)--;
    if(*logAssignCount == 0){
      delete logStream;
      delete logAssignCount;
      logAssignCount=NULL;
    }
    else logAssignCount = NULL;
}
}

void lookupProblem(const std::string &s);

#endif
  class NoBasisError : public CoinError
  {
  public:
    NoBasisError(): CoinError("No basis available","LandP",""){}
  };

  class SimplexInterfaceError : public CoinError
  {
  public:
    SimplexInterfaceError(): CoinError("Invalid conversion to simplex interface", "CglLandP","CglLandP"){}
  };
  Parameters & parameter() {return params_;}
private:
  Parameters params_;

  struct CachedData
  {
    CachedData(int nBasics = 0 , int nNonBasics = 0);
    CachedData(const CachedData & source);

    CachedData& operator=(const CachedData &source);
    void getData(const OsiSolverInterface &si);
    ~CachedData();
    int * basics_;
    int *nonBasics_;
    int nBasics_;
    int nNonBasics_;
    CoinWarmStartBasis * basis_;
    double * colsol_;
    double * slacks_;
    bool * integers_;
  };
  mutable CachedData cached_;
  CoinMessageHandler * handler_;
  CoinMessages messages_;
  CglValidator validator_;
#ifdef DO_STAT

  mutable roundsStatistics roundsStats_;
  mutable std::ostream * logStream;
  mutable int * logAssignCount;
  mutable bool used;
#endif
};
void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);

#endif

---