GamsModel.hpp

Go to the documentation of this file.

// Copyright (C) 2006-2008 GAMS Development and others
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: GamsModel.hpp 510 2008-08-16 19:31:27Z stefan $
//
// Authors: Michael Bussieck, Stefan Vigerske

#ifndef __GAMSMODEL_HPP__
#define __GAMSMODEL_HPP__

#include "GAMSlinksConfig.h"
// from CoinUtils
#include "CoinPragma.hpp"

extern "C" struct dictRec;

class GamsModel  {
public:
  enum  BasisStatus { 
    NonBasicLower = 0,
    NonBasicUpper,
    Basic,
    SuperBasic,
    LastBasisStatus 
  };
  
  enum VariableStatus {
                VarNormal = 0,
                VarNonOptimal,
                VarInfeasible,
                VarUnbounded,
                VarLastStatus   
  };

  enum RowStatus {
                RowNormal = 0,
                RowNonOptimal,
                RowInfeasible,
                RowUnbounded,
                RowLastStatus   
  };
  
  enum  SolverStatus { 
    SolverStatusNotSet = 0,
    NormalCompletion = 1,
    IterationInterrupt,
    ResourceInterrupt,
    TerminatedBySolver,
    EvaluationErrorLimit,
    CapabilityProblems,
    LicensingProblems,
    UserInterrupt,
    ErrorSetupFailure,
    ErrorSolverFailure,
    ErrorInternalSolverError,
    SolveProcessingSkipped,
    ErrorSystemFailure,
    LastSolverStatus 
  }; 

  enum  ModelStatus { 
    ModelStatusNotSet = 0,
    Optimal,
    LocallyOptimal,
    Unbounded,
    Infeasible,
    LocallyInfeasible,
    IntermediateInfeasible,
    IntermediateNonoptimal,
    IntegerSolution,
    IntermediateNonInteger,
    IntegerInfeasible,
    LicensingProblemNoSolution,
    ErrorUnknown,
    ErrorNoSolution,
    NoSolutionReturned,
    SolvedUnique,
    Solved,
    SolvedSingular,
    UnboundedNoSolution,
    InfeasibleNoSolution,
    LastModelStatus 
  };
  
  enum PrintMask {
        LogMask = 0x1,
        StatusMask = 0x2,
        AllMask = LogMask|StatusMask,
        LastPrintMask
  };
  

  GamsModel(const char *cntrfile);

  ~GamsModel();

  void readMatrix();

  void PrintOut(PrintMask mask, const char *msg);
  
  int getSysOut(); 
  void TimerStart();
  double SecondsSinceStart();
        const char* getSystemDir();
        
        double getMInfinity() const;
        double getPInfinity() const;
        void setInfinity(const double& SolverMInf, const double& SolverPInf);
        
        bool isReformulated() const { return isReform_; }
        
        bool isLP() const;
  inline int nCols() const  { return nCols_; }
  inline int nDCols() const { return nDCols_; }
  inline int nSOS1() const  { return nSOS1_; }
  inline int nSOS2() const  { return nSOS2_; }
        inline int nSemiContinuous() const { return nSemiCon_; }
  inline int nRows() const  { return nRows_; }
  inline int nNnz()  const  { return nNnz_; }

  inline double *ColLb()    { return ColLb_; }
  inline double *ColUb()    { return ColUb_; }
  inline bool   *ColDisc()  { return ColDisc_; }
  inline int    *SOSIndicator() { return SOSIndicator_; }
  inline bool   *ColSemiContinuous() { return ColSemiCon_; } 
  inline double *ColLevel()     { return ColLevel_; }
  inline double *ColMargin()    { return ColMargin_; }
  inline int    *ColBasis()     { return ColBasis_; }
  inline double *ColPriority()  { return ColPriority_; }
  inline double *ColScale()     { return ColScale_; }

  inline char   *RowSense() { return RowSense_; }
  inline double *RowRhs()   { return RowRhs_; }
  inline double *RowLevel()     { return RowLevel_; }
  inline double *RowMargin()    { return RowMargin_; }
  inline int    *RowBasis()     { return RowBasis_; }
  inline double *RowScale()     { return RowScale_; }

  inline double *ObjCoef()  { return ObjCoef_; }
  inline double ObjConstant()  { return ObjRhs_; }
  inline double ObjSense() const { return ObjSense_; }
  inline double ObjScale() const { return ObjScale_; } 

  inline int    *matStart()  { return matStart_; }
  inline int    *matRowIdx() { return matRowIdx_; }
  inline double *matValue()  { return matValue_; }
  int matSqueezeZeros();
  ModelStatus getModelStatus();
  SolverStatus getSolverStatus();

  void setStatus(const SolverStatus& newSolverStatus, 
                 const ModelStatus& newModelStatus);

  inline void setIterUsed(const int IterUsed) { IterUsed_ = IterUsed; }
  inline void setResUsed(const double ResUsed) { ResUsed_ = ResUsed; }
  inline void setNodesUsed(const int NodesUsed) { NodeUsed_ = NodesUsed; }
  inline void setObjVal(const double ObjVal) { ObjVal_ = ObjVal; }
  inline void setObjBound(const double ObjBound) { ObjBound_ = ObjBound; }
  inline double getObjVal() { return ObjVal_; }
  inline double getResUsed() { return ResUsed_; }

  inline int    *ColIndicator() { return ColIndicator_; }
  inline int    *RowIndicator() { return RowIndicator_; }

  void setSolution(const double *ColLevel=0, const double *ColMargin=0, 
                   const int *ColBasis=0, const int *ColIndicator=0,
                   const double *RowLevel=0, const double *RowMargin=0, 
                   const int *RowBasis=0, const int *RowIndicator=0);
  double getResLim();
  int    getIterLim(); // Iteration limit for model run
  int    getNodeLim();
  int    getGamsInteger(int nr);
  int    getGamsInteger(int intnr, int bitnr);
  double getOptCA();   
  double getOptCR();   
  double getCheat();   
  double getCutOff();
  bool getScaleOption();
  bool getPriorityOption();

        const char* getOptionfile();
//      inline bool haveNames() { return dict; }
        
private:
  int nCols_;  // # columns
  int nDCols_; // # discrete columns
  int nSOS1_;  // # SOS type 1
  int nSOS2_;  // # SOS type 2
  int nSemiCon_; // # semicontinuous or semicont. integer columns
  int nRows_;  // # rows
  int nNnz_;   // # non zeros

  double startTime_; // Start time

  double *ColLb_;   // lower bound for columns
  double *ColUb_;   // upper bound for columns
  bool   *ColDisc_; // indicator for discrete columns: discrete (true) or not (false)
  int    *SOSIndicator_;  // indicator for SOS of type 1 and 2
  bool   *ColSemiCon_;  // indicator for semicontinuous columns: semicon. (true) or not (false)
  double *ColLevel_; // values of column variables
  double *ColMargin_; // marginal values = duals
  int    *ColBasis_; // column basis status
  double *ColPriority_; // branching priority
  double *ColScale_; // scaling parameter
  int    *ColIndicator_; // indicator for feasibility

  char   *RowSense_; // sense of row
  double *RowRhs_;   // right hand side
  double *RowScale_; // scaling parameters
  double *RowLevel_; // values of rows = row activity
  double *RowMargin_; // marginal values = duals
  int    *RowBasis_; // Row basis status
  int    *RowIndicator_; // indicator for feasibility

  double ObjSense_; // objective sense 1=min, -1=max
  double *ObjCoef_;  // Dense objective function
  double  ObjRhs_;   // constant in objective function
  double  zCoef_;    // coefficient of objective variable
  double ObjScale_;  // scale value of objective variable
  int     isReform_; // reformulated objective function

  int    *matStart_;  // matrix start of column
  int    *matRowIdx_; // matrix row index
  double *matValue_;  // matrix values
 
  void Allocate();

  double ObjVal_;
  double ObjBound_;
  double ResUsed_;
  int    IterUsed_;
  int    DomUsed_;
  int    NodeUsed_;

  SolverStatus SolverStatus_;
  ModelStatus ModelStatus_;
};

#endif // __GAMSMODEL_HPP__