diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/CglGMIParam.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/CglGMIParam.hpp | 313 |
1 files changed, 313 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/CglGMIParam.hpp b/newstructure/thirdparty/linux/include/coin/CglGMIParam.hpp new file mode 100644 index 0000000..a1aae41 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/CglGMIParam.hpp @@ -0,0 +1,313 @@ +// 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" + + + /**@name CglGMI Parameters */ + //@{ + + /** Class collecting parameters for the GMI cut generator. + + Parameters of the generator are listed below. Modifying the default + values for parameters other than the last four might result in + invalid cuts. + + - MAXDYN: Maximum ratio between largest and smallest non zero + coefficients in a cut. See method setMAXDYN(). + - EPS_ELIM: Precision for deciding if a coefficient is zero when + eliminating slack variables. See method setEPS_ELIM(). + - MINVIOL: Minimum violation for the current basic solution in + a generated cut. See method setMINVIOL(). + - USE_INTSLACKS: Use integer slacks to generate cuts. + (not implemented yet, will be in the future). + See method setUSE_INTSLACKS(). + - AWAY: Look only at basic integer variables whose current value is at + least this value away from being integer. See method setAway(). + - CHECK_DUPLICATES: Should we check for duplicates when adding a cut + to the collection? Can be slow. + Default 0 - do not check, add cuts anyway. + - CLEAN_PROC: Cleaning procedure that should be used. Look below at the + enumeration CleaningProcedure for possible values. + - INTEGRAL_SCALE_CONT: If we try to scale cut coefficients so that + they become integral, do we also scale on + continuous variables? + Default 0 - do not scale continuous vars. + Used only if CLEAN_PROC does integral scaling. + - ENFORCE_SCALING: Discard badly scaled cuts, or keep them (unscaled). + Default 1 - yes. + + */ + //@} + +class CglGMIParam : public CglParam { + +public: + + /**@name Enumerations */ + 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 + }; + + /**@name Set/get methods */ + + //@{ + /** Aliases for parameter get/set method in the base class CglParam */ + + /** Value for Infinity. Default: DBL_MAX */ + inline void setInfinity(double value) {setINFINIT(value);} + inline double getInfinity() const {return INFINIT;} + + /** Epsilon for comparing numbers. Default: 1.0e-6 */ + inline void setEps(double value) {setEPS(value);} + inline double getEps() const {return EPS;} + + /** Epsilon for zeroing out coefficients. Default: 1.0e-5 */ + inline void setEpsCoeff(double value) {setEPS_COEFF(value);} + inline double getEpsCoeff() const {return EPS_COEFF;} + + /** Maximum support of the cutting planes. Default: INT_MAX */ + inline void setMaxSupport(int value) {setMAX_SUPPORT(value);} + inline int getMaxSupport() const {return MAX_SUPPORT;} + /** Alias for consistency with our naming scheme */ + inline void setMaxSupportAbs(int value) {setMAX_SUPPORT(value);} + inline int getMaxSupportAbs() const {return MAX_SUPPORT;} + inline int getMAX_SUPPORT_ABS() const {return MAX_SUPPORT;} + + /** Set AWAY, the minimum distance from being integer used for selecting + rows for cut generation; all rows whose pivot variable should be + integer but is more than away from integrality will be selected; + Default: 0.005 */ + virtual void setAway(double value); + /** Get value of away */ + inline double getAway() const {return AWAY;} + /// Aliases + inline void setAWAY(double value) {setAway(value);} + inline double getAWAY() const {return AWAY;} + + /** Set the value of EPS_ELIM, epsilon for values of coefficients when + eliminating slack variables; + Default: 0 */ + virtual void setEPS_ELIM(double value); + /** Get the value of EPS_ELIM */ + inline double getEPS_ELIM() const {return EPS_ELIM;} + /// Aliases + inline void setEpsElim(double value) {setEPS_ELIM(value);} + inline double getEpsElim() const {return EPS_ELIM;} + + /** Set EPS_RELAX_ABS */ + virtual void setEPS_RELAX_ABS(double value); + /** Get value of EPS_RELAX_ABS */ + inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;} + /// Aliases + inline void setEpsRelaxAbs(double value) {setEPS_RELAX_ABS(value);} + inline double getEpsRelaxAbs() const {return EPS_RELAX_ABS;} + + /** Set EPS_RELAX_REL */ + virtual void setEPS_RELAX_REL(double value); + /** Get value of EPS_RELAX_REL */ + inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;} + /// Aliases + 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); + /** Get the value of MAXDYN */ + inline double getMAXDYN() const {return MAXDYN;} + /// Aliases + inline void setMaxDyn(double value) {setMAXDYN(value);} + inline double getMaxDyn() const {return MAXDYN;} + + /** Set the value of MINVIOL, the minimum violation for the current + basic solution in a generated cut. Default: 1e-7 */ + virtual void setMINVIOL(double value); + /** Get the value of MINVIOL */ + inline double getMINVIOL() const {return MINVIOL;} + /// Aliases + inline void setMinViol(double value) {setMINVIOL(value);} + inline double getMinViol() const {return MINVIOL;} + + /** Set the value of MAX_SUPPORT_REL, the factor contributing to the + maximum support relative to the number of columns. Maximum + allowed support is: MAX_SUPPORT_ABS + + MAX_SUPPORT_REL*ncols. Default: 0.1 */ + virtual void setMAX_SUPPORT_REL(double value); + /** Get the value of MINVIOL */ + inline double getMAX_SUPPORT_REL() const {return MAX_SUPPORT_REL;} + /// Aliases + inline void setMaxSupportRel(double value) {setMAX_SUPPORT_REL(value);} + inline double getMaxSupportRel() const {return MAX_SUPPORT_REL;} + + /** Set the value of USE_INTSLACKS. Default: 0 */ + virtual void setUSE_INTSLACKS(bool value); + /** Get the value of USE_INTSLACKS */ + inline bool getUSE_INTSLACKS() const {return USE_INTSLACKS;} + /// Aliases + inline void setUseIntSlacks(bool value) {setUSE_INTSLACKS(value);} + inline int getUseIntSlacks() const {return USE_INTSLACKS;} + + /** Set the value of CHECK_DUPLICATES. Default: 0 */ + virtual void setCHECK_DUPLICATES(bool value); + /** Get the value of CHECK_DUPLICATES */ + inline bool getCHECK_DUPLICATES() const {return CHECK_DUPLICATES;} + /// Aliases + inline void setCheckDuplicates(bool value) {setCHECK_DUPLICATES(value);} + inline bool getCheckDuplicates() const {return CHECK_DUPLICATES;} + + /** Set the value of CLEAN_PROC. Default: CP_CGLLANDP1 */ + virtual void setCLEAN_PROC(CleaningProcedure value); + /** Get the value of CLEAN_PROC. */ + inline CleaningProcedure getCLEAN_PROC() const {return CLEAN_PROC;} + /// Aliases + inline void setCleanProc(CleaningProcedure value) {setCLEAN_PROC(value);} + inline CleaningProcedure getCleaningProcedure() const {return CLEAN_PROC;} + + /** Set the value of INTEGRAL_SCALE_CONT. Default: 0 */ + virtual void setINTEGRAL_SCALE_CONT(bool value); + /** Get the value of INTEGRAL_SCALE_CONT. */ + inline bool getINTEGRAL_SCALE_CONT() const {return INTEGRAL_SCALE_CONT;} + /// Aliases + inline void setIntegralScaleCont(bool value) {setINTEGRAL_SCALE_CONT(value);} + inline bool getIntegralScaleCont() const {return INTEGRAL_SCALE_CONT;} + + /** Set the value of ENFORCE_SCALING. Default: 1 */ + virtual void setENFORCE_SCALING(bool value); + /** Get the value of ENFORCE_SCALING. */ + inline bool getENFORCE_SCALING() const {return ENFORCE_SCALING;} + /// Aliases + inline void setEnforceScaling(bool value) {setENFORCE_SCALING(value);} + inline bool getEnforcescaling() const {return ENFORCE_SCALING;} + + //@} + + /**@name Constructors and destructors */ + //@{ + /// Default constructor + 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); + + /// Constructor from CglParam + 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); + + /// Copy constructor + CglGMIParam(const CglGMIParam &source); + + /// Clone + virtual CglGMIParam* clone() const; + + /// Assignment operator + virtual CglGMIParam& operator=(const CglGMIParam &rhs); + + /// Destructor + virtual ~CglGMIParam(); + //@} + +protected: + + /**@name Parameters */ + //@{ + + /** Use row only if pivot variable should be integer but is more + than AWAY from being integer. */ + double AWAY; + + /** Epsilon for value of coefficients when eliminating slack variables. + Default: 0. */ + double EPS_ELIM; + + /** Value added to the right hand side of each generated cut to relax it. + Default: 1e-11 */ + double EPS_RELAX_ABS; + + /** For a generated cut with right hand side rhs_val, + EPS_RELAX_EPS * fabs(rhs_val) is used to relax the constraint. + Default: 1.e-13 */ + double EPS_RELAX_REL; + + /** Maximum ratio between largest and smallest non zero + coefficients in a cut. Default: 1e6. */ + double MAXDYN; + + /** Minimum violation for the current basic solution in a generated cut. + Default: 1e-4. */ + double MINVIOL; + + /** Maximum support relative to number of columns. Must be between 0 + and 1. Default: 0. */ + double MAX_SUPPORT_REL; + + /** Which cleaning procedure should be used? */ + CleaningProcedure CLEAN_PROC; + + /** Use integer slacks to generate cuts if USE_INTSLACKS = 1. Default: 0. */ + bool USE_INTSLACKS; + + /** Check for duplicates when adding the cut to the collection? */ + bool CHECK_DUPLICATES; + + /** Should we try to rescale cut coefficients on continuous variables + so that they become integral, or do we only rescale coefficients + on integral variables? Used only by cleaning procedure that try + the integral scaling. */ + bool INTEGRAL_SCALE_CONT; + + /** Should we discard badly scaled cuts (according to the scaling + procedure in use)? If false, CglGMI::scaleCut always returns + true, even though it still scales cuts whenever possible, but + not cut is rejected for scaling. Default true. Used only by + cleaning procedure that try to scale. */ + bool ENFORCE_SCALING; + + //@} +}; + +#endif |