CglResidualCapacity.hpp

Go to the documentation of this file.

// LAST EDIT: 
//-----------------------------------------------------------------------------
// Implementation of Residual Capacity Inequalities
// Francisco Barahona (barahon@us.ibm.com)
//         
// date: May 18, 2006
//-----------------------------------------------------------------------------
// Copyright (C) 2004, International Business Machines Corporation and others. 
// All Rights Reserved.
// This code is published under the Eclipse Public License.

#ifndef CglResidualCapacity_H
#define CglResidualCapacity_H

#include <iostream>
#include <fstream>
//#include <vector>

#include "CoinError.hpp"

#include "CglCutGenerator.hpp"

//=============================================================================

#ifndef CGL_DEBUG
#define CGL_DEBUG 0
#endif

//=============================================================================




//=============================================================================

class CglResidualCapacity : public CglCutGenerator {
    
    friend void CglResidualCapacityUnitTest(const OsiSolverInterface * siP,
                                            const std::string mpdDir );
    
    
private:
    //---------------------------------------------------------------------------
    // Enumeration constants that describe the various types of rows
    enum RowType {
        ROW_L,
        ROW_G,
        ROW_BOTH,
        ROW_OTHER
    };
    
    
public:
    void setEpsilon(double value);
    double getEpsilon() const;
    void setTolerance(double value);
    double getTolerance() const;
    void setDoPreproc(int value);
    bool getDoPreproc() const;

    virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
                              const CglTreeInfo info = CglTreeInfo());
    
    //---------------------------------------------------------------------------
    CglResidualCapacity ();
    
    CglResidualCapacity ( const double tolerance );
    
    CglResidualCapacity (
                         const CglResidualCapacity &);
    
    virtual CglCutGenerator * clone() const;
    
    CglResidualCapacity &
    operator=(
              const CglResidualCapacity& rhs);
    
    virtual
    ~CglResidualCapacity ();
    virtual void refreshPrep();
    
    
    
private:
    //--------------------------------------------------------------------------
    // Private member methods
    
    // Construct
    void gutsOfConstruct ( const double tolerance);
    
    // Delete
    void gutsOfDelete();
    
    // Copy
    void gutsOfCopy (const CglResidualCapacity& rhs);
    
    // Do preprocessing.
    // It determines the type of each row. 
    // It may change sense and RHS for ranged rows
    void resCapPreprocess(const OsiSolverInterface& si);
    
    // Determine the type of a given row.
    RowType determineRowType(const OsiSolverInterface& si,
                             const int rowLen, const int* ind, 
                             const double* coef, const char sense, 
                             const double rhs,
                             const double* colLowerBound,
                             const double* colUpperBound) const;
    // helps the function above
    bool treatAsLessThan(const OsiSolverInterface& si,
                         const int rowLen, const int* ind, 
                         const double* coef,
                         const double rhs,
                         const double* colLowerBound,
                         const double* colUpperBound) const;
    
    // Generate Residual Capacity cuts
    void generateResCapCuts( const OsiSolverInterface& si,
                             const double* xlp,
                             const double* colUpperBound,
                             const double* colLowerBound,
                             const CoinPackedMatrix& matrixByRow,
                             const double* LHS,
                             const double* coefByRow,
                             const int* colInds,
                             const int* rowStarts,
                             const int* rowLengths,
                             OsiCuts& cs ) const;
    

    // Residual Capacity separation 
    bool resCapSeparation(const OsiSolverInterface& si,
                          const int rowLen, const int* ind, 
                          const double* coef,
                          const double rhs,
                          const double *xlp,  
                          const double* colUpperBound,
                          const double* colLowerBound,
                          OsiRowCut& resCapCut) const;
    
      

private:
    //---------------------------------------------------------------------------
    // Private member data
    double EPSILON_;
    double TOLERANCE_;
    int doPreproc_;
    // The number of rows of the problem.
    int numRows_;
    // The number columns of the problem.
    int numCols_;
    // Indicates whether preprocessing has been done.
    bool doneInitPre_;
    // Array with the row types of the rows in the model.
    RowType* rowTypes_;
    // The indices of the rows of the initial matrix
    int* indRows_;
    // Sense of rows (modified if ranges)
    char * sense_;
    // RHS of rows (modified if ranges)
    double * RHS_;
    // The number of rows of type ROW_L
    int numRowL_;
    // The indices of the rows of type ROW_L
    int* indRowL_;
    // The number of rows of type ROW_G
    int numRowG_;
    // The indices of the rows of type ROW_G
    int* indRowG_;
};

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

  
#endif