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, int deleteStuff = 2);
  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 void setOriginalModel(OsiSolverInterface *originalModel)
  {
    originalModel_ = originalModel;
  }
  inline OsiSolverInterface *startModel() const
  {
    return startModel_;
  }
  inline int numberSolvers() const
  {
    return numberSolvers_;
  }
  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;
  }
  inline void setPresolve(int iPass, OsiPresolve *presolve)
  {
    if (iPass >= 0 && iPass < numberSolvers_)
      presolve_[iPass] = presolve;
  }
  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 int options() const
  {
    return options_;
  }
  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();
 
  void setTimeLimit(const double timeLimit, const bool useElapsedTime);
 
  void setKeepColumnNames(const bool keep);
 
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_;
 
  bool useElapsedTime_;
 
  double timeLimit_;
 
  bool keepColumnNames_;
 
  double getCurrentCPUTime() const;
 
};
 
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_;
  CoinBigIndex *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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/