BlisModel.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Bcps Linear Solver (BLIS).                       *
 *                                                                           *
 * BLIS is distributed under the Eclipse Public License as part of the       *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           * 
 *                                                                           *
 * Copyright (C) 2001-2013, Lehigh University, Yan Xu, and Ted Ralphs.       *
 * All Rights Reserved.                                                      *
 *===========================================================================*/

//#############################################################################

#ifndef BlisModel_h_
#define BlisModel_h_

//#############################################################################

#include "CoinMpsIO.hpp"
#include "CoinPackedMatrix.hpp"
#include "CoinMessageHandler.hpp"
#include "OsiSolverInterface.hpp"
#include "OsiCuts.hpp"
#include "CglCutGenerator.hpp"

#include "AlpsKnowledgeBroker.h"
#include "AlpsParams.h"

#include "BcpsModel.h"

#include "BcpsBranchStrategy.h"
#include "BcpsObject.h"
#include "BcpsObjectPool.h"

#include "Blis.h"
#include "BlisConGenerator.h"
#include "BlisHeuristic.h"
#include "BlisParams.h"

#include "AlpsTreeNode.h"

//#############################################################################

class BlisConstraint;

//#############################################################################

class BlisModel : public BcpsModel {

 private:

    //------------------------------------------------------
    // LP SOLVER.
    //------------------------------------------------------
    
    OsiSolverInterface *lpSolver_;
    
    //------------------------------------------------------
    // PROBLEM DATA. Populate when readInstance() or decodeToSelf().
    //------------------------------------------------------
    
    CoinPackedMatrix *colMatrix_;    

    double *origVarLB_;
    double *origVarUB_;
    double *origConLB_;
    double *origConUB_;

    int numCols_;
    int numRows_;
    int numElems_;

    double objSense_;
    double *objCoef_;

    int numIntVars_;
    int *intVars_;
    char *colType_;

    //------------------------------------------------------
    // SOLUTION.
    //------------------------------------------------------
    
    int numSolutions_;
    int numHeurSolutions_;

    //double *savedLpSolution_;
    
    double incObjValue_;

    double *incumbent_;

    double cutoff_;

    double cutoffInc_;
    
    //------------------------------------------------------
    // SEARCHING.
    //------------------------------------------------------

    double *startVarLB_;
    double *startVarUB_;
    double *startConLB_;
    double *startConUB_;

    BcpsBranchStrategy * branchStrategy_;

    // Hotstart strategy 0 = off, 
    // 1 = branch if incorrect,
    // 2 = branch even if correct, ....
    int hotstartStrategy_;
    
    int numObjects_;

    BcpsObject **objects_;

    int * priority_;

    AlpsTreeNode *activeNode_;

    int numStrong_;

    // Not used. 
    double nodeWeight_;

    //------------------------------------------------------
    // HEURISTICS.
    //------------------------------------------------------

    int numHeuristics_;

    BlisHeuristic ** heuristics_;

    //------------------------------------------------------
    // CONSTRAINTS.
    //------------------------------------------------------

    int useCons_; 
    
    int numCutGenerators_;
    
    int maxNumCons_;

    BlisConGenerator ** generators_;

    BcpsConstraintPool *constraintPool_;
    
    BlisConstraint **oldConstraints_;
    
    int oldConstraintsSize_;
    
    int numOldConstraints_;

    double * conRandoms_;
    
    int denseConCutoff_;
    
    //------------------------------------------------------
    // PARAMETERS, STATISTICS, and MESSAGE
    //------------------------------------------------------

    BlisParams *BlisPar_;
    
    CoinMessageHandler * handler_;

    int numNodes_;
    
    int numIterations_;

    int aveIterations_;
    
    //------------------------------------------------------
    // TEMPORARY STORAGE
    //------------------------------------------------------
    
    int *tempVarLBPos_;
    int *tempVarUBPos_;
    int *tempConLBPos_;
    int *tempConUBPos_;

 public:

    bool isRoot_;

    double startTime_;

    double timeLimit_; 

    double integerTol_;

    double optimalRelGap_;

    double optimalAbsGap_;

    bool useHeuristics_;
    
    OsiCuts newCutPool_;
    
 public:

    std::vector<AlpsTreeNode *> leafToRootPath;    

 public:

    BlisModel() { init(); }

    virtual ~BlisModel();
    
    void gutsOfDestructor();
    
    //------------------------------------------------------
    // SETUP, LP SOLVER
    //------------------------------------------------------

    void init();

    virtual void readInstance(const char* dataFile);

    virtual void readParameters(const int argnum, const char * const *arglist);

    virtual void writeParameters(std::ostream& outstream) const;

    virtual AlpsTreeNode * createRoot();
    
    virtual bool setupSelf();

    virtual void setSolver(OsiSolverInterface *si) { lpSolver_ = si; }
    
    virtual OsiSolverInterface *solver() { return lpSolver_; }

    bool resolve();

    void setActiveNode(AlpsTreeNode *node) { activeNode_ = node; }

    void setSolEstimate(double est) { activeNode_->setSolEstimate(est); }
    
    int getNumStrong() { return numStrong_; }
    
    void addNumStrong(int num=1) { numStrong_ += num; }
    
    //------------------------------------------------------
    // PROBLEM DATA
    //------------------------------------------------------

    double* getObjCoef() const { return objCoef_; }

    const double * getColLower() { return lpSolver_->getColLower(); }

    const double * getColUpper() { return lpSolver_->getColUpper(); }

    int getNumCols() { return lpSolver_->getNumCols(); }

    int getNumRows() { return lpSolver_->getNumRows(); }

    double *origVarLB() { return origVarLB_; }
    double *origVarUB() { return origVarUB_; }

    double *origConLB() { return origConLB_; }
    double *origConUB() { return origConUB_; }

    double *startVarLB() { return startVarLB_; }
    double *startVarUB() { return startVarUB_; }

    double *startConLB() { return startConLB_; }
    double *startConUB() { return startConUB_; }

    int *tempVarLBPos() { return tempVarLBPos_; }
    int *tempVarUBPos() { return tempVarUBPos_; }
    int *tempConLBPos() { return tempConLBPos_; }
    int *tempConUBPos() { return tempConUBPos_; }

    //------------------------------------------------------
    // LP SOLUTION
    //------------------------------------------------------

    double getLpObjValue() const { return lpSolver_->getObjValue(); }

    const double * getLpSolution() const { return lpSolver_->getColSolution();}
    
    //double * savedLpSolution() { return savedLpSolution_; }
    
    //------------------------------------------------------
    // MILP SOLUTION
    //------------------------------------------------------

    int getNumSolutions() const { return numSolutions_; }
    
    int getNumHeurSolutions() const { return numHeurSolutions_;}
    
    double * incumbent() { return incumbent_; }
    
    bool setBestSolution(BLIS_SOL_TYPE how,
                         double & objectiveValue, 
                         const double *solution,
                         bool fixVariables = false);

    inline double getCutoff() const { return cutoff_;  }

    inline void setCutoff(double co) { 
        double direction = lpSolver_->getObjSense();
        lpSolver_->setDblParam(OsiDualObjectiveLimit, co * direction);
        cutoff_ = co;
    }

    bool feasibleSolution(int & numIntegerInfs);

    bool feasibleSolution(int & numIntegerInfs, int & numObjectInfs);
    
    //------------------------------------------------------
    // BRANCHING
    //------------------------------------------------------

    inline BcpsBranchStrategy * branchStrategy() const
        { return branchStrategy_; }

    inline void setBranchingMethod(BcpsBranchStrategy * method){
        if (branchStrategy_) delete branchStrategy_;
        branchStrategy_ = method; 
    }

    inline void setBranchingMethod(BcpsBranchStrategy & method) { 
        if (branchStrategy_) delete branchStrategy_;
        branchStrategy_ = &method;
    }

    inline int numObjects() const { return numObjects_; }

    inline void setNumObjects(int num) { numObjects_ = num; }

    inline BcpsObject ** objects() { return objects_;}

    inline BcpsObject * objects(int which) { return objects_[which]; }
    
    void deleteObjects();

    void addObjects(int numObjects, BcpsObject ** objects);

    void findIntegers(bool startAgain);

    int getNumIntVars() const { return numIntVars_; }

    int* getIntVars() const { return intVars_; }

    bool checkInteger(double value) const {
        double integerTolerance = 1.0e-5;
        double nearest = floor(value + 0.5);
        if (fabs(value - nearest) <= integerTolerance) {
            return true;
        }
        else {
            return false;
        }
    }

    //------------------------------------------------------
    // HEURISTICS.
    //------------------------------------------------------

    void addHeuristic(BlisHeuristic * heur);
    
    BlisHeuristic * heuristics(int i) const { return heuristics_[i]; }

    int numHeuristics() const { return numHeuristics_; }

    //------------------------------------------------------
    // CONSTRAINTS.
    //------------------------------------------------------

    void addCutGenerator(CglCutGenerator * generator,
                         const char * name = NULL,
                         int strategy = 0,
                         bool normal = true, 
                         bool atSolution = false,
                         bool whenInfeasible = false);
    
    BlisConGenerator *cutGenerators(int i) const { return generators_[i]; }

    int numCutGenerators() const { return numCutGenerators_; }

    int getMaxNumCons() const { return maxNumCons_; }

    void setMaxNumCons(int m) { maxNumCons_ = m; }

    BcpsConstraintPool *constraintPool() { return constraintPool_; }


    int getNumOldConstraints() const { return numOldConstraints_; }

    void setNumOldConstraints(int num) { numOldConstraints_ = num; }
    
    int getOldConstraintsSize() const { return oldConstraintsSize_; }
    
    void setOldConstraintsSize(int num) { oldConstraintsSize_ = num; }

    BlisConstraint **oldConstraints() { return oldConstraints_; }
    
    void setOldConstraints(BlisConstraint **old) { oldConstraints_ = old; }

    void delOldConstraints() {
        delete [] oldConstraints_; 
        oldConstraints_ = NULL; 
    }

    int useCons() const { return useCons_; }

    void setUseCons(int u) { useCons_ = u; }

    int getDenseConCutoff() const { return denseConCutoff_; }

    void setDenseConCutoff(int cutoff) { denseConCutoff_ = cutoff; }
    
    double *getConRandoms() const { return conRandoms_; }
    
    //------------------------------------------------------
    // PRIORITY AND WEITGHT.
    //------------------------------------------------------

    void passInPriorities(const int * priorities, 
                          bool ifNotSimpleIntegers,
                          int defaultValue = 1000);
    
    inline const int * priority() const { return priority_; }
    
    inline int priority(int sequence) const { 
        if (priority_) return priority_[sequence];
        else return 1000;
    }
    
    inline const double getNodeWeight() const { return nodeWeight_; }

    inline void setNodeWeight(double nw) { nodeWeight_ = nw; }

    //------------------------------------------------------
    // STATISTICS.
    //------------------------------------------------------

    virtual void modelLog();
    
    int getNumNodes() const { return numNodes_; }

    int getNumIterations() const { return numIterations_; }

    int getAveIterations() const { return aveIterations_; }

    void addNumNodes(int newNodes = 1) { numNodes_ += newNodes; }

    void addNumIterations(int newIter) {
        numIterations_ += newIter; 
        aveIterations_ = numIterations_ / numNodes_;
    }

    inline CoinMessageHandler * messageHandler() const { return handler_; }

    BlisParams * BlisPar() { return BlisPar_; }

    int getHotstartStrategy() { return hotstartStrategy_; }
    void setHotstartStrategy(int value) { hotstartStrategy_ = value; }

    //------------------------------------------------------
    // PARALLEL
    //------------------------------------------------------

    virtual void registerKnowledge();    
    
    virtual AlpsEncoded* encode() const;
    
    virtual void decodeToSelf(AlpsEncoded&);
};

#endif /* End of file */