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

Go to the documentation of this file.

// 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 CglTreeInfo info = CglTreeInfo()) const;
  int generateCutsAndModify( const OsiSolverInterface & si, OsiCuts & cs, 
                             CglTreeInfo * info);

  int snapshot ( const OsiSolverInterface & si,
                  char * possible=NULL,
                  bool withObjective=true);
  void deleteSnapshot ( );
  int createCliques( OsiSolverInterface & si, 
                    int minimumSize=2, int maximumSize=100, bool extendCliques=false);
  void deleteCliques();


  const double * tightLower() const;
  const double * tightUpper() const;
  const char * tightenBounds() const
  { return tightenBounds_;}


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


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


  void setMaxPass(int value);
  int getMaxPass() const;
  void setLogLevel(int value);
  int getLogLevel() const;
  void setMaxProbe(int value);
  int getMaxProbe() const;
  void setMaxLook(int value);
  int getMaxLook() const;
  void setMaxElements(int value);
  int getMaxElements() const;
  void setMaxPassRoot(int value);
  int getMaxPassRoot() const;
  void setMaxProbeRoot(int value);
  int getMaxProbeRoot() const;
  void setMaxLookRoot(int value);
  int getMaxLookRoot() const;
  void setMaxElementsRoot(int value);
  int getMaxElementsRoot() const;
  virtual bool mayGenerateRowCutsInTree() const;


  inline int numberThisTime() const
  { return numberThisTime_;}
  inline const int * lookedAt() const
  { return lookedAt_;}



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

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


  void tightenThese(const OsiSolverInterface & solver, int number, const int * which);


  CglProbing ();
 
  CglProbing (
    const CglProbing &);

  virtual CglCutGenerator * clone() const;

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

  virtual void refreshSolver(OsiSolverInterface * solver);
  virtual std::string generateCpp( FILE * fp);
      
private:
  
 // Private member methods

  int probe( const OsiSolverInterface & si, 
             const OsiRowCutDebugger * debugger, 
             OsiCuts & cs, 
             double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
             CoinPackedMatrix *columnCopy,
             double * rowLower, double * rowUpper,
             char * intVar, double * minR, double * maxR, int * markR, 
              CglTreeInfo * info) const;
  int probeCliques( const OsiSolverInterface & si, 
             const OsiRowCutDebugger * debugger, 
             OsiCuts & cs, 
             double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
                    CoinPackedMatrix *columnCopy,
             double * rowLower, double * rowUpper,
             char * intVar, double * minR, double * maxR, int * markR, 
             CglTreeInfo * info) const;
  int probeSlacks( const OsiSolverInterface & si, 
                    const OsiRowCutDebugger * debugger, 
                    OsiCuts & cs, 
                    double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
                   CoinPackedMatrix *columnCopy,
                    double * rowLower, double * rowUpper,
                    char * intVar, double * minR, double * maxR,int * markR,
                     CglTreeInfo * info) const;
  int gutsOfGenerateCuts( const OsiSolverInterface & si, 
                          OsiCuts & cs,
                          double * rowLower, double * rowUpper,
                          double * colLower, double * colUpper,
                           CglTreeInfo * info) const;
  void setupRowCliqueInformation(const OsiSolverInterface & si);
  int tighten(double *colLower, double * colUpper,
              const int *column, const double *rowElements, 
              const CoinBigIndex *rowStart, const int * rowLength,
              double *rowLower, double *rowUpper, 
              int nRows,int nCols,char * intVar,int maxpass,
              double tolerance) const;
  void tighten2(double *colLower, double * colUpper,
                const int *column, const double *rowElements, 
                const CoinBigIndex *rowStart, const int * rowLength,
                double *rowLower, double *rowUpper, 
                double * minR, double * maxR, int * markR,
                int nRows,int nCols) const;

  // Private member data

  struct disaggregation_struct_tag ;
  friend struct CglProbing::disaggregation_struct_tag ;


  CoinPackedMatrix * rowCopy_;
  CoinPackedMatrix * columnCopy_;
  double * rowLower_;
  double * rowUpper_;
  double * colLower_;
  double * colUpper_;
  mutable int numberRows_;
  mutable int numberColumns_;
  double primalTolerance_;
  int mode_;
  mutable int rowCuts_;
  int maxPass_;
  int logLevel_;
  int maxProbe_;
  int maxStack_;
  int maxElements_;
  int maxPassRoot_;
  int maxProbeRoot_;
  int maxStackRoot_;
  int maxElementsRoot_;
  int usingObjective_;
  int numberIntegers_;
  int number01Integers_;
  mutable int numberThisTime_;
  mutable int * lookedAt_;
  typedef struct {
    unsigned int zeroOne:1; // nonzero if affected variable is 0-1
    unsigned int whenAtUB:1; // nonzero if fixing happens when this variable at 1
    unsigned int affectedToUB:1; // nonzero if affected variable fixed to UB
    unsigned int affected:29; // If 0-1 then 0-1 sequence, otherwise true
  } disaggregationAction;
  typedef struct disaggregation_struct_tag {
    int sequence; // integer variable
    // index will be NULL if no probing done yet
    int length; // length of newValue
    disaggregationAction * index; // columns whose bounds will be changed
  } disaggregation;
  disaggregation * cutVector_;
  int numberCliques_;
  typedef struct {
    unsigned int equality:1; //  nonzero if clique is ==
  } cliqueType;
  cliqueType * cliqueType_;
  int * cliqueStart_;
  typedef struct {
    unsigned int oneFixes:1; //  nonzero if variable to 1 fixes all
    unsigned int sequence:31; //  variable (in matrix) (but also see cliqueRow_)
  } cliqueEntry;
  cliqueEntry * cliqueEntry_;
  int * oneFixStart_;
  int * zeroFixStart_;
  int * endFixStart_;
  int * whichClique_;
  cliqueEntry * cliqueRow_;
  int * cliqueRowStart_;
  char * tightenBounds_;
};

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

---