Cgl/Doxygen/CglProbing_8hpp_source.html

// $Id$

// 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