CglProbing.hpp

Go to the documentation of this file.

// $Id: CglProbing.hpp 1387 2017-09-29 11:02:03Z forrest $
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CglProbing_H
#define CglProbing_H

#include <string>

#include "CglCutGenerator.hpp"
  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
    unsigned int affected;
  } disaggregationAction;

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());
  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);
  void deleteCliques();
  OsiSolverInterface * cliqueModel(const OsiSolverInterface * model,
                                   int type);

  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;
  typedef struct {
    unsigned int equality:1; //  nonzero if clique is ==
  } CliqueType;

  inline int numberCliques() const
  { return numberCliques_;}
  inline CliqueType * cliqueType() const
  { return cliqueType_;}
  inline CoinBigIndex * cliqueStart() const
  { return cliqueStart_;}
  inline CliqueEntry * cliqueEntry() const
  { return cliqueEntry_;}

  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,const CoinBigIndex * rowStartPos,
             const int * realRow, const double * rowLower, const double * rowUpper,
             const char * intVar, double * minR, double * maxR, int * markR, 
             CglTreeInfo * info);
  int probeCliques( const OsiSolverInterface & si, 
             const OsiRowCutDebugger * debugger, 
             OsiCuts & cs, 
             double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
                    CoinPackedMatrix *columnCopy, const int * realRow,
             double * rowLower, double * rowUpper,
             char * intVar, double * minR, double * maxR, int * markR, 
             CglTreeInfo * info);
  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);
  int gutsOfGenerateCuts( const OsiSolverInterface & si, 
                          OsiCuts & cs,
                          double * rowLower, double * rowUpper,
                          double * colLower, double * colUpper,
                           CglTreeInfo * info);
  void setupRowCliqueInformation(const OsiSolverInterface & si);
  int tighten(double *colLower, double * colUpper,
              const int *column, const double *rowElements, 
              const CoinBigIndex *rowStart,const CoinBigIndex * rowStartPos,
              const int * rowLength,
              double *rowLower, double *rowUpper, 
              int nRows,int nCols,char * intVar,int maxpass,
              double tolerance);
  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);

  // 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_;
  int numberRows_;
  int numberColumns_;
  double primalTolerance_;
  int mode_;
  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_;
  int numberThisTime_;
  int totalTimesCalled_;
  int * lookedAt_;
  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_;
  CliqueType * cliqueType_;
  CoinBigIndex * cliqueStart_;
  CliqueEntry * cliqueEntry_;
  int * oneFixStart_;
  int * zeroFixStart_;
  int * endFixStart_;
  int * whichClique_;
  CliqueEntry * cliqueRow_;
  int * cliqueRowStart_;
  char * tightenBounds_;
};
inline int affectedInDisaggregation(const disaggregationAction & dis)
{ return dis.affected&0x1fffffff;}
inline void setAffectedInDisaggregation(disaggregationAction & dis,
                                           int affected)
{ dis.affected = affected|(dis.affected&0xe0000000);}
#ifdef NDEBUG
inline bool zeroOneInDisaggregation(const disaggregationAction & )
{ return true;}
#else
inline bool zeroOneInDisaggregation(const disaggregationAction & dis)
//{ return (dis.affected&0x80000000)!=0;}
{ assert ((dis.affected&0x80000000)!=0); return true;}
#endif
inline void setZeroOneInDisaggregation(disaggregationAction & dis,bool zeroOne)
{ dis.affected = (zeroOne ? 0x80000000 : 0)|(dis.affected&0x7fffffff);}
inline bool whenAtUBInDisaggregation(const disaggregationAction & dis)
{ return (dis.affected&0x40000000)!=0;}
inline void setWhenAtUBInDisaggregation(disaggregationAction & dis,bool whenAtUB)
{ dis.affected = (whenAtUB ? 0x40000000 : 0)|(dis.affected&0xbfffffff);}
inline bool affectedToUBInDisaggregation(const disaggregationAction & dis)
{ return (dis.affected&0x20000000)!=0;}
inline void setAffectedToUBInDisaggregation(disaggregationAction & dis,bool affectedToUB)
{ dis.affected = (affectedToUB ? 0x20000000 : 0)|(dis.affected&0xdfffffff);}

//#############################################################################
void CglProbingUnitTest(const OsiSolverInterface * siP,
                        const std::string mpdDir );
class CglImplication : public CglCutGenerator {
 
public:

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

  CglImplication ();
 
  CglImplication (CglTreeProbingInfo * info);
 
  CglImplication (
    const CglImplication &);

  virtual CglCutGenerator * clone() const;

  CglImplication &
    operator=(
    const CglImplication& rhs);
  
  virtual
    ~CglImplication ();
  virtual std::string generateCpp( FILE * fp);

  inline void setProbingInfo(CglTreeProbingInfo * info)
  { probingInfo_=info;}

private:
  CglTreeProbingInfo * probingInfo_;
};
#endif