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: CglLandP.hpp 1122 2013-04-06 20:39:53Z stefan $
//
// 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