BlockIPInterface.h

Go to the documentation of this file.

#ifndef BLOCKIP_INTERFACE_H
#define BLOCKIP_INTERFACE_H

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

#include "ExceptionBlockIPInterface.h"
#include "BlockIP.h"
#include "SMLBlockIP.h"
#ifdef OSI_INTERFACE
#include "OsiInterface.h"
#endif // OSI_INTERFACE
#include "StdForm.h"
#include <vector>

using namespace std; 

class EXPDLL BlockIPInterface {
  public:
    enum SOLVER{CPLEX, XPRESS, GLPK, CLP, BLOCKIP, BLOCKIP_MATLAB, NONE};
    enum OPT_STATUS{OPTIMAL_SOLUTION, TIME_LIMIT_INFEAS, TIME_LIMIT_FEAS, FEASIBLE, INFEASIBLE, OTHERWISE, UNBOUNDED};
    enum TYPE_INPUT {NO_INPUT, MPS, AMPL, BLOCKIP_FORMAT};
    
  private:
    BlockIP *bip; 
    SMLBlockIP *smlbip; 
#ifdef OSI_INTERFACE
    OsiInterface *oi; 
#endif // OSI_INTERFACE
    SOLVER solver; 
    double maxTime; 
    int numThreads; 
    bool solved; 
    char *logFilename; 
    char *solFilename; 
    StdForm *stdForm; 
    string *varNames; 
    int numVars; 
    int *varsOrder; 
    bool amplOrMps; 
    TYPE_INPUT type_input; 
    
    int numVarsMatlab; 
    int numConsMatlab; 
    
    // only for BlockIP_Matlab
    int numBlocks; 
    int numCons; 
    int numLinCons; 
    string *consNames; 
    string *blockNames; 
    int *varsPerBlock; 
    int *consPerBlock; 
    vector<int> *indexUbInf; 
    
    double fobj; 
    double dobj; 
    double *x; 
    double *y; 
    double *z; 
    double *w; 
    double *rc; 
    int iter; 
    int iterPCG; 
    double CPUsec; 
 
  public:
    double infMatlab; 
    int iterMatlab; 
    int typeCompMatlab; 
    const char *pathMatlab; 
    
  public:
    // Constructor
    BlockIPInterface();
    
    // Destructor
    ~BlockIPInterface();
    
    // Set the solver to be used
    void setSolver(SOLVER solver);
    
    // Get the solver to be used
    SOLVER getSolver();
    
    // Set maximum time allowed to solve the problem
    void setMaxTime(double time);
    
    // Get maximum time allowed to solve the problem
    double getMaxTime();
    
    // Set the maximum number of threads to be used
    void setMaxThreads(int numThreads);
    
    // Get the maximum number of threads to be used
    int getMaxThreads();
    
    // Set the name of the log file
    void setLogFilename(char *filename);
    
    // Get the name of the log file
    const char* getLogFilename();
    
    // Set the name of the solution file
    void setSolFilename(char *filename);
    
    // Get the name of the solution file
    const char* getSolFilename();

    // Get BlockIP interface
    BlockIP* getBlockIPInterface();

#ifdef OSI_INTERFACE     
    // Get solver interface
    OsiInterface* getSolverInterface();
#endif // OSI_INTERFACE
    
    // Load a problem from a mps file
    void readMps(const char *filename);
    
    // Load a problem from ampl files
    void readAmpl(const char *modelFilename, const char *dataFilename);
    
    // Load a problem from BlockIP format file
    void readBlockIPFormat(const char *filename);
    
    // Converts a problem in ampl format to mps format
    void amplToMps(const char *modelFilename, const char *dataFilename, const char *mpsFilename, bool convertToStd=false);
    
    // Converts a problem in ampl format to BlockIP format
    void amplToBlockIPFormat(const char *modelFilename, const char *dataFilename, const char *BlockIPFormatFilename, bool convertToStd=false);
    
    // Converts a problem in mps format to BlockIP format
    void mpsToBlockIPFormat(const char *mpsFilename, const char *BlockIPFormatFilename, bool convertToStd=false);
    
    // Converts a problem in BlockIP format to mps format
    void BlockIPFormatToMps(const char *BlockIPFormatFilename, const char *mpsFilename, bool convertToStd=false);
    
    // Solve the problem loaded
    OPT_STATUS solve();
    
    // Get the objective function value
    double getObjValue();
    
    // Get the solution
    const double* getSolution();
    
    // Get the number of variables
    int getNumVars();
    
    // Only for BlockIP
    // Get dual objective function
    double getDualValue();
    // Get the number of IP iterations performed
    int getIter();
    // Get the overall number of PCG iterations performed
    int getPCGIter();
    // Get the CPU seconds of the optimization process
    double getCPUsec();

    // Display the primal variables value of blocks and slacks
    void printX();
    void printX(int globalVarIndex);
    void printX(string varName);
    void printX(int blockIndex, int varIndex);
    void printX(string blockName, int varIndex);
    void printXBlock(int blockIndex);
    void printXBlock(string blockName);
    void printXSlack();
    void printXSlack(int slackIndex);

    // Display the reduced cost of primal variables of blocks and slacks
    void printRC();
    void printRC(int globalVarIndex);
    void printRC(string varName);
    void printRC(int blockIndex, int varIndex);
    void printRC(string blockName, int varIndex);
    void printRCBlock(int blockIndex);
    void printRCBlock(string blockName);
    void printRCSlack();
    void printRCSlack(int slackIndex);

    // Display the dual variables value of blocks and linking constraints
    void printCons();
    void printCons(int globalConsIndex);
    void printCons(string consName);
    void printCons(int blockIndex, int consIndex);
    void printCons(string blockName, int consIndex);
    void printConsBlock(int blockIndex);
    void printConsBlock(string blockName);
    void printConsLinking();
    void printConsLinking(int linkingIndex);

    
  protected:
    // Free all allocated memory
    void freeMemory();
    
    // Create the files to load and solve a problem in BlockIP Matlab
    void createMatlabProblem();
};

inline void BlockIPInterface::setSolver(SOLVER solver)

{
#ifndef OSI_INTERFACE
  if (solver == CPLEX || solver == XPRESS || solver == GLPK || solver == CLP)
    throw ExceptionBlockIPInterface(ExceptionBlockIPInterface::OSI_INTERFACE_NOT_AVAILABLE);
#endif
  this->solver = solver;
}

inline BlockIPInterface::SOLVER BlockIPInterface::getSolver()
{
  return solver;
}

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

inline double BlockIPInterface::getMaxTime()

{
  return maxTime;
}
 
inline void BlockIPInterface::setMaxThreads(int numThreads)
{
  this->numThreads = numThreads;
}
    
inline int BlockIPInterface::getMaxThreads()
{
  return numThreads;
}

inline const char* BlockIPInterface::getLogFilename()

{
  return logFilename;
}

inline const char* BlockIPInterface::getSolFilename()

{
  return solFilename;
}

inline BlockIP* BlockIPInterface::getBlockIPInterface()

{
  return bip;
}

#ifdef OSI_INTERFACE 
inline OsiInterface* BlockIPInterface::getSolverInterface()

{
  return oi;
}
#endif // OSI_INTERFACE

inline double BlockIPInterface::getObjValue()
{
  return fobj;
}

inline double BlockIPInterface::getDualValue()
// Get dual objective function
{
  return dobj;
}

inline int BlockIPInterface::getIter()
// Get the number of IP iterations performed
{
  return iter;
}

inline int BlockIPInterface::getPCGIter()
// Get the overall number of PCG iterations performed
{
  return iterPCG;
}

inline double BlockIPInterface::getCPUsec()
// Get the CPU seconds of the optimization process
{
  return CPUsec;
}

#endif //BLOCKIP_INTERFACE_H