ruby-cbc 0.1.9

data/ext/ruby-cbc/install/include/coin/CglGMI.hpp

@@ -0,0 +1,364 @@
+// Last edit: 02/05/2013
+//
+// Name:     CglGMI.hpp
+// Author:   Giacomo Nannicini
+//           Singapore University of Technology and Design, Singapore
+//           email: nannicini@sutd.edu.sg
+// Date:     11/17/09
+//-----------------------------------------------------------------------------
+// Copyright (C) 2009, Giacomo Nannicini.  All Rights Reserved.
+
+#ifndef CglGMI_H
+#define CglGMI_H
+
+#include "CglCutGenerator.hpp"
+#include "CglGMIParam.hpp"
+#include "CoinWarmStartBasis.hpp"
+#include "CoinFactorization.hpp"
+
+/* Enable tracking of rejection of cutting planes. If this is disabled,
+   the cut generator is slightly faster. If defined, it enables proper use
+   of setTrackRejection and related functions. */
+//#define TRACK_REJECT
+
+/* Debug output */
+//#define GMI_TRACE
+
+/* Debug output: print optimal tableau */
+//#define GMI_TRACETAB
+
+/* Print reason for cut rejection, whenever a cut is discarded */
+//#define GMI_TRACE_CLEAN
+
+/** Gomory cut generator with several cleaning procedures, used to test
+ *  the numerical safety of the resulting cuts 
+ */
+
+class CglGMI : public CglCutGenerator {
+
+  friend void CglGMIUnitTest(const OsiSolverInterface * siP,
+			     const std::string mpdDir);
+public:
+
+  /** Public enum: all possible reasons for cut rejection */
+  enum RejectionType{
+    failureFractionality,
+    failureDynamism,
+    failureViolation,
+    failureSupport,
+    failureScale
+  };
+
+  /**@name generateCuts */
+  //@{
+  /** Generate Gomory Mixed-Integer cuts for the model of the solver
+      interface si.
+
+      Insert the generated cuts into OsiCuts cs.
+
+      Warning: This generator currently works only with the Lp solvers Clp or 
+      Cplex9.0 or higher. It requires access to the optimal tableau and 
+      optimal basis inverse and makes assumptions on the way slack variables 
+      are added by the solver. The Osi implementations for Clp and Cplex 
+      verify these assumptions.
+
+      When calling the generator, the solver interface si must contain
+      an optimized problem and information related to the optimal
+      basis must be available through the OsiSolverInterface methods
+      (si->optimalBasisIsAvailable() must return 'true'). It is also
+      essential that the integrality of structural variable i can be
+      obtained using si->isInteger(i).
+
+  */
+  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+			    const CglTreeInfo info = CglTreeInfo());
+
+  /// Return true if needs optimal basis to do cuts (will return true)
+  virtual bool needsOptimalBasis() const { return true; }
+  //@}
+
+  /**@name Common Methods */
+  //@{
+  // Function for checking equality with user tolerance
+  inline bool areEqual(double x, double y, 
+		       double epsAbs = 1e-12, 
+		       double epsRel = 1e-12) {
+    return (fabs((x) - (y)) <= 
+	    std::max(epsAbs, epsRel * std::max(fabs(x), fabs(y))));
+  }
+
+  // Function for checking is a number is zero
+  inline bool isZero(double x, double epsZero = 1e-20) {
+    return (fabs(x) <= epsZero);
+  }
+
+
+  // Function for checking if a number is integer
+  inline bool isIntegerValue(double x, 
+			     double intEpsAbs = 1e-9,
+			     double intEpsRel = 1e-15) {
+    return (fabs((x) - floor((x)+0.5)) <= 
+	    std::max(intEpsAbs, intEpsRel * fabs(x)));
+  }
+
+  
+  //@}
+  
+  
+  /**@name Public Methods */
+  //@{
+
+  // Set the parameters to the values of the given CglGMIParam object.
+  void setParam(const CglGMIParam &source); 
+  // Return the CglGMIParam object of the generator. 
+  inline CglGMIParam getParam() const {return param;}
+  inline CglGMIParam & getParam() {return param;}
+
+  // Compute entries of is_integer.
+  void computeIsInteger();
+
+  /// Print the current simplex tableau  
+  void printOptTab(OsiSolverInterface *solver) const;
+
+  /// Set/get tracking of the rejection of cutting planes.
+  /// Note that all rejection related functions will not do anything 
+  /// unless the generator is compiled with the define GMI_TRACK_REJECTION
+  void setTrackRejection(bool value);
+  bool getTrackRejection();
+
+  /// Get number of cuts rejected for given reason; see above
+  int getNumberRejectedCuts(RejectionType reason);
+
+  /// Reset counters for cut rejection tracking; see above
+  void resetRejectionCounters();
+
+  /// Get total number of generated cuts since last resetRejectionCounters()
+  int getNumberGeneratedCuts();
+  
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglGMI();
+
+  /// Constructor with specified parameters 
+  CglGMI(const CglGMIParam &param);
+ 
+  /// Copy constructor 
+  CglGMI(const CglGMI &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglGMI & operator=(const CglGMI& rhs);
+  
+  /// Destructor 
+  virtual ~CglGMI();
+  /// Create C++ lines to get to current state
+  virtual std::string generateCpp( FILE * fp);
+
+  //@}
+    
+private:
+  
+  // Private member methods
+
+/**@name Private member methods */
+
+  //@{
+
+  // Method generating the cuts after all CglGMI members are properly set.
+  void generateCuts(OsiCuts & cs);
+
+  /// Compute the fractional part of value, allowing for small error.
+  inline double aboveInteger(double value) const; 
+
+  /// Compute the fractionalities involved in the cut, and the cut rhs.
+  /// Returns true if cut is accepted, false if discarded
+  inline bool computeCutFractionality(double varRhs, double& cutRhs);
+
+  /// Compute the cut coefficient on a given variable
+  inline double computeCutCoefficient(double rowElem, int index);
+
+  /// Use multiples of the initial inequalities to cancel out the coefficient
+  /// on a slack variables. 
+  inline void eliminateSlack(double cutElem, int cutIndex, double* cut,
+			      double& cutRhs, const double *elements, 
+			      const int *rowStart, const int *indices, 
+			      const int *rowLength, const double *rhs);
+
+  /// Change the sign of the coefficients of the non basic
+  /// variables at their upper bound.
+  inline void flip(double& rowElem, int rowIndex);
+
+  /// Change the sign of the coefficients of the non basic
+  /// variables at their upper bound and do the translations restoring
+  /// the original bounds. Modify the right hand side
+  /// accordingly. Two functions: one for original variables, one for slacks.
+  inline void unflipOrig(double& rowElem, int rowIndex, double& rowRhs);
+  inline void unflipSlack(double& rowElem, int rowIndex, double& rowRhs,
+			   const double* slack_val);
+
+  /// Pack a row of ncol elements
+  inline void packRow(double* row, double* rowElem, int* rowIndex,
+		       int& rowNz);
+
+  /// Clean the cutting plane; the cleaning procedure does several things
+  /// like removing small coefficients, scaling, and checks several
+  /// acceptance criteria. If this returns false, the cut should be discarded.
+  /// There are several cleaning procedures available, that can be selected
+  /// via the parameter param.setCLEANING_PROCEDURE(int value)
+  bool cleanCut(double* cutElem, int* cutIndex, int& cutNz,
+		 double& cutRhs, const double* xbar);
+
+  /// Cut cleaning procedures: return true if successfull, false if
+  /// cut should be discarded by the caller of if problems encountered
+
+  /// Check the violation
+  bool checkViolation(const double* cutElem, const int* cutIndex,
+		       int cutNz, double cutrhs, const double* xbar);
+
+  /// Check the dynamism
+  bool checkDynamism(const double* cutElem, const int* cutIndex,
+		      int cutNz);
+
+  /// Check the support
+  bool checkSupport(int cutNz);
+
+  /// Remove small coefficients and adjust the rhs accordingly
+  bool removeSmallCoefficients(double* cutElem, int* cutIndex, 
+				 int& cutNz, double& cutRhs);
+
+  /// Adjust the rhs by relaxing by a small amount (relative or absolute)
+  void relaxRhs(double& rhs);
+
+  /// Scale the cutting plane in different ways;
+  /// scaling_type possible values:
+  /// 0 : scale to obtain integral cut
+  /// 1 : scale based on norm, to obtain cut norm equal to ncol
+  /// 2 : scale to obtain largest coefficient equal to 1
+  bool scaleCut(double* cutElem, int* cutIndex, int cutNz,
+		 double& cutRhs, int scalingType);
+
+  /// Scale the cutting plane in order to generate integral coefficients
+  bool scaleCutIntegral(double* cutElem, int* cutIndex, int cutNz,
+			  double& cutRhs);
+
+  /// Compute the nearest rational number; used by scale_row_integral
+  bool nearestRational(double val, double maxdelta, long maxdnom,
+			long& numerator, long& denominator);
+
+  /// Compute the greatest common divisor
+  long computeGcd(long a, long b);
+
+  /// print a vector of integers
+  void printvecINT(const char *vecstr, const int *x, int n) const;
+  /// print a vector of doubles: dense form
+  void printvecDBL(const char *vecstr, const double *x, int n) const;
+  /// print a vector of doubles: sparse form
+  void printvecDBL(const char *vecstr, const double *elem, const int * index, 
+		   int nz) const;
+
+  /// Recompute the simplex tableau for want of a better accuracy.
+  /// Requires an empty CoinFactorization object to do the computations,
+  /// and two empty (already allocated) arrays which will contain 
+  /// the basis indices on exit. Returns 0 if successfull.
+  int factorize(CoinFactorization & factorization,
+		int* colBasisIndex, int* rowBasisIndex);
+
+
+  //@}
+
+  
+  // Private member data
+
+/**@name Private member data */
+
+  //@{
+
+  /// Object with CglGMIParam members. 
+  CglGMIParam param;
+
+  /// Number of rows ( = number of slack variables) in the current LP.
+  int nrow; 
+
+  /// Number of structural variables in the current LP.
+  int ncol;
+
+  /// Lower bounds for structural variables
+  const double *colLower;
+
+  /// Upper bounds for structural variables
+  const double *colUpper;
+  
+  /// Lower bounds for constraints
+  const double *rowLower;
+
+  /// Upper bounds for constraints
+  const double *rowUpper;
+
+  /// Righ hand side for constraints (upper bound for ranged constraints).
+  const double *rowRhs;
+
+  /// Characteristic vectors of structural integer variables or continuous
+  /// variables currently fixed to integer values. 
+  bool *isInteger;
+
+  /// Current basis status: columns
+  int *cstat;
+
+  /// Current basis status: rows
+  int *rstat;
+
+  /// Pointer on solver. Reset by each call to generateCuts().
+  OsiSolverInterface *solver;
+
+  /// Pointer on point to separate. Reset by each call to generateCuts().
+  const double *xlp;
+
+  /// Pointer on row activity. Reset by each call to generateCuts().
+  const double *rowActivity;
+
+  /// Pointer on matrix of coefficient ordered by rows. 
+  /// Reset by each call to generateCuts().
+  const CoinPackedMatrix *byRow;
+
+  /// Pointer on matrix of coefficient ordered by columns. 
+  /// Reset by each call to generateCuts().
+  const CoinPackedMatrix *byCol;
+
+  /// Fractionality of the cut and related quantities.
+  double f0;
+  double f0compl;
+  double ratiof0compl;
+
+#if defined(TRACK_REJECT) || defined (TRACK_REJECT_SIMPLE)
+  /// Should we track the reason of each cut rejection?
+  bool trackRejection;
+  /// Number of failures by type
+  int fracFail;
+  int dynFail;
+  int violFail;
+  int suppFail;
+  int smallCoeffFail;
+  int scaleFail;
+  /// Total number of generated cuts
+  int numGeneratedCuts;
+#endif
+
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglGMI class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CglGMIUnitTest(const OsiSolverInterface * siP,
+			 const std::string mpdDir );
+
+
+#endif

data/ext/ruby-cbc/install/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