CglGMIParam.hpp

Go to the documentation of this file.

// Name:     CglGMIParam.hpp
// Author:   Giacomo Nannicini
//           Singapore University of Technology and Design
//           email: nannicini@sutd.edu.sg
//           based on CglRedSplitParam.hpp by Francois Margot
// Date:     11/17/09
//-----------------------------------------------------------------------------
// Copyright (C) 2009, Giacomo Nannicini and others.  All Rights Reserved.
 
#ifndef CglGMIParam_H
#define CglGMIParam_H
 
#include "CglParam.hpp"
 
 
 
 
class CglGMIParam : public CglParam {
 
public:
 
  enum CleaningProcedure{
    /* CglLandP procedure I */
    CP_CGLLANDP1,
    /* CglLandP procedure II */
    CP_CGLLANDP2,
    /* CglRedSplit procedure I */
    CP_CGLREDSPLIT,
    /* Only integral cuts, i.e. cuts with integral coefficients */
    CP_INTEGRAL_CUTS,
    /* CglLandP procedure I with integral scaling */
    CP_CGLLANDP1_INT,
    /* CglLandP procedure I with scaling of the max element to 1 if possible */
    CP_CGLLANDP1_SCALEMAX,
    /* CglLandP procedure I with scaling of the rhs to 1 if possible */
    CP_CGLLANDP1_SCALERHS
  };
 
  inline void setInfinity(double value) {setINFINIT(value);}
  inline double getInfinity() const {return INFINIT;}
 
  inline void setEps(double value) {setEPS(value);}
  inline double getEps() const {return EPS;}
 
  inline void setEpsCoeff(double value) {setEPS_COEFF(value);}
  inline double getEpsCoeff() const {return EPS_COEFF;}
 
  inline void setMaxSupport(int value) {setMAX_SUPPORT(value);}
  inline int getMaxSupport() const {return MAX_SUPPORT;}
  inline void setMaxSupportAbs(int value) {setMAX_SUPPORT(value);}
  inline int getMaxSupportAbs() const {return MAX_SUPPORT;}
  inline int getMAX_SUPPORT_ABS() const {return MAX_SUPPORT;}
 
  virtual void setAway(double value);
  inline double getAway() const {return AWAY;}
  inline void setAWAY(double value) {setAway(value);}
  inline double getAWAY() const {return AWAY;}
 
  virtual void setEPS_ELIM(double value);
  inline double getEPS_ELIM() const {return EPS_ELIM;}
  inline void setEpsElim(double value) {setEPS_ELIM(value);}
  inline double getEpsElim() const {return EPS_ELIM;}
  
  virtual void setEPS_RELAX_ABS(double value);
  inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;}
  inline void setEpsRelaxAbs(double value) {setEPS_RELAX_ABS(value);}
  inline double getEpsRelaxAbs() const {return EPS_RELAX_ABS;}
 
  virtual void setEPS_RELAX_REL(double value);
  inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;}
  inline void setEpsRelaxRel(double value) {setEPS_RELAX_REL(value);}
  inline double getEpsRelaxRel() const {return EPS_RELAX_REL;}
 
  // Set the maximum ratio between largest and smallest non zero 
  // coefficients in a cut. Default: 1e6.
  virtual void setMAXDYN(double value);
  inline double getMAXDYN() const {return MAXDYN;}
  inline void setMaxDyn(double value) {setMAXDYN(value);}
  inline double getMaxDyn() const {return MAXDYN;}
 
  virtual void setMINVIOL(double value);
  inline double getMINVIOL() const {return MINVIOL;}
  inline void setMinViol(double value) {setMINVIOL(value);}
  inline double getMinViol() const {return MINVIOL;}
 
  virtual void setMAX_SUPPORT_REL(double value);
  inline double getMAX_SUPPORT_REL() const {return MAX_SUPPORT_REL;}
  inline void setMaxSupportRel(double value) {setMAX_SUPPORT_REL(value);}
  inline double getMaxSupportRel() const {return MAX_SUPPORT_REL;}
 
  virtual void setUSE_INTSLACKS(bool value);
  inline bool getUSE_INTSLACKS() const {return USE_INTSLACKS;}
  inline void setUseIntSlacks(bool value) {setUSE_INTSLACKS(value);}
  inline int getUseIntSlacks() const {return USE_INTSLACKS;}
 
  virtual void setCHECK_DUPLICATES(bool value);
  inline bool getCHECK_DUPLICATES() const {return CHECK_DUPLICATES;}
  inline void setCheckDuplicates(bool value) {setCHECK_DUPLICATES(value);}
  inline bool getCheckDuplicates() const {return CHECK_DUPLICATES;}
 
  virtual void setCLEAN_PROC(CleaningProcedure value);
  inline CleaningProcedure getCLEAN_PROC() const {return CLEAN_PROC;}
  inline void setCleanProc(CleaningProcedure value) {setCLEAN_PROC(value);}
  inline CleaningProcedure getCleaningProcedure() const {return CLEAN_PROC;}
 
  virtual void setINTEGRAL_SCALE_CONT(bool value);
  inline bool getINTEGRAL_SCALE_CONT() const {return INTEGRAL_SCALE_CONT;}
  inline void setIntegralScaleCont(bool value) {setINTEGRAL_SCALE_CONT(value);}
  inline bool getIntegralScaleCont() const {return INTEGRAL_SCALE_CONT;}
 
  virtual void setENFORCE_SCALING(bool value);
  inline bool getENFORCE_SCALING() const {return ENFORCE_SCALING;}
  inline void setEnforceScaling(bool value) {setENFORCE_SCALING(value);}
  inline bool getEnforcescaling() const {return ENFORCE_SCALING;}
 
 
  CglGMIParam(double eps = 1e-12,
              double away = 0.005,
              double eps_coeff = 1e-11,
              double eps_elim = 0,
              double eps_relax_abs = 1e-11,
              double eps_relax_rel = 1e-13,
              double max_dyn = 1e6,
              double min_viol = 1e-4,
              int max_supp_abs = 1000,
              double max_supp_rel = 0.1,
              CleaningProcedure clean_proc = CP_CGLLANDP1,
              bool use_int_slacks = false,
              bool check_duplicates = false,
              bool integral_scale_cont = false,
              bool enforce_scaling = true);
 
  CglGMIParam(CglParam &source,
              double away = 0.005,
              double eps_elim = 1e-12,
              double eps_relax_abs = 1e-11,
              double eps_relax_rel = 1e-13,
              double max_dyn = 1e6,
              double min_viol = 1e-4,
              double max_supp_rel = 0.1,
              CleaningProcedure clean_proc = CP_CGLLANDP1,
              bool use_int_slacks = false,
              bool check_duplicates = false,
              bool integral_scale_cont = false,
              bool enforce_scaling = true);
  
  CglGMIParam(const CglGMIParam &source);
 
  virtual CglGMIParam* clone() const;
 
  virtual CglGMIParam& operator=(const CglGMIParam &rhs);
 
  virtual ~CglGMIParam();
 
protected:
 
 
  double AWAY;
 
  double EPS_ELIM;
 
  double EPS_RELAX_ABS;
 
  double EPS_RELAX_REL;
 
  double MAXDYN;
 
  double MINVIOL;
 
  double MAX_SUPPORT_REL;
 
  CleaningProcedure CLEAN_PROC;
 
  bool USE_INTSLACKS;
 
  bool CHECK_DUPLICATES;
 
  bool INTEGRAL_SCALE_CONT;
 
  bool ENFORCE_SCALING;
 
};
 
#endif