CglGomory.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CglGomory_H
#define CglGomory_H

#include <string>

#include "CglCutGenerator.hpp"

class CoinWarmStartBasis;
class CglGomory : public CglCutGenerator {
   friend void CglGomoryUnitTest(const OsiSolverInterface * siP,
                                  const std::string mpdDir );
 
public:
    
  
  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
                             const CglTreeInfo info = CglTreeInfo());
  int generateCuts( const OsiRowCutDebugger * debugger, 
                    OsiCuts & cs,
                    const CoinPackedMatrix & columnCopy,
                    const CoinPackedMatrix & rowCopy,
                    const double * colsol,
                    const double * colLower, const double * colUpper,
                    const double * rowLower, const double * rowUpper,
                    const char * intVar ,
                    const CoinWarmStartBasis* warm,
                    const CglTreeInfo info = CglTreeInfo());
  int generateCuts( const OsiRowCutDebugger * debugger, 
                    OsiCuts & cs,
                    const CoinPackedMatrix & columnCopy,
                    const double * colsol,
                    const double * colLower, const double * colUpper,
                    const double * rowLower, const double * rowUpper,
                    const char * intVar ,
                    const CoinWarmStartBasis* warm,
                    const CglTreeInfo info = CglTreeInfo());

  virtual bool needsOptimalBasis() const { return true; }

  void passInOriginalSolver(OsiSolverInterface * solver);
  inline OsiSolverInterface * originalSolver() const
  { return originalSolver_;}
  inline void setGomoryType(int type)
  { gomoryType_=type;}
  inline int gomoryType() const
  { return gomoryType_;}

  void setLimit(int limit);
  int getLimit() const;
  void setLimitAtRoot(int limit);
  int getLimitAtRoot() const;
  virtual int maximumLengthOfCutInTree() const;

  void setAway(double value);
  double getAway() const;
  void setAwayAtRoot(double value);
  double getAwayAtRoot() const;

  void setConditionNumberMultiplier(double value);
  double getConditionNumberMultiplier() const;
  void setLargestFactorMultiplier(double value);
  double getLargestFactorMultiplier() const;

   inline void useAlternativeFactorization(bool yes=true)
   { alternateFactorization_= (yes) ? 1 : 0;} 
   inline bool alternativeFactorization() const
   { return (alternateFactorization_!=0);} 

  CglGomory ();
 
  CglGomory (
    const CglGomory &);

  virtual CglCutGenerator * clone() const;

  CglGomory &
    operator=(
    const CglGomory& rhs);
  
  virtual
    ~CglGomory ();
  virtual std::string generateCpp( FILE * fp);
  virtual void refreshSolver(OsiSolverInterface * solver);
      
private:
  
 // Private member methods

  // Private member data

  double away_;
  double awayAtRoot_;
  double conditionNumberMultiplier_;
  double largestFactorMultiplier_;
  OsiSolverInterface * originalSolver_;
  int limit_;
  int limitAtRoot_;
  int dynamicLimitInTree_;
  int numberTimesStalled_;
  int alternateFactorization_;
  int gomoryType_;
};

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