osiif.h

Go to the documentation of this file.

#ifndef OSIIF_H
#define OSIIF_H
#include "abacus/lp.h"
#include "abacus/optsense.h"
#include "abacus/lpvarstat.h"
#include "abacus/slackstat.h"
#include "abacus/csense.h"
#include "abacus/osiinclude.h"
#include <CoinPackedVector.hpp>
#include <CoinWarmStartBasis.hpp>
#include <CoinBuild.hpp>

class ABA_LPMASTEROSI;

  class  ABA_OSIIF :  public virtual ABA_LP  {
    public:

    ABA_OSIIF(ABA_MASTER *master);

      ABA_OSIIF(ABA_MASTER *master,
                  ABA_OPTSENSE sense, 
                  int nRow, 
                  int maxRow, 
                  int nCol, 
                  int maxCol,
                  ABA_ARRAY<double> &obj, 
                  ABA_ARRAY<double> &lb, 
                  ABA_ARRAY<double> &ub,
                  ABA_ARRAY<ABA_ROW*> &rows);

      virtual ~ABA_OSIIF();

      enum SOLVERTYPE {Exact, Approx};

      inline SOLVERTYPE currentSolverType()
      { return currentSolverType_; }

      inline OsiSolverInterface* osiLP();
         

    private:

      /****************************************************************
       * Pointer to the Osi solver interface. It is later typecast to 
       * a pointer to an object of a solver specific derived class.
       * See osiif.cc, ABA_OSIIF::_initialize.
       ****************************************************************/
      OsiSolverInterface *osiLP_;

      /***************************************************
       * Helper functions to free allocated memory
       **************************************************/

      void freeDouble(const double*&);

      void freeDouble(double*&);

      void freeInt(int*&);
      
      void freeChar(char*&);

      void freeChar(const char*&);

      void freeStatus(CoinWarmStartBasis::Status*&);

      virtual void    _initialize(ABA_OPTSENSE sense, int nRow, int maxRow,
                                  int nCol, int maxCol,
                                  ABA_ARRAY<double> &obj, ABA_ARRAY<double> &lBound,
                                  ABA_ARRAY<double> &uBound, ABA_ARRAY<ABA_ROW*> &rows);

      virtual void _loadBasis(ABA_ARRAY<ABA_LPVARSTAT::STATUS> &lpVarStat,
                              ABA_ARRAY<ABA_SLACKSTAT::STATUS> &slackStat);

      virtual ABA_OPTSENSE _sense() const;

      virtual void     _sense(const ABA_OPTSENSE &newSense);

      virtual int      _nRow()  const;

      virtual int      _maxRow() const;

      virtual int      _nCol() const;

      virtual int      _maxCol() const;

      virtual double   _obj(int i) const; 

      virtual double   _lBound(int i) const;

      virtual double   _uBound(int i) const;

      virtual double   _rhs(int i) const;

      virtual void     _row(int i, ABA_ROW &r) const;

      virtual int      _nnz() const;


      virtual OPTSTAT _primalSimplex();

      virtual OPTSTAT _dualSimplex();

      virtual OPTSTAT _barrier(bool doCrossover);

      virtual OPTSTAT _approx();

      virtual double _value() const;

      virtual double _xVal(int i);

      virtual double _barXVal(int i);

      virtual double _reco(int i);

      virtual double _slack(int i);

      virtual double _yVal(int i);

      virtual ABA_LPVARSTAT::STATUS _lpVarStat(int i);

      virtual ABA_SLACKSTAT::STATUS _slackStat(int i);
     
      virtual int  _getInfeas(int &infeasRow, int &infeasCol, double *bInvRow);

      virtual void _remRows(ABA_BUFFER<int> &ind);

      virtual void _addRows(ABA_BUFFER<ABA_ROW*> &newRows) ;

      virtual void _remCols(ABA_BUFFER<int> &vars);

      virtual void _addCols(ABA_BUFFER<ABA_COLUMN*> &newVars);

      virtual void _changeRhs(ABA_ARRAY<double> &newRhs);

      virtual void _changeLBound(int i, double newLb);

      virtual void _changeUBound(int i, double newUb);

      virtual int _pivotSlackVariableIn(ABA_BUFFER<int> &rows);

      void              getSol();

      char              csense2osi(ABA_CSENSE *sense)             const;

      ABA_CSENSE::SENSE     osi2csense(char sense)                const;

      CoinWarmStartBasis::Status lpVarStat2osi(ABA_LPVARSTAT::STATUS stat) const;

      ABA_LPVARSTAT::STATUS osi2lpVarStat(CoinWarmStartBasis::Status stat)               const;

      CoinWarmStartBasis::Status slackStat2osi(ABA_SLACKSTAT::STATUS stat) const;

      ABA_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);

      void _colRealloc(int newSize);
     
      virtual int _setSimplexIterationLimit(int limit);
      
      virtual int _getSimplexIterationLimit(int &limit);
      ABA_LPMASTEROSI *lpMasterOsi_;

      double  value_;

      const double *xVal_;
      const double *barXVal_;

      const double *reco_;

      const double *yVal_;

      const char *cStat_;

      int numCols_;

      int numRows_;

      const char *rStat_;

      const double *rhs_;
 
      const double *rowactivity_;

      const char *rowsense_;

      const double *colupper_;
      
      const double *collower_;

      const double *objcoeff_;

      CoinWarmStartBasis *ws_;

      SOLVERTYPE currentSolverType_;

      ABA_OSIIF(const ABA_OSIIF &rhs);
      const ABA_OSIIF &operator=(const ABA_OSIIF &rhs);

inline 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;
   }
 }

  };

inline OsiSolverInterface* ABA_OSIIF::osiLP()
{ return osiLP_; }
#endif

---