ilp_problem.cc

#include<LEDA/map.h>
#include<LEDA/list.h>
#include<scil/global.h>
#include<scil/var_obj.h>
#include<scil/cons_obj.h>
#include<scil/variable.h>
#include<scil/subproblem.h>
#include<scil/ilp_problem.h>
#include<scil/row.h>
#include<scil/sym_constraint.h>

#ifdef OSL
#include<ekk_c_api.h>
#endif
#ifdef CPLEX
#include<cplex.h>
#endif

const
string& ILP_Problem::configuration(const string& s) const {
  return ConfMap[s];
};

string& ILP_Problem::configuration(const string& s) {
  return ConfMap[s];
};

bool ILP_Problem::optimization_started() {
  return opt_started;
};

void ILP_Problem::read_configuration_file(string s) {
  ifstream ifs(s);

  string s1, s2;
  while(!ifs.eof()) {
    if(ifs.peek()=='#') s2.read_line(ifs); else {
      ifs >> s1;
      ifs >> s2;
      configuration(s1)=s2;
    }
  }
};


#ifdef OSL
ILP_Problem* global;
int test=0;

//void ekksslv(EKKModel * model, int reason,
//           double * objective_value ,  int * status);

int OSLLINKAGE_CB evnucallback(EKKModel* model) {

  global->SP->fixvar=-1;

  ekk_dualSimplex(model);
  
  for(int i=0; i<global->number_of_variables(); i++) {
    if(ekk_columnStatus(model,i)==0) global->SP->fixvar=i;
  };
  
  global->SP->mipModel=model;
    
  bool s=global->SP->feasible();
  if(s==false) {
    
    double * c=ekk_getColsol(model);
    global->SP->fixvalue=c[global->SP->fixvar];
    c[global->SP->fixvar]=0.9;
    //c[20]=0.1;
    ekk_setColsol(model,c);
    //global->iter++;

    return 0;
  } 

  cout<<"FEASIBLE SOLUTION\n";

  return 0;
}; /* ekkevnu */


int lpcallback(EKKModel * model, int reason, EKKIntegerPresolve *, 
               EKKCuts * cuts, int depth) {
  test++;
  if(test==1) {
    for(int i=0; i<global->number_of_variables(); i++) {
      if(ekk_columnStatus(model,i)==0) global->SP->fixvar=i;
    };
    double * c=ekk_getColsol(model);
    global->SP->fixvalue=c[global->SP->fixvar];

    c[global->SP->fixvar]=0.9;
 
    return 0;
  }

  cuts->numberCuts=0;
  cuts->maxCuts=100000;
  cuts->cut=new EKKCut[100000];

  if(reason!=0) return 0;
  global->iter++;
  global->SP->mipModel=model;
  global->SP->Cuts=cuts;

  global->SP->separate();

  return 0;
}

void test2(EKKModel * model, int reason, int * iarray,
           double * rarray, int * muser , int nuser) {
  cout<<"HIER\n";
};

void test3 (EKKModel * model, int * xadj,
            int * adjncy , int * perm , int * invp,
            int * mwork, int nwords, int nrow) {
  cout<<"ordu\n";
};

void test1(EKKModel * model, int reason,
           double * objective_value ,  int * status) {
  cout<<reason<<" reason\n";

  global->SP->fixvar=1;

  //ekk_dualSimplex(model);
  /* 
  for(int i=0; i<global->number_of_variables(); i++) {
    if(ekk_columnStatus(model,i)==0) global->SP->fixvar=i;
  };
  */
  global->SP->mipModel=model;
    
  cout<<global->SP->fixvar<<"modifiing\n";

  bool s=global->SP->feasible();
  if(s==false) {
    double * c=ekk_getColsol(model);
    global->SP->fixvalue=c[global->SP->fixvar];
    c[global->SP->fixvar]=0.9;
    //c[20]=0.1;
    ekk_setColsol(model,c);
    //global->iter++;
  };

  cout<<"treturning\n";
};
#endif

#ifdef CPLEX

mycutcallback (CPXENVptr env,
               void      *cbdata,
               int       wherefrom,
               void      *cbhandle,
               int       *useraction_p) {
{

  ILP_Problem * ILP;
  ILP = static_cast <ILP_Problem *> (cbhandle);
  
  
  int status = CPXgetcallbacknodex(env, cbdata, wherefrom, x, 0, NUMCOLS-1);

};
#endif 

ILP_Problem::ILP_Problem (Optsense optSense) {
  os = optSense;

  iter=0;
  global=this;
  opt_started=false;

  nvars=1;
  nconss=1;

  vararray.resize(0, 1000);

  SP=new subproblem(this);

#ifdef OSL
  env = ekk_initializeContext();
  mipModel=ekk_newModel(env,NULL);
  // Set line length to 100 characters
  int rtcod = ekk_setIlinelen(mipModel,100);
  
  // Set to print primal and dual solutions
  rtcod = ekk_setIprtinfomask(mipModel,63);
  
  // Set to print the column solutions only
  rtcod = ekk_setIsolmask(mipModel,6);
  
  // Set ItruCallBack usage frequency to 9999999     
  rtcod = ekk_setIiterufreq(mipModel,9999999);
  
  // Set to print the parameter values for the OSL functions
  //ekk_setPrinting(mipModel,1,1,0);

  // Set as problem type problem
  if(os==Optsense_Max)
    rtcod = ekk_setRmaxmin(mipModel, -1.000000);
  else
    rtcod = ekk_setRmaxmin(mipModel, 1.000000);

  //ekk_messagePrintOff(mipModel,100);
  //ekk_messagePrintOff(mipModel,95);
  //ekk_messagePrintOff(mipModel,87);
  //ekk_messagePrintOff(mipModel,6);
  //ekk_messagePrintOff(mipModel,102);
  //ekk_messagePrintOff(mipModel,34);
  
  ekk_messagePrintOff(mipModel,317);
  ekk_messagePrintOff(mipModel,324);
  ekk_messagePrintOff(mipModel,321);
  ekk_messagePrintOff(mipModel,323);
  ekk_messagePrintOff(mipModel,114);

  ekk_resizeModel(mipModel, 1, 1, 0);

  ekk_setPresolveOff(mipModel);

  ekk_registerCutuCallBack(mipModel, lpcallback);
  ekk_registerEvnuCallBack(mipModel, evnucallback);
  //ekk_registerSlvuCallBack(mipModel, test1);
  //ekk_registerNoduCallBack(mipModel, test2);
  //ekk_registerOrduCallBack(mipModel, test3);
#endif

#ifdef CPLEX
  env = CPXopenCPLEX (&status);
    
  if ( env == NULL ) 
    {
      char  errmsg[1024];
      fprintf (stderr, "Could not open CPLEX environment.\n");
      CPXgeterrorstring (env, status, errmsg);
      fprintf (stderr, "%s", errmsg);
        
      throw  CplexError();
    }
  
  status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_ON); 
  if ( status ) {
    fprintf (stderr, 
             "Failure to turn on screen indicator, error %d.\n", status);
      
    throw CplexError();
  }  
#endif
};



ILP_Problem::~ILP_Problem () {
};

var ILP_Problem::add_variable (double obj, double lBound, double uBound,
                               Vartype t, Activation a = Static)
{
  var_obj* v=new var_obj(obj, lBound, uBound, t);
  return add_variable(v);
};


var ILP_Problem::add_variable (var_obj * v, Activation a = Static)
{
  v->set_index(nvars);
  nvars++;

  ekk_addOneColumn(mipModel, v->obj(), v->lower_bound(), v->upper_bound(), 
                   v->non_zeros, v->columns, v->coeffs ); 
 
  if(v->type()==Vartype_Integer)
    ekk_markAsInteger( mipModel , nvars-1 ); 

  if(nvars==vararray.high()) vararray.resize(0, 2*vararray.high());
  vararray[nvars-1]=v;
  
  return v;
};

/*
void ILP_Problem::updateBestSolution (solution& Sol_)
{
  Sol=Sol_;
}
*/

cons
ILP_Problem::add_basic_constraint (cons_obj * c, Activation a = Static)
{
  nconss++;
  //ekk_resizeModel(mipModel, nconss, nvars, 1);
  c->init();
  ekk_addOneRow(mipModel , c->lower_bound() , c->upper_bound() , 
                c->non_zeros , c->rows , c->coeffs );
  conslist.append(c);
  return c;
};


cons ILP_Problem::add_basic_constraint(cons_sense s, double r, Activation a=Static) {
  /*{\Mop adds a primitive basic constraint to the root of the 
    BCP-tree. |s| specifies the sense (one of |Less|, |Equal|, or 
    |Greater|) and |r| the right-hand-side of the constraint.}*/
  cons_obj* I=new cons_obj(s, r);
  return add_basic_constraint(I, a);
}

void ILP_Problem::add_sym_constraint(sym_constraint* c) {
  /*{\Mop adds the symbolic constraint |c| to the model.}*/
  sym_constraints.append(c);
  c->init(*SP);
}

void ILP_Problem::set_coefficient(var v, cons i, double d) {
  /*{\Mop sets the coefficient for variable $v$ and ineqality $i$
    to $d$ in the LP-Matrix.}*/
  cout<<"TODO\n";
};

void ILP_Problem::set_primal_heuristic(primal_heuristic* P) { // 
  /*{\Mop adds a primal heuristic to the model.}*/
  primal_heur=P;
};

void ILP_Problem::optimize() {
  /*{\Mop Computes the optimal solution for the current model.}*/
  //ekk_exportModel(mipModel, "test.mps", 1, 1);

  Cuts=new EKKCuts;
  
  Cuts->numberCuts=0;
  Cuts->maxCuts=100000;
  Cuts->cut=new EKKCut[100000];

  Cuts->cut->lowerBound=0;
  Cuts->cut->upperBound=0;
  Cuts->cut->numberElements=0;
  Cuts->cut->variable=new int[1];
  Cuts->cut->variable[0]=0;
  Cuts->cut->coefficient=new double[1];
  Cuts->cut->coefficient[0]=0;

  opt_started=true;

  ekk_branchAndCut(mipModel, NULL, NULL, NULL, Cuts, 100000, 0);

  const double* d=ekk_colsol(mipModel);
  for(int i=0; i<nvars; i++) {
    if(d[i]>0.001) Sol.set_value(vararray[i], d[i]);
  };
};


double ILP_Problem::get_solution(var v) { 
  /*{\Mop returns the value of $v$ in the best found solution.}*/
  if(Sol.value(v)>0.5) return 1;
  return 0;
  //return Sol.value(v); 
}

double ILP_Problem::get_solution(row& r) {
  row_entry re;
  double d=0;
  forall(re, r) d+=re.coeff*get_solution(re.Var);
  return d;
};

---