CglProbing.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CglProbing_H
#define CglProbing_H

#include <string>

#include "CglCutGenerator.hpp"

class CglProbing : public CglCutGenerator {
   friend void CglProbingUnitTest(const OsiSolverInterface * siP,
                                  const std::string mpdDir );
 
public:
    
  
  virtual void generateCuts( const OsiSolverInterface & si, 
                             OsiCuts & cs) const;
  int generateCutsAndModify( const OsiSolverInterface & si, 
                             OsiCuts & cs);






  void snapshot ( const OsiSolverInterface & si,
                  char * possible=NULL);


  void deleteSnapshot ( );


  const double * tightLower() const;
  const double * tightUpper() const;


  const double * relaxedRowLower() const;
  const double * relaxedRowUpper() const;


  void setMode(int mode);
  int getMode() const;


  void setMaxPass(int value);
  int getMaxPass() const;
  void setMaxProbe(int value);
  int getMaxProbe() const;
  void setMaxLook(int value);
  int getMaxLook() const;



  void setRowCuts(int type);
  int rowCuts() const;


  void setUsingObjective(bool yesNo);
  int getUsingObjective() const;


  CglProbing ();
 
  CglProbing (
    const CglProbing &);

  CglProbing &
    operator=(
    const CglProbing& rhs);
  
  virtual
    ~CglProbing ();

  virtual void refreshSolver(OsiSolverInterface * solver);
      
private:
  
 // Private member methods

  int probe( const OsiSolverInterface & si, 
             const OsiRowCutDebugger * debugger, 
             OsiCuts & cs, 
             double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
             double * rowLower, double * rowUpper,
             char * intVar, double * minR, double * maxR, int * markR, 
             int * look, int nlook) const;
  int gutsOfGenerateCuts( const OsiSolverInterface & si, 
                          OsiCuts & cs,
                          double * rowLower, double * rowUpper,
                          double * colLower, double * colUpper) const;

  // Private member data


  CoinPackedMatrix * rowCopy_;
  double * rowLower_;
  double * rowUpper_;
  double * colLower_;
  double * colUpper_;
  int numberRows_;
  int numberColumns_;
  double primalTolerance_;
  int mode_;
  int rowCuts_;
  int maxPass_;
  int maxProbe_;
  int maxStack_;
  bool usingObjective_;
  int numberIntegers_;
  typedef struct{
    int sequence; // integer variable
    // newValue will be NULL if no probing done yet
    // lastLBWhenAt1 gives length of newValue;
    int lastUBWhenAt0; // last UB changed when integer at lb 
    int lastLBWhenAt0; // last LB changed when integer at lb
    int lastUBWhenAt1; // last UB changed when integer at ub
    int lastLBWhenAt1; // last LB changed when integer at ub
    int * index; // columns whose bounds will be changed
    double * newValue; // new values 
  } disaggregation;
  disaggregation * cutVector_;
};

//#############################################################################
void CglProbingUnitTest(const OsiSolverInterface * siP,
                        const std::string mpdDir );
  
#endif

---