/home/coin/SVN-release/CoinAll-1.1.0/Cgl/src/CglRedSplit/CglRedSplit.hpp

Go to the documentation of this file.

// Last edit: 4/20/07
//
// Name:     CglRedSplit.hpp
// Author:   Francois Margot
//           Tepper School of Business
//           Carnegie Mellon University, Pittsburgh, PA 15213
//           email: fmargot@andrew.cmu.edu
// Date:     2/6/05
//-----------------------------------------------------------------------------
// Copyright (C) 2005, Francois Margot and others.  All Rights Reserved.

#ifndef CglRedSplit_H
#define CglRedSplit_H

#include "CglCutGenerator.hpp"
#include "CglRedSplitParam.hpp"

class CglRedSplit : public CglCutGenerator {

  friend void CglRedSplitUnitTest(const OsiSolverInterface * siP,
                                  const std::string mpdDir);
public:
  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
                            const CglTreeInfo info = CglTreeInfo());

  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
                            const CglTreeInfo info = CglTreeInfo()) const;

  virtual bool needsOptimalBasis() const;
  
  

  // Set the parameters to the values of the given CglRedSplitParam object.
  void setParam(const CglRedSplitParam &source); 
  // Return the CglRedSplitParam object of the generator. 
  inline CglRedSplitParam getParam() const {return param;}

  // Compute entries of low_is_lub and up_is_lub.
  void compute_is_lub();

  // Compute entries of is_integer.
  void compute_is_integer();

  void set_given_optsol(const double *given_sol, const int card_sol);

  void print() const;

  void printOptTab(OsiSolverInterface *solver) const;
  

  //************************************************************
  // TO BE REMOVED
  void setLimit(int limit);
  int getLimit() const;

  void setAway(double value);
  double getAway() const;
  void setLUB(double value);
  double getLUB() const;

  void setEPS(double value);
  double getEPS() const;

  void setEPS_COEFF(double value);
  double getEPS_COEFF() const;

  void setEPS_COEFF_LUB(double value);
  double getEPS_COEFF_LUB() const;

  void setEPS_RELAX(double value);
  double getEPS_RELAX() const;

  void setNormIsZero(double value);
  double getNormIsZero() const;

  void setMinReduc(double value);
  double getMinReduc() const;

  void setMaxTab(double value);
  double getMaxTab() const;
  // END TO BE REMOVED
  //************************************************************



  CglRedSplit();

  CglRedSplit(const CglRedSplitParam &RS_param);
 
  CglRedSplit (const CglRedSplit &);

  virtual CglCutGenerator * clone() const;

  CglRedSplit &
    operator=(
    const CglRedSplit& rhs);
  
  virtual
    ~CglRedSplit ();
  virtual std::string generateCpp( FILE * fp);
    
private:
  
  // Private member methods


  // Method generating the cuts after all CglRedSplit members are properly set.
  void generateCuts(OsiCuts & cs);

  inline double rs_above_integer(double value); 

  void update_pi_mat(int r1, int r2, int step);

  void update_redTab(int r1, int r2, int step);

  void find_step(int r1, int r2, int *step, 
                 double *reduc, double *norm);

  int test_pair(int r1, int r2, double *norm);

  void reduce_contNonBasicTab();

  void generate_row(int index_row, double *row);

  int generate_cgcut(double *row, double *rhs);

  int generate_cgcut_2(int basic_ind, double *row, double *rhs);

  void eliminate_slacks(double *row, 
                        const double *elements, 
                        const int *start,
                        const int *indices,
                        const int *rowLength,
                        const double *rhs, double *rowrhs);

  void flip(double *row);

  void unflip(double *row, double *rowrhs, double *slack_val);

  double row_scale_factor(double *row);

  int generate_packed_row(const double *xlp, double *row,
                          int *rowind, double *rowelem, 
                          int *card_row, double & rhs);

  void check_optsol(const int calling_place,
                    const double *xlp, const double *slack_val,
                    const int do_flip);

  void check_optsol(const int calling_place,
                    const double *xlp, const double *slack_val,
                    const double *ck_row, const double ck_rhs, 
                    const int cut_number, const int do_flip);

  // Check that two vectors are different.
  bool rs_are_different_vectors(const int *vect1, 
                                const int *vect2,
                                const int dim);

  // Check that two vectors are different.
  bool rs_are_different_vectors(const double *vect1, 
                                const double *vect2,
                                const int dim);

  // Check that two matrices are different.
  bool rs_are_different_matrices(const CoinPackedMatrix *mat1, 
                                 const CoinPackedMatrix *mat2,
                                 const int nmaj,
                                 const int nmin);

  
  // Private member data


  CglRedSplitParam param;

  int nrow; 

  int ncol;

  const double *colLower;

  const double *colUpper;
  
  const double *rowLower;

  const double *rowUpper;

  const double *rowRhs;

  int card_intBasicVar_frac;

  int card_intNonBasicVar; 

  int card_contNonBasicVar;

  int card_nonBasicAtUpper; 

  int card_nonBasicAtLower;

  int *cv_intBasicVar_frac;  

  int *intBasicVar_frac;

  int *intNonBasicVar; 

  // slacks are considered continuous (no harm if this is not the case).
  int *contNonBasicVar;

  int *nonBasicAtUpper;

  int *nonBasicAtLower;

  int mTab;

  int nTab;

  int **pi_mat;

  double **contNonBasicTab;

  // Dimensions: mTab by card_intNonBasicVar.
  double **intNonBasicTab;

  double *rhsTab ;

  const double *given_optsol;

  int card_given_optsol;

  int *is_integer;

  int *low_is_lub;

  int *up_is_lub;

  OsiSolverInterface *solver;

  const double *xlp;

  const double *rowActivity;

  const char *colType;

  const CoinPackedMatrix *byRow;

};

//#############################################################################
void CglRedSplitUnitTest(const OsiSolverInterface * siP,
                         const std::string mpdDir );


#endif

---