CglLandP.hpp

Go to the documentation of this file.

// Copyright (C) 2005-2009, Pierre Bonami and others.  All Rights Reserved.
// Author:   Pierre Bonami
//           Tepper School of Business
//           Carnegie Mellon University, Pittsburgh, PA 15213
// Date:     07/21/05
//
// $Id$
//
// This code is licensed under the terms of the Eclipse Public License (EPL).
//---------------------------------------------------------------------------
#ifndef CglLandP_H
#define CglLandP_H
 
#include "CglLandPValidator.hpp"
#include "CglCutGenerator.hpp"
#include "CglParam.hpp"
 
#include <iostream>
class CoinWarmStartBasis;
namespace LAP
{
enum LapMessagesTypes
{
    BEGIN_ROUND,
    END_ROUND,
    DURING_SEP,
    CUT_REJECTED,
    CUT_FAILED,
    CUT_GAP,
    LAP_CUT_FAILED_DO_MIG,
    LAP_MESSAGES_DUMMY_END
};
class LapMessages : public CoinMessages
{
public:
    LapMessages( );
    virtual ~LapMessages() {}
};
class CglLandPSimplex;
}
 
class CglLandP : public CglCutGenerator
{
    friend void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);
 
    friend class LAP::CglLandPSimplex;
    friend class CftCglp;
 
public:
 
    enum SelectionRules
    {
        mostNegativeRc ,
        bestPivot ,
        initialReducedCosts
    };
 
    enum ExtraCutsMode
    {
        none,
        AtOptimalBasis ,
        WhenEnteringBasis ,
        AllViolatedMigs
    };
 
    enum SeparationSpaces
    {
        Fractional=0 ,
        Fractional_rc,
        Full 
    };
 
    enum Normalization
    {
        Unweighted = 0,
        WeightRHS,
        WeightLHS,
        WeightBoth
    };
 
    enum LHSnorm
    {
        L1 = 0,
        L2,
        SupportSize,
        Infinity,
        Average,
        Uniform
    };
    enum RhsWeightType
    {
        Fixed = 0 ,
        Dynamic 
    };
    class Parameters : public CglParam
    {
    public:
        Parameters();
        Parameters(const Parameters &other);
        Parameters & operator=(const Parameters &other);
 
        int pivotLimit;
        int pivotLimitInTree;
        int maxCutPerRound;
        int failedPivotLimit;
        int degeneratePivotLimit;
        int extraCutsLimit;
 
        double pivotTol;
        double away;
        double timeLimit;
        double singleCutTimeLimit;
        double rhsWeight;
 
 
        bool useTableauRow;
        bool modularize;
        bool strengthen;
        bool countMistakenRc;
        SeparationSpaces sepSpace;
        bool perturb;
        Normalization normalization;
        RhsWeightType rhsWeightType;
        LHSnorm lhs_norm;
        ExtraCutsMode generateExtraCuts;
        SelectionRules pivotSelection;
    };
 
 
    CglLandP(const CglLandP::Parameters &params = CglLandP::Parameters(),
             const LAP::Validator &validator = LAP::Validator());
    ~CglLandP();
    CglLandP(const CglLandP &source);
    CglLandP& operator=(const CglLandP &rhs);
    CglCutGenerator * clone() const;
 
 
    virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
                              const CglTreeInfo info = CglTreeInfo());
 
 
    virtual bool needsOptimalBasis() const
    {
        return true;
    }
 
    LAP::Validator & validator()
    {
        return validator_;
    }
    void setLogLevel(int level)
    {
        handler_->setLogLevel(level);
    }
 
    class NoBasisError : public CoinError
    {
    public:
        NoBasisError(): CoinError("No basis available","LandP","") {}
    };
 
    class SimplexInterfaceError : public CoinError
    {
    public:
        SimplexInterfaceError(): CoinError("Invalid conversion to simplex interface", "CglLandP","CglLandP") {}
    };
    Parameters & parameter()
    {
        return params_;
    }
private:
 
 
    void scanExtraCuts(OsiCuts& cs, const double * colsol) const;
 
    Parameters params_;
 
    struct CachedData
    {
        CachedData(int nBasics = 0 , int nNonBasics = 0);
        CachedData(const CachedData & source);
 
        CachedData& operator=(const CachedData &source);
        void getData(const OsiSolverInterface &si);
 
        void clean();
 
        ~CachedData();
        int * basics_;
        int *nonBasics_;
        int nBasics_;
        int nNonBasics_;
        CoinWarmStartBasis * basis_;
        double * colsol_;
        double * slacks_;
        bool * integers_;
        OsiSolverInterface * solver_;
    };
    int getSortedFractionals(CoinPackedVector &xFrac,
                             const CachedData & data,
                             const CglLandP::Parameters& params) const;
    void getSortedFractionalIndices(std::vector<int>& indices,
                                    const CachedData &data,
                                    const CglLandP::Parameters & params) const;
    CachedData cached_;
    CoinMessageHandler * handler_;
    CoinMessages messages_;
    LAP::Validator validator_;
    int numrows_;
    int numcols_;
    double * originalColLower_;
    double * originalColUpper_;
    bool canLift_;
    OsiCuts extraCuts_;
};
void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);
 
#endif