CglRedSplitParam.hpp

Go to the documentation of this file.

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




class CglRedSplitParam : public CglParam {

public:

  virtual void setAway(const double value);
  inline double getAway() const {return away_;}

  virtual void setLUB(const double value);
  inline double getLUB() const {return LUB;}

  void setEPS_ELIM(const double value);
  double getEPS_ELIM() const {return EPS_ELIM;}
  
  virtual void setEPS_RELAX_ABS(const double eps_ra);
  inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;}

  virtual void setEPS_RELAX_REL(const double eps_rr);
  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);
  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);
  inline double getMAXDYN_LUB() const {return MAXDYN_LUB;}

  virtual void setEPS_COEFF_LUB(const double value);
  inline double getEPS_COEFF_LUB() const {return EPS_COEFF_LUB;}

  virtual void setMINVIOL(double value);
  inline double getMINVIOL() const {return MINVIOL;}

  virtual void setUSE_INTSLACKS(int value);
  inline int getUSE_INTSLACKS() const {return USE_INTSLACKS;}

  virtual void setUSE_CG2(int value);
  inline int getUSE_CG2() const {return USE_CG2;}

  virtual void setNormIsZero(const double value);
  inline double getNormIsZero() const {return normIsZero;}

  virtual void setMinReduc(const double value);
  inline double getMinReduc() const {return minReduc;}

  virtual void setMaxTab(const double value);
  inline double getMaxTab() const {return maxTab_;}

  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);

  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);

  CglRedSplitParam(const CglRedSplitParam &source);

  virtual CglRedSplitParam* clone() const;

  virtual CglRedSplitParam& operator=(const CglRedSplitParam &rhs);

  virtual ~CglRedSplitParam();

protected:


  double LUB;

   double EPS_ELIM;

  double EPS_RELAX_ABS;

  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;

  double EPS_COEFF_LUB;

  double MINVIOL;

  int USE_INTSLACKS;

  int USE_CG2;

  double normIsZero;

  double minReduc;

  double away_;
  
  double maxTab_;

};

#endif