GamsBCH.hpp

Go to the documentation of this file.

// Copyright (C) GAMS Development 2007-2008
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: GamsBCH.hpp 510 2008-08-16 19:31:27Z stefan $
//
// Author: Stefan Vigerske

#ifndef GAMSBCH_HPP_
#define GAMSBCH_HPP_

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

#include <vector>

#include "GamsHandler.hpp"
#include "GamsOptions.hpp"
#include "GamsDictionary.hpp"

class GamsBCH {
public:
        class Cut {
        public:
                double lb;
                double ub;
                int nnz;
                int* indices;
                double* coeff;
                
                Cut();
                ~Cut();
        };
        
private:
        GamsHandler& gams;

        struct dictRec* dict;
        
        /* storage of size iolib.ncols for node relaxation solution */
  double    *node_x;
        /* storage of size iolib.ncols for node lower bound */
  double    *node_lb;
        /* storage of size iolib.ncols for node upper bound */
  double    *node_ub;

  bool      have_incumbent;
  bool      new_incumbent;
  double    incumbent_value; /* objective function value of incumbent */
        /* storage of size iolib.ncols for incumbent solution */
  double    *incumbent;
        /* storage of size iolib.ncols for global lower bounds */
  double    *global_lb;
        /* storage of size iolib.ncols for global upper bounds */
  double    *global_ub;
  
  bool       userkeep;       /* indicator for running gamskeep */

  int       heurfreq;       /* heuristic frequency */
  int       heurinterval;
  int       heurmult;
  int       heurfirst;      /* heuristic at first nodes */
  bool      heurnewint;     /* heuristic if new incumbent */
  int       heurobjfirst;   /* heurisitc at first nodes if node obj is good */
  char      heurcall[1024];      /* command line minus gams for the heuristic */

  char      cutcall[1024];       /* command line minus gams for the cut generation */
  int       cutfreq;        /* cut frequency */
  int       cutinterval;
  int       cutmult;
  int       cutfirst;       /* cuts at first nodes */
  bool      cutnewint;      /* cuts if new incumbent */

  char      incbcall[1024];      /* command line minus gams for the incumbent checking callback */
  char      incbicall[1024];     /* command line minus gams for the incumbent reporting callback */

  char      userjobid[1024];     /* jobid added to gdxname, gdxnameinc, usergdxin, adds --userjobid to the calls and o and lf */

  char      gdxname[1024];       /* GDX file name for solution read by the GAMS models */
  char      gdxnameinc[1024];    /* GDX file name for incumbent read by the GAMS models */
  char      usergdxin[1024];     /* GDX file name for reading stuff back */
        
        int       ncalls; /* number of BCH calls performed */
        int       ncuts;  /* number of cuts received */
        int       nsols;  /* number of primal solutions received */
        
        int       loglevel; /* amount of output printed by GamsBCH class */

        void init();
        
        int reportIncumbent();
public:
        GamsBCH(GamsHandler& gams_, GamsDictionary& gamsdict, GamsOptions& opt);
        GamsBCH(GamsHandler& gams_, GamsDictionary& gamsdict);
        
        ~GamsBCH();
        
        void setupParameters(GamsOptions& opt);

        void set_userjobid(const char* userjobid);
        void set_usergdxname(const char* usergdxname, const char* usergdxprefix = NULL);
        void set_usergdxnameinc(const char* usergdxnameinc, const char* usergdxprefix = NULL);
        void set_usergdxin(const char* usergdxin_, const char* usergdxprefix = NULL);
        void set_userkeep(bool userkeep_) { userkeep = userkeep_; }

        void set_usercutcall(const char* usercutcall);
        void set_usercutfreq(int usercutfreq) { cutfreq=usercutfreq; }
        void set_usercutinterval(int usercutinterval) { cutinterval=usercutinterval; }
        void set_usercutmult(int usercutmult) { cutmult=usercutmult; }
        void set_usercutfirst(int usercutfirst) { cutfirst=usercutfirst; }
        void set_usercutnewint(bool usercutnewint) { cutnewint=usercutnewint; }

        void set_userheurcall(const char* userheurcall);
        void set_userheurfreq(int userheurfreq) { heurfreq=userheurfreq; }
        void set_userheurinterval(int userheurinterval) { heurinterval=userheurinterval; }
        void set_userheurmult(int userheurmult) { heurmult=userheurmult; }
        void set_userheurfirst(int userheurfirst) { heurfirst=userheurfirst; }
        void set_userheurnewint(bool userheurnewint) { heurnewint=userheurnewint; }
        void set_userheurobjfirst(int userheurobjfirst) { heurobjfirst=userheurobjfirst; }
        
        void set_userincbcall(const char* userincbcall);
        void set_userincbicall(const char* userincbicall);

        const char* get_usercutcall() { return cutcall; }
        bool get_usercutnewint() const { return cutnewint; }

        const char* get_userheurcall() { return heurcall; }
        bool get_userheurnewint() const { return heurnewint; }
        
        void setLogLevel(int loglevel_) { loglevel=loglevel_; }
        
        int getNumCalls() const { return ncalls; }
        int getNumCuts() const { return ncuts; }
        int getNumSols() const { return nsols; }
        
        int getNumCols() const { return gams.getColCount(); }

        void printParameters() const;
        
        void setGlobalBounds(const double* lb_, const double* ub_);

        void setNodeSolution(const double* x_, double objval_, const double* lb_, const double* ub_);

        bool setIncumbentSolution(const double* x_, double objval_);
        
        bool doCuts();
        
        bool generateCuts(std::vector<Cut>& cuts);
        
        bool doHeuristic(double bestbnd, double curobj);

        bool runHeuristic(double* x, double& objvalue);
};

#endif /*GAMSBCH_HPP_*/