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