CglRedSplit2Param.hpp

Go to the documentation of this file.

// Name:     CglRedSplit2Param.hpp
// Author:   Giacomo Nannicini
//           Singapore University of Technology and Design
//           Singapore
//           email: nannicini@sutd.edu.sg
// Date:     03/09/09
//-----------------------------------------------------------------------------
// Copyright (C) 2010, Giacomo Nannicini and others.  All Rights Reserved.

#ifndef CglRedSplit2Param_H
#define CglRedSplit2Param_H

#include "CglParam.hpp"
#include <vector>



class CglRedSplit2Param : public CglParam {

public:
  enum RowSelectionStrategy{
    /* Pick rows that introduce the fewest nonzeroes on integer nonbasics */
    RS1, 
    /* Pick rows that introduce the fewest nonzeroes on the set of working
       continuous nonbasics */
    RS2,
    /* Pick rows that introduce the fewest nonzeroes on both integer and
       working continuous nonbasics */
    RS3,
    /* Same as RS0 but with greedy algorithm */
    RS4,
    /* Same as RS1 but with greedy algorithm */
    RS5,
    /* Same as RS2 but with greedy algorithm */
    RS6,
    /* Pick rows with smallest angle in the space of integer and working
       continuous nonbasics */
    RS7,
    /* Pick rows with smallest angle in the space of working
       continuous nonbasics */
    RS8,
    /* Use all strategies */
    RS_ALL,
    /* Use best ones - that is, RS8 and RS7 */
    RS_BEST
  };

  enum ColumnSelectionStrategy{
    /* C-3P */
    CS1, CS2, CS3,
    /* C-5P */
    CS4, CS5, CS6, CS7, CS8,
    /* I-2P-2/3 */
    CS9, CS10,
    /* I-2P-4/5 */
    CS11, CS12,
    /* I-2P-1/2 */
    CS13, CS14,
    /* I-3P */
    CS15, CS16, CS17,
    /* I-4P */
    CS18, CS19, CS20, CS21,
    /* Use all strategies up to this point */
    CS_ALL,
    /* Use best strategies (same effect as CS_ALL, because it turns out that
       using all strategies is the best thing to do) */
    CS_BEST,
    /* Optimize over all continuous nonbasic columns; this does not give
       good results, but we use it for testing Lift & Project + RedSplit */
    CS_ALLCONT,
    /* Lift & Project specific strategy: only select variables which
       are nonbasic in the tableau but are basic in the point to cut
       off.  This strategy cannot be used outside L&P. It is not very
       effective even with L&P, but is left here for testing.*/
    CS_LAP_NONBASICS
  };

  enum ColumnScalingStrategy{
    /* No scaling */
    SC_NONE,
    /* Multiply by |xbar[i]| where xbar[i] is the value of the 
       corresponding component of the point that we want to cut off */
    SC_LINEAR,
    /* Multiply by min(factor,|xbar[i]|) */
    SC_LINEAR_BOUNDED,
    /* Multiply by min(factor,log(|xbar[i]|)) */
    SC_LOG_BOUNDED,
    /* Multiply all new nonbasics by factor */
    SC_UNIFORM,
    /* Multiply only nonzero coefficients by factor */
    SC_UNIFORM_NZ
  };

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

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

  virtual void setEPS_RELAX_REL(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: 1e6.
  virtual void setMAXDYN(double value);
  inline double getMAXDYN() const {return MAXDYN;}

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

  inline void setMAX_SUPP_ABS(int value) {setMAX_SUPPORT(value);}
  inline int getMAX_SUPP_ABS() const {return MAX_SUPPORT;}

  inline void setMAX_SUPP_REL(double value); 
  inline double getMAX_SUPP_REL() const {return MAX_SUPP_REL;}

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

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

  virtual void setMinNormReduction(double value);
  inline double getMinNormReduction() const {return minNormReduction_;}

  virtual void setMaxSumMultipliers(int value);
  inline int getMaxSumMultipliers() const {return maxSumMultipliers_;}

  virtual void setNormalization(double value);
  inline double getNormalization() const {return normalization_;}

  virtual void addNumRowsReduction(int value);
  inline std::vector<int> getNumRowsReduction() const {return numRowsReduction_;}
  inline void resetNumRowsReduction() {numRowsReduction_.clear();}

  virtual void addColumnSelectionStrategy(ColumnSelectionStrategy value);
  inline std::vector<ColumnSelectionStrategy> getColumnSelectionStrategy() const {return columnSelectionStrategy_;}
  inline void resetColumnSelectionStrategy(){columnSelectionStrategy_.clear();}

  virtual void addRowSelectionStrategy(RowSelectionStrategy value);
  inline std::vector<RowSelectionStrategy> getRowSelectionStrategy() const {return rowSelectionStrategy_;};
  inline void resetRowSelectionStrategy() {rowSelectionStrategy_.clear();}

  virtual void addNumRowsReductionLAP(int value);
  inline std::vector<int> getNumRowsReductionLAP() const {return numRowsReductionLAP_;}
  inline void resetNumRowsReductionLAP() {numRowsReductionLAP_.clear();}

  virtual void addColumnSelectionStrategyLAP(ColumnSelectionStrategy value);
  inline std::vector<ColumnSelectionStrategy> getColumnSelectionStrategyLAP() const {return columnSelectionStrategyLAP_;}
  inline void resetColumnSelectionStrategyLAP(){columnSelectionStrategyLAP_.clear();}

  virtual void addRowSelectionStrategyLAP(RowSelectionStrategy value);
  inline std::vector<RowSelectionStrategy> getRowSelectionStrategyLAP() const {return rowSelectionStrategyLAP_;};
  inline void resetRowSelectionStrategyLAP() {rowSelectionStrategyLAP_.clear();}

  virtual void setColumnScalingStrategyLAP(ColumnScalingStrategy value);
  inline ColumnScalingStrategy getColumnScalingStrategyLAP() const {return columnScalingStrategyLAP_; };

  virtual void setColumnScalingBoundLAP(double value);
  inline double getColumnScalingBoundLAP() const {return columnScalingBoundLAP_;};

  virtual void setTimeLimit(double value);
  inline double getTimeLimit() const {return timeLimit_;}

  virtual void setMaxNumCuts(int value);
  inline int getMaxNumCuts() const {return maxNumCuts_;}

  virtual void setMaxNumComputedCuts(int value);
  inline int getMaxNumComputedCuts() const {return maxNumComputedCuts_;}

  virtual void setMaxNonzeroesTab(int value);
  inline int getMaxNonzeroesTab() const {return maxNonzeroesTab_;}

  virtual void setSkipGomory(int value);
  inline int getSkipGomory() const {return skipGomory_;}


  CglRedSplit2Param(bool use_default_strategies = true,
                    double eps = 1e-12,
                    double eps_coeff = 1e-11,
                    double eps_elim = 0.0,
                    double eps_relax_abs = 1e-11,
                    double eps_relax_rel = 1e-13,
                    double max_dyn = 1e6,
                    double min_viol = 1e-3,
                    int max_supp_abs = 1000,
                    double max_supp_rel = 0.1,
                    int use_int_slacks = 0,
                    double norm_zero = 1e-5,
                    double minNormReduction = 0.1,
                    int maxSumMultipliers = 10,
                    double normalization = 0.0001,
                    double away = 0.005,
                    double timeLimit = 60,
                    int maxNumCuts = 10000,
                    int maxNumComputedCuts = 10000,
                    int maxNonzeroesTab = 1000,
                    double columnScalingBoundLAP = 5.0,
                    int skipGomory = 1);

  CglRedSplit2Param(const CglParam &source,
                    bool use_default_strategies = true,
                    double eps_elim = 0.0,
                    double eps_relax_abs = 1e-11,
                    double eps_relax_rel = 1e-13,
                    double max_dyn = 1e6,
                    double min_viol = 1e-3,
                    double max_supp_rel = 0.1,
                    int use_int_slacks = 0,
                    double norm_zero = 1e-5,
                    double minNormReduction = 0.1,
                    int maxSumMultipliers = 10,
                    double normalization = 0.0001,
                    double away = 0.005,
                    double timeLimit = 60,
                    int maxNumCuts = 10000,
                    int maxNumComputedCuts = 10000,
                    int maxNonzeroesTab = 1000,
                    double columnScalingBoundLAP = 5.0,
                    int skipGomory = 1);

  CglRedSplit2Param(const CglRedSplit2Param &source);

  virtual CglRedSplit2Param* clone() const;

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

  virtual ~CglRedSplit2Param();

protected:


  double EPS_ELIM;

  double EPS_RELAX_ABS;

  double EPS_RELAX_REL;

  // Maximum ratio between largest and smallest non zero 
  // coefficients in a cut. Default: 1e6.
  double MAXDYN;

  double MINVIOL;

  double MAX_SUPP_REL;

  int USE_INTSLACKS;

  double normIsZero_;

  double minNormReduction_;

  int maxSumMultipliers_;

  double normalization_;

  double away_;
  
  std::vector<int> numRowsReduction_;

  std::vector<ColumnSelectionStrategy> columnSelectionStrategy_;

  std::vector<RowSelectionStrategy> rowSelectionStrategy_;

  std::vector<int> numRowsReductionLAP_;

  std::vector<ColumnSelectionStrategy> columnSelectionStrategyLAP_;

  std::vector<RowSelectionStrategy> rowSelectionStrategyLAP_;

  ColumnScalingStrategy columnScalingStrategyLAP_;

  double columnScalingBoundLAP_;

  double timeLimit_;

  int maxNumCuts_;

  int maxNumComputedCuts_;

  int maxNonzeroesTab_;

  int skipGomory_;

};

#endif