OsiSolver.h

Go to the documentation of this file.

#ifndef OSI_SOLVER_H
#define OSI_SOLVER_H

#ifndef EXPDLL
#ifdef WIN32
#ifdef OSI_INTERFACE_EXPORTS
#define EXPDLL __declspec(dllexport)
#else
#define EXPDLL __declspec(dllimport)
#endif //OSI_INTERFACE_EXPORTS
#else
#define EXPDLL 
#endif //WIN32
#endif //EXPDLL

#include "CoinPackedMatrix.hpp"
#include "OsiSolverInterface.hpp"
#include "CoinMessageHandler.hpp"
#include "ExceptionOsiSolver.h"

using namespace std; 


class EXPDLL OsiSolver {
  public:
    enum STATUS{OPTIMAL_SOLUTION, TIME_LIMIT_INFEAS, TIME_LIMIT_FEAS, FEASIBLE, FIRST_FEASIBLE, INFEASIBLE, OTHERWISE};
    
  protected:
    double maxTime; 
    bool stopAtFirstFeasible; 
    bool solved; 
    int numThreads; 
    OsiSolverInterface *si; 
    CoinMessageHandler *cmh; 
    FILE *f; 
    char *filename; 
    double fobj; 
    
  public:
    // Constructor
    OsiSolver();
    
    // Destructor
    ~OsiSolver();
    
    // Set maximum time allowed to solve the problem
    inline void setMaxTime(double time);
    
    // Get maximum time allowed to solve the problem
    inline double getMaxTime();
    
    // Set the maximum number of threads that the solver can use to solve the problem
    inline void setNumThreads(int numThreads);
    
    // Get the maximum number of threads that the solver can use to solve the problem
    inline int getNumThreads();
    
    // Set if the execution must be stopped at first feasible solution
    inline void setFirstFeasible(bool stopAtFirstFeasible);
    
    // Get if the execution must be stopped at first feasible solution
    inline bool getFirstFeasible();
    
    // Set the name of the log file
    void setLogFileName(char *filename);
    
    // Get the name of the log file
    inline const char* getLogFileName();
    
    // Get solver interface
    inline OsiSolverInterface* getSolverInterface();
    
    // Load a problem from a mps file
    virtual void readMps(const char *filename);
    
    // Load a problem
    void loadProblem(int numRows, int numColumns, int nz, double obj[], double qobj[], double lb[], double ub[], 
    double lhs[], double rhs[], int begRows[], int indCols[], double values[], bool copy_vectors=true);
    
    // Solve the problem loaded
    virtual STATUS solve();
    
    // Get the objective function value
    inline double getObjValue();
    
    // Get the solution
    virtual const double* getSolution();
    
    // Get the number of variables
    inline int getNumVars();
    
    // Get the name of variables
    virtual const string* getVarNames();
    
  protected:
    // Free all allocated memory
    void freeMemory();
    
    // Load the quadratic objective function cost
    virtual void loadQuadraticObj(double qobj[]);
};

void OsiSolver::setMaxTime(double time)
{
  this->maxTime = time;
}

double OsiSolver::getMaxTime()

{
  return maxTime;
}

void OsiSolver::setNumThreads(int numThreads)
{
  if (numThreads > 0)
    this->numThreads = numThreads;
  else
    this->numThreads = -1;
}

inline int OsiSolver::getNumThreads()

{
  return numThreads;
}

void OsiSolver::setFirstFeasible(bool stopAtFirstFeasible)

{
  this->stopAtFirstFeasible = stopAtFirstFeasible;
}

bool OsiSolver::getFirstFeasible()

{
  return stopAtFirstFeasible;
}

const char* OsiSolver::getLogFileName()
{
  return filename;
}

OsiSolverInterface* OsiSolver::getSolverInterface()

{
  return si;
}

double OsiSolver::getObjValue()
{
  return fobj;
}

int OsiSolver::getNumVars()

{
  if (!si)
    return 0;
  return si->getNumCols();
}

#endif //OSI_SOLVER_H