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
//
// $Id$
//-----------------------------------------------------------------------------
// Copyright (C) 2005, Francois Margot and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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 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 CoinBigIndex *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