CglPreProcess.hpp

Go to the documentation of this file.

// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CglPreProcess_H
#define CglPreProcess_H

#include <string>
#include <vector>

#include "CoinMessageHandler.hpp"
#include "OsiSolverInterface.hpp"
#include "CglStored.hpp"
#include "OsiPresolve.hpp"
#include "CglCutGenerator.hpp"

//#############################################################################

class CglPreProcess  {
  
public:



  OsiSolverInterface * preProcess(OsiSolverInterface & model, 
                                  bool makeEquality=false, int numberPasses=5);
  OsiSolverInterface * preProcessNonDefault(OsiSolverInterface & model, 
                                  int makeEquality=0, int numberPasses=5,
                                            int tuning=0);
  void postProcess(OsiSolverInterface &model
                   ,bool deleteStuff=true);
  int tightenPrimalBounds(OsiSolverInterface & model,double factor=0.0);
  OsiSolverInterface * someFixed(OsiSolverInterface & model, 
                                 double fractionToKeep=0.25,
                                 bool fixContinuousAsWell=false,
                                 char * keep=NULL) const;
  OsiSolverInterface * cliqueIt(OsiSolverInterface & model,
                                double cliquesNeeded=0.0) const;
  int reducedCostFix(OsiSolverInterface & model);

  //---------------------------------------------------------------------------

  void setCutoff(double value) ;

  double getCutoff() const;
  inline OsiSolverInterface * originalModel() const
  { return originalModel_;}
  inline OsiSolverInterface * startModel() const
  { return startModel_;}
  inline OsiSolverInterface * modelAtPass(int iPass) const
  { if (iPass>=0&&iPass<numberSolvers_) return model_[iPass]; else return NULL;}
  inline OsiSolverInterface * modifiedModel(int iPass) const
  { if (iPass>=0&&iPass<numberSolvers_) return modifiedModel_[iPass]; else return NULL;}
  inline OsiPresolve * presolve(int iPass) const
  { if (iPass>=0&&iPass<numberSolvers_) return presolve_[iPass]; else return NULL;}
  const int * originalColumns();
  const int * originalRows();
  inline int numberSOS() const
  { return numberSOS_;}
  inline const int * typeSOS() const
  { return typeSOS_;}
  inline const int * startSOS() const
  { return startSOS_;}
  inline const int * whichSOS() const
  { return whichSOS_;}
  inline const double * weightSOS() const
  { return weightSOS_;}
  void passInProhibited(const char * prohibited,int numberColumns);
  inline const char * prohibited()
  { return prohibited_;}
  inline int numberIterationsPre() const
  { return numberIterationsPre_;}
  inline int numberIterationsPost() const
  { return numberIterationsPost_;}
  void passInRowTypes(const char * rowTypes,int numberRows);
  inline const char * rowTypes()
  { return rowType_;}
  inline const CglStored & cuts() const
  { return cuts_;}
  inline const CglStored * cutsPointer() const
  { return &cuts_;}
  void update(const OsiPresolve * pinfo,const OsiSolverInterface * solver);
  inline void setOptions(int value)
  { options_=value;}


  inline int numberCutGenerators() const
  { return numberCutGenerators_;}
  inline CglCutGenerator ** cutGenerators() const
  { return generator_;}
  inline CglCutGenerator * cutGenerator(int i) const
  { return generator_[i];}
  void addCutGenerator(CglCutGenerator * generator);
    
    void setApplicationData (void * appData);

    void * getApplicationData() const;
  
  //---------------------------------------------------------------------------

  void passInMessageHandler(CoinMessageHandler * handler);
  void newLanguage(CoinMessages::Language language);
  inline void setLanguage(CoinMessages::Language language)
  {newLanguage(language);}
  inline CoinMessageHandler * messageHandler() const
  {return handler_;}
  inline CoinMessages messages() 
  {return messages_;}
  inline CoinMessages * messagesPointer() 
  {return &messages_;}
  //---------------------------------------------------------------------------



  CglPreProcess(); 
  
  CglPreProcess(const CglPreProcess & rhs);
  
  CglPreProcess & operator=(const CglPreProcess& rhs);

  ~CglPreProcess ();
  
  void gutsOfDestructor();
private:



  OsiSolverInterface * modified(OsiSolverInterface * model,
                                bool constraints,
                                int & numberChanges,
                                int iBigPass,
                                int numberPasses);
  void createOriginalIndices();
  void makeInteger();

//---------------------------------------------------------------------------

private:


  OsiSolverInterface * originalModel_;
  OsiSolverInterface * startModel_;
  int numberSolvers_;
  OsiSolverInterface ** model_;
  OsiSolverInterface ** modifiedModel_;
  OsiPresolve ** presolve_;

  CoinMessageHandler * handler_;

  bool defaultHandler_;

  CoinMessages messages_;

  void * appData_;
  int * originalColumn_;
  int * originalRow_;
  int numberCutGenerators_;
  CglCutGenerator ** generator_;
  int numberSOS_;
  int * typeSOS_;
  int * startSOS_;
  int * whichSOS_;
  double * weightSOS_;
  int numberProhibited_;
  int numberIterationsPre_;
  int numberIterationsPost_;
  char * prohibited_;
  int numberRowType_;
  int options_;
  char * rowType_;
  CglStored cuts_;
};
class CglBK  {
  
public:


  void bronKerbosch();
  OsiSolverInterface * newSolver(const OsiSolverInterface & model);

  //---------------------------------------------------------------------------



  //---------------------------------------------------------------------------



  CglBK(); 
  
  CglBK(const OsiSolverInterface & model, const char * rowType,
        int numberElements);
  
  CglBK(const CglBK & rhs);
  
  CglBK & operator=(const CglBK& rhs);

  ~CglBK ();
  

//---------------------------------------------------------------------------

private:

  int * candidates_;
  char * mark_;
  int * start_;
  int * otherColumn_;
  int * originalRow_;
  int * dominated_;
  CoinPackedMatrix * cliqueMatrix_;
  const char * rowType_;
  int numberColumns_;
  int numberRows_;
  int numberPossible_;
  int numberCandidates_;
  int firstNot_;
  int numberIn_;
  int left_;
  int lastColumn_;
};
// for hashing
typedef struct {
  int index, next;
} CglHashLink;
class OsiRowCut;
class CglUniqueRowCuts {
public:

  CglUniqueRowCuts(int initialMaxSize=0, int hashMultiplier=4 );
  ~CglUniqueRowCuts();
  CglUniqueRowCuts(const CglUniqueRowCuts& rhs);
  CglUniqueRowCuts& operator=(const CglUniqueRowCuts& rhs);
  inline OsiRowCut * cut(int sequence) const
  { return rowCut_[sequence];}
  inline int numberCuts() const
  { return numberCuts_;}
  inline int sizeRowCuts() const
  { return numberCuts_;}
  inline OsiRowCut * rowCutPtr(int sequence)
  { return rowCut_[sequence];}
  void eraseRowCut(int sequence);
  // insert cut
  inline void insert(const OsiRowCut & cut)
  { insertIfNotDuplicate(cut);}
  // Return 0 if added, 1 if not
  int insertIfNotDuplicate(const OsiRowCut & cut);
  // Add in cuts as normal cuts (and delete)
  void addCuts(OsiCuts & cs);
private:
  OsiRowCut ** rowCut_;
  CglHashLink *hash_;
  int size_;
  int hashMultiplier_;
  int numberCuts_;
  int lastHash_;
};
#endif