diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/CglRedSplitParam.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/CglRedSplitParam.hpp | 272 |
1 files changed, 272 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/CglRedSplitParam.hpp b/thirdparty/linux/include/coin1/CglRedSplitParam.hpp new file mode 100644 index 0000000..2601fb2 --- /dev/null +++ b/thirdparty/linux/include/coin1/CglRedSplitParam.hpp @@ -0,0 +1,272 @@ +// Name: CglRedSplitParam.hpp +// Author: Francois Margot +// Tepper School of Business +// Carnegie Mellon University, Pittsburgh, PA 15213 +// email: fmargot@andrew.cmu.edu +// Date: 11/24/06 +// +// $Id: CglRedSplitParam.hpp 1122 2013-04-06 20:39:53Z stefan $ +//----------------------------------------------------------------------------- +// Copyright (C) 2006, Francois Margot and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CglRedSplitParam_H +#define CglRedSplitParam_H + +#include "CglParam.hpp" + + + /**@name CglRedSplit Parameters */ + //@{ + + /** Class collecting parameters the Reduced-and-split 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. + + - LUB: Value considered large for the absolute value of a lower or upper + bound on a variable. See method setLUB(). + - MAXDYN: Maximum ratio between largest and smallest non zero + coefficients in a cut. See method setMAXDYN(). + - MAXDYN_LUB: Maximum ratio between largest and smallest non zero + coefficients in a cut involving structural variables with + lower or upper bound in absolute value larger than LUB. + Should logically be larger or equal to MAXDYN. + See method setMAXDYN_LUB(). + - EPS_ELIM: Precision for deciding if a coefficient is zero when + eliminating slack variables. See method setEPS_ELIM(). + - EPS_COEFF_LUB: Precision for deciding if a coefficient of a + generated cut is zero when the corresponding + variable has a lower or upper bound larger than + LUB in absolute value. See method setEPS_COEFF_LUB(). + - 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). + See method setUSE_INTSLACKS(). + - USE_CG2: Use alternative formula to generate a mixed integer Gomory + cut (see methods CglRedSPlit::generate_cgcut() + and CglRedSPlit::generate_cgcut_2()). See method setUSE_CG2(). + - normIsZero: Norm of a vector is considered zero if smaller than + this value. See method setNormIsZero(). + - minReduc: Reduction is performed only if the norm of the vector is + reduced by this fraction. See method setMinReduc(). + - away: Look only at basic integer variables whose current value + is at least this value from being integer. See method setAway(). + - maxTab: Controls the number of rows selected for the generation. See + method setMaxTab(). + */ + //@} + +class CglRedSplitParam : public CglParam { + +public: + + /**@name Set/get methods */ + //@{ + /** 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.05 */ + virtual void setAway(const double value); + /// Get value of away + inline double getAway() const {return away_;} + + /** Set the value of LUB, value considered large for the absolute value of + a lower or upper bound on a variable; + Default: 1000 */ + virtual void setLUB(const double value); + /** Get the value of LUB */ + inline double getLUB() const {return LUB;} + + /** Set the value of EPS_ELIM, epsilon for values of coefficients when + eliminating slack variables; + Default: 1e-12 */ + void setEPS_ELIM(const double value); + /** Get the value of EPS_ELIM */ + double getEPS_ELIM() const {return EPS_ELIM;} + + /** Set EPS_RELAX_ABS */ + virtual void setEPS_RELAX_ABS(const double eps_ra); + /** Get value of EPS_RELAX_ABS */ + inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;} + + /** Set EPS_RELAX_REL */ + virtual void setEPS_RELAX_REL(const double eps_rr); + /** Get value of EPS_RELAX_REL */ + inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;} + + // Set the maximum ratio between largest and smallest non zero + // coefficients in a cut. Default: 1e8. + virtual void setMAXDYN(double value); + /** Get the value of MAXDYN */ + inline double getMAXDYN() const {return MAXDYN_LUB;} + + // Set the maximum ratio between largest and smallest non zero + // coefficient in a cut involving structural variables with + // lower or upper bound in absolute value larger than LUB. + // Should logically be larger or equal to MAXDYN. Default: 1e13. + virtual void setMAXDYN_LUB(double value); + /** Get the value of MAXDYN_LUB */ + inline double getMAXDYN_LUB() const {return MAXDYN_LUB;} + + /** Set the value of EPS_COEFF_LUB, epsilon for values of coefficients for + variables with absolute value of lower or upper bound larger than LUB; + Default: 1e-13 */ + virtual void setEPS_COEFF_LUB(const double value); + /** Get the value of EPS_COEFF_LUB */ + inline double getEPS_COEFF_LUB() const {return EPS_COEFF_LUB;} + + /** 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;} + + /** Set the value of USE_INTSLACKS. Default: 0 */ + virtual void setUSE_INTSLACKS(int value); + /** Get the value of USE_INTSLACKS */ + inline int getUSE_INTSLACKS() const {return USE_INTSLACKS;} + + /** Set the value of USE_CG2. Default: 0 */ + virtual void setUSE_CG2(int value); + /** Get the value of USE_CG2 */ + inline int getUSE_CG2() const {return USE_CG2;} + + /** Set the value of normIsZero, the threshold for considering a norm to be + 0; Default: 1e-5 */ + virtual void setNormIsZero(const double value); + /** Get the value of normIsZero */ + inline double getNormIsZero() const {return normIsZero;} + + /** Set the value of minReduc, threshold for relative norm improvement for + performing a reduction; Default: 0.05 */ + virtual void setMinReduc(const double value); + /// Get the value of minReduc + inline double getMinReduc() const {return minReduc;} + + /** Set the maximum allowed value for (mTab * mTab * CoinMax(mTab, nTab)) where + mTab is the number of rows used in the combinations and nTab is the + number of continuous non basic variables. The work of the generator is + proportional to (mTab * mTab * CoinMax(mTab, nTab)). Reducing the value of + maxTab makes the generator faster, but weaker. Default: 1e7. */ + virtual void setMaxTab(const double value); + /// Get the value of maxTab + inline double getMaxTab() const {return maxTab_;} + //@} + + /**@name Constructors and destructors */ + //@{ + /// Default constructor + CglRedSplitParam(const double lub = 1000.0, + const double eps_elim = 1e-12, + const double eps_relax_abs = 1e-8, + const double eps_relax_rel = 0.0, + const double max_dyn = 1e8, + const double max_dyn_lub = 1e13, + const double eps_coeff_lub = 1e-13, + const double min_viol = 1e-7, + const int use_int_slacks = 0, + const int use_cg2 = 0, + const double norm_zero = 1e-5, + const double min_reduc = 0.05, + const double away = 0.05, + const double max_tab = 1e7); + + /// Constructor from CglParam + CglRedSplitParam(const CglParam &source, + const double lub = 1000.0, + const double eps_elim = 1e-12, + const double eps_relax_abs = 1e-8, + const double eps_relax_rel = 0.0, + const double max_dyn = 1e8, + const double max_dyn_lub = 1e13, + const double eps_coeff_lub = 1e-13, + const double min_viol = 1e-7, + const int use_int_slacks = 0, + const int use_cg2 = 0, + const double norm_zero = 1e-5, + const double min_reduc = 0.05, + const double away = 0.05, + const double max_tab = 1e7); + + /// Copy constructor + CglRedSplitParam(const CglRedSplitParam &source); + + /// Clone + virtual CglRedSplitParam* clone() const; + + /// Assignment operator + virtual CglRedSplitParam& operator=(const CglRedSplitParam &rhs); + + /// Destructor + virtual ~CglRedSplitParam(); + //@} + +protected: + + /**@name Parameters */ + //@{ + + /** Value considered large for the absolute value of lower or upper + bound on a variable. Default: 1000. */ + double LUB; + + /** Epsilon for value of coefficients when eliminating slack variables. + Default: 1e-12. */ + double EPS_ELIM; + + /** Value added to the right hand side of each generated cut to relax it. + Default: 1e-8 */ + 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: 0 */ + double EPS_RELAX_REL; + + // Maximum ratio between largest and smallest non zero + // coefficients in a cut. Default: 1e8. + double MAXDYN; + + // Maximum ratio between largest and smallest non zero + // coefficients in a cut involving structural variables with + // lower or upper bound in absolute value larger than LUB. + // Should logically be larger or equal to MAXDYN. Default: 1e13. + double MAXDYN_LUB; + + /// Epsilon for value of coefficients for variables with absolute value of + /// lower or upper bound larger than LUB. Default: 1e-13. + double EPS_COEFF_LUB; + + /// Minimum violation for the current basic solution in a generated cut. + /// Default: 1e-7. + double MINVIOL; + + /// Use integer slacks to generate cuts if USE_INTSLACKS = 1. Default: 0. + int USE_INTSLACKS; + + /// Use second way to generate a mixed integer Gomory cut + /// (see methods generate_cgcut()) and generate_cgcut_2()). Default: 0. + int USE_CG2; + + /// Norm of a vector is considered zero if smaller than normIsZero; + /// Default: 1e-5. + double normIsZero; + + /// Minimum reduction in percent that must be achieved by a potential + /// reduction step in order to be performed; Between 0 and 1, default: 0.05. + double minReduc; + + /// Use row only if pivot variable should be integer but is more + /// than away_ from being integer. + double away_; + + /// Maximum value for (mTab * mTab * CoinMax(mTab, nTab)). See method + /// setMaxTab(). + double maxTab_; + + //@} +}; + +#endif |