CbcSolver.hpp

Go to the documentation of this file.

/* $Id: CbcSolver.hpp 1212 2009-08-21 16:19:13Z forrest $ */
// Copyright (C) 2007, International Business Machines
// Corporation and others.  All Rights Reserved.

#ifndef CbcSolver_H
#define CbcSolver_H

#include <string>
#include <vector>
#include "CoinFinite.hpp"
#include "CoinMessageHandler.hpp"
#include "OsiClpSolverInterface.hpp"

#if CBC_OTHER_SOLVER==1
#include "OsiCpxSolverInterface.hpp"
#endif

#include "CbcModel.hpp"
#include "CbcOrClpParam.hpp"

class CbcUser;
class CbcStopNow;
class CglCutGenerator;

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

class CbcSolver {

public:


    int solve(int argc, const char * argv[], int returnMode);
    int solve(const char * input, int returnMode);

    CbcSolver();

    CbcSolver(const OsiClpSolverInterface &);

    CbcSolver(const CbcModel &);

    CbcSolver(const CbcSolver & rhs);

    CbcSolver & operator=(const CbcSolver& rhs);

    ~CbcSolver ();
    void fillParameters();
    void fillValuesInSolver();
    void addUserFunction(CbcUser * function);
    void setUserCallBack(CbcStopNow * function);
    void addCutGenerator(CglCutGenerator * generator);

    // analyze model
    int * analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment,
                  bool changeInt,  CoinMessageHandler * generalMessageHandler);
    //int doHeuristics(CbcModel * model, int type);
    void updateModel(ClpSimplex * model2, int returnMode);

    int intValue(CbcOrClpParameterType type) const;
    void setIntValue(CbcOrClpParameterType type, int value);
    double doubleValue(CbcOrClpParameterType type) const;
    void setDoubleValue(CbcOrClpParameterType type, double value);
    CbcUser * userFunction(const char * name) const;
    inline CbcModel * model() {
        return &model_;
    }
    inline CbcModel * babModel() {
        return babModel_;
    }
    inline int numberUserFunctions() const {
        return numberUserFunctions_;
    }
    inline CbcUser ** userFunctionArray() const {
        return userFunction_;
    }
    inline OsiClpSolverInterface * originalSolver() const {
        return originalSolver_;
    }
    inline CoinModel * originalCoinModel() const {
        return originalCoinModel_;
    }
    void setOriginalSolver(OsiClpSolverInterface * originalSolver);
    void setOriginalCoinModel(CoinModel * originalCoinModel);
    inline int numberCutGenerators() const {
        return numberCutGenerators_;
    }
    inline CglCutGenerator ** cutGeneratorArray() const {
        return cutGenerator_;
    }
    inline double startTime() const {
        return startTime_;
    }
    inline void setPrinting(bool onOff) {
        noPrinting_ = !onOff;
    }
    inline void setReadMode(int value) {
        readMode_ = value;
    }
private:


    CbcModel model_;

    CbcModel * babModel_;

    CbcUser ** userFunction_;
    int * statusUserFunction_;
    OsiClpSolverInterface * originalSolver_;
    CoinModel * originalCoinModel_;
    CglCutGenerator ** cutGenerator_;
    int numberUserFunctions_;
    int numberCutGenerators_;
    CbcStopNow * callBack_;
    double startTime_;
    CbcOrClpParam * parameters_;
    int numberParameters_ ;
    bool doMiplib_;
    bool noPrinting_;
    int readMode_;
};
//#############################################################################

typedef struct {
    // Priorities
    int * priorities_;
    // SOS priorities
    int * sosPriority_;
    // Direction to branch first
    int * branchDirection_;
    // Input solution
    double * primalSolution_;
    // Down pseudo costs
    double * pseudoDown_;
    // Up pseudo costs
    double * pseudoUp_;
} CbcSolverUsefulData;


class CbcUser {

public:


    virtual int importData(CbcSolver * /*model*/, int & /*argc*/, char ** /*argv[]*/) {
        return -1;
    }

    virtual void exportSolution(CbcSolver * /*model*/,
                                int /*mode*/, const char * /*message*/ = NULL) {}

    virtual void exportData(CbcSolver * /*model*/) {}

    virtual void fillInformation(CbcSolver * /*model*/,
                                 CbcSolverUsefulData & /*info*/) {}


    inline CoinModel *coinModel() const {
        return coinModel_;
    }
    virtual void * stuff() {
        return NULL;
    }
    inline std::string name() const {
        return userName_;
    }
    virtual void solve(CbcSolver * model, const char * options) = 0;
    virtual bool canDo(const char * options) = 0;


    CbcUser();

    CbcUser(const CbcUser & rhs);

    CbcUser & operator=(const CbcUser& rhs);

    virtual CbcUser * clone() const = 0;

    virtual ~CbcUser ();

protected:


    CoinModel * coinModel_;

    std::string userName_;

};
//#############################################################################

class CbcStopNow {

public:


    virtual int callBack(CbcModel * /*currentSolver*/, int /*whereFrom*/) {
        return 0;
    }


    CbcStopNow();

    CbcStopNow(const CbcStopNow & rhs);

    CbcStopNow & operator=(const CbcStopNow& rhs);

    virtual CbcStopNow * clone() const;

    virtual ~CbcStopNow ();

private:


};
#endif