osiif.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/lib/abacus/lp.h>
#include <ogdf/lib/abacus/optsense.h>
#include <ogdf/lib/abacus/lpvarstat.h>
#include <ogdf/lib/abacus/slackstat.h>
#include <ogdf/lib/abacus/csense.h>
#include <ogdf/lib/abacus/osiinclude.h>
#include <coin/CoinPackedMatrix.hpp>
#include <coin/CoinPackedVector.hpp>
#include <coin/CoinWarmStartBasis.hpp>
#include <coin/CoinBuild.hpp>
 
#pragma GCC visibility push(default)
namespace abacus {
 
class LpMasterOsi;
 
 
class  OsiIF :  public virtual LP  {
public:
 
 
    OsiIF(Master *master);
 
 
    OsiIF(Master *master,
        OptSense sense,
        int nRow,
        int maxRow,
        int nCol,
        int maxCol,
        Array<double> &obj,
        Array<double> &lb,
        Array<double> &ub,
        Array<Row*> &rows);
 
    virtual ~OsiIF();
 
    enum SOLVERTYPE { Exact, Approx };
 
    SOLVERTYPE currentSolverType() const { return currentSolverType_; }
 
    OsiSolverInterface* osiLP() { return osiLP_; }
 
 
private:
 
 
    OsiSolverInterface *osiLP_;
 
    /***************************************************
     * Helper functions to free allocated memory
     **************************************************/
 
    void freeDouble(const double* &ptr) {
        delete [] ptr;
        ptr = nullptr;
    }
 
    void freeDouble(double* &ptr) {
        delete [] ptr;
        ptr = nullptr;
    }
 
    void freeInt(int* &ptr) {
        delete [] ptr;
        ptr = nullptr;
    }
 
    void freeChar(char* &ptr) {
        delete [] ptr;
        ptr = nullptr;
    }
 
    void freeChar(const char* &ptr) {
        delete [] ptr;
        ptr = nullptr;
    }
 
    void freeStatus(CoinWarmStartBasis::Status*&);
 
 
    virtual void _initialize(
        OptSense sense,
        int nRow, int maxRow,
        int nCol, int maxCol,
        Array<double> &obj,
        Array<double> &lBound,
        Array<double> &uBound,
        Array<Row*> &rows) override;
 
 
    virtual void _loadBasis(Array<LPVARSTAT::STATUS> &lpVarStat,
        Array<SlackStat::STATUS> &slackStat) override;
 
 
    virtual OptSense _sense() const override;
 
 
    virtual void _sense(const OptSense &newSense) override;
 
 
    virtual int  _nRow()  const override { return numRows_; }
 
 
    virtual int  _maxRow() const override {
        return numRows_;  // Size management is completely done by Osi!
    }
 
 
    virtual int  _nCol() const override { return numCols_; }
 
 
    virtual int  _maxCol() const override {
        return numCols_;  // Size management is completely done by Osi!
    }
 
 
    virtual double _obj(int i) const override { return objcoeff_[i]; }
 
 
    virtual double _lBound(int i) const override { return collower_[i]; }
 
 
    virtual double _uBound(int i) const override { return colupper_[i]; }
 
 
    virtual double _rhs(int i) const override { return rhs_[i]; }
 
 
    virtual void _row(int i, Row &r) const override;
 
 
    virtual int _nnz() const override { return osiLP_->getNumElements(); }
 
 
    virtual OPTSTAT _primalSimplex() override;
 
 
    virtual OPTSTAT _dualSimplex() override;
 
 
    virtual OPTSTAT _barrier(bool doCrossover) override;
 
 
    virtual OPTSTAT _approx() override;
 
 
    virtual double _value() const override { return value_; }
 
 
    virtual double _xVal(int i) const override { return xVal_[i]; }
 
 
    virtual double _barXVal(int i) const override;
 
 
    virtual double _reco(int i) const override { return reco_[i]; }
 
 
    virtual double _slack(int i) const override;
 
 
    virtual double _yVal(int i) const override { return yVal_[i]; }
 
 
    virtual LPVARSTAT::STATUS _lpVarStat(int i) const override;
 
 
    virtual SlackStat::STATUS _slackStat(int i) const override;
 
 
    virtual int  _getInfeas(int &infeasRow, int &infeasCol, double *bInvRow) const override;
 
 
    virtual void _remRows(ArrayBuffer<int> &ind) override;
 
 
    virtual void _addRows(ArrayBuffer<Row*> &newRows) override ;
 
 
    virtual void _remCols(ArrayBuffer<int> &vars) override;
 
 
    virtual void _addCols(ArrayBuffer<Column*> &newVars) override;
 
 
    virtual void _changeRhs(Array<double> &newRhs) override;
 
 
    virtual void _changeLBound(int i, double newLb) override;
 
 
    virtual void _changeUBound(int i, double newUb) override;
 
 
    virtual int _pivotSlackVariableIn(ArrayBuffer<int> &rows) override;
 
 
    void getSol();
 
    char csense2osi(CSense *sense) const;
 
    CSense::SENSE osi2csense(char sense) const;
 
    CoinWarmStartBasis::Status lpVarStat2osi(LPVARSTAT::STATUS stat) const;
 
    LPVARSTAT::STATUS osi2lpVarStat(CoinWarmStartBasis::Status stat) const;
 
    CoinWarmStartBasis::Status slackStat2osi(SlackStat::STATUS stat) const;
 
    SlackStat::STATUS osi2slackStat(CoinWarmStartBasis::Status stat) const;
 
    OsiSolverInterface* getDefaultInterface();
 
    OsiSolverInterface* switchInterfaces(SOLVERTYPE newMethod);
 
 
    void loadDummyRow(OsiSolverInterface* s2, const double* lbounds, const double* ubounds, const double* objectives);
 
 
    void _rowRealloc(int newSize) override;
 
 
    void _colRealloc(int newSize) override;
 
 
    virtual int _setSimplexIterationLimit(int limit) override {
        return(!osiLP_->setIntParam(OsiMaxNumIteration, limit));
    }
 
    /***
     *  \param limit Stores the iteration limit if the return value is 0.
     *
     *  \return 0 If the iteration limit could be retrieved, \return 1 otherwise.
     */
    virtual int _getSimplexIterationLimit(int &limit) const override {
        return(!osiLP_->getIntParam(OsiMaxNumIteration, limit));
    }
 
    void convertSenseToBound(
        double inf,
        const char sense,
        const double right,
        const double range,
        double& lower,
        double& upper) const
    {
        switch (sense) {
        case 'E':
            lower = upper = right;
            break;
        case 'L':
            lower = -inf;
            upper = right;
            break;
        case 'G':
            lower = right;
            upper = inf;
            break;
        case 'R':
            lower = right - range;
            upper = right;
            break;
        case 'N':
            lower = -inf;
            upper = inf;
            break;
        }
    }
 
    LpMasterOsi *lpMasterOsi_;
 
    double  value_;
 
    double *xVal_;
 
    const double *barXVal_;
 
    double *reco_;
 
    double *yVal_;
 
    char *cStat_;
 
    int numCols_;
 
    int numRows_;
 
    char *rStat_;
 
    const double *rhs_;
 
    double *rowactivity_;
 
    const char *rowsense_;
 
    const double *colupper_;
 
    const double *collower_;
 
    const double *objcoeff_;
 
    CoinWarmStartBasis *ws_;
 
    SOLVERTYPE currentSolverType_;
 
    OsiIF(const OsiIF &rhs);
    const OsiIF &operator=(const OsiIF &rhs);
};
 
}
#pragma GCC visibility pop