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/aba_variable.h>
#include<scil/aba_constraint.h>
#include<scil/subproblem.h>
#include<scil/ilp_problem.h>
#include<scil/row.h>

using namespace SCIL;

ABA_SUB* ILP_Problem::firstSub() {
  if(lpsolverset!=-1) defaultLpSolver((LPSOLVER) lpsolverset);

  myroot=new subproblem(this);

  Coefficient co;
  forall(co, coeff_list) {
    myroot->set_coefficient(co.first(), co.second(), co.third());
  }

  sym_constraint* c;
  forall(c, sym_constraints) {
    myroot->add_sym_constraint(c);
  }

  return myroot;
};

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

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

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

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


ILP_Problem::ILP_Problem (Optsense optSense, bool price) : 
  ABA_MASTER ("none", true, price, (optSense == Optsense_Min ? ABA_OPTSENSE::Min : 
                                   ABA_OPTSENSE::Max))
{
  os = optSense;
  ChangeToCompiledLpSolver ();
  ABA_BUFFER < ABA_VARIABLE * >variables (this, 0);
  ABA_BUFFER < ABA_CONSTRAINT * >temp (this, 0);
  ABA_BUFFER < ABA_CONSTRAINT * >constraints (this, 0);
  initializePools (constraints, temp, variables, 
                   minimal_size, minimal_size, true);
  conPool ()->increase (minimal_size);
  cutPool ()->increase (minimal_size);
  nvars = 0;
  nconss = 0;
  primal_heur = 0;
};



ILP_Problem::~ILP_Problem () {
};


void ILP_Problem::initialize_Optimization ()
{};


void ILP_Problem::initializeParameters ()
{
  //if(exists(".abacus")) {
    readParameters (".abacus");
    //}
};

var ILP_Problem::add_variable (double obj, double lBound, double uBound,
                               Vartype t, Activation a)
{
  ABA_VARTYPE::TYPE type = ABA_VARTYPE::Continuous;
  if (t == Vartype_Integer)
    {
      if ((lBound == 0) && (uBound == 1))
        type = ABA_VARTYPE::Binary;
      else
        type = ABA_VARTYPE::Integer;
    }
  if (nvars == varPool ()->size ())
    varPool ()->increase (2 * nvars);
  
  var_obj * v = new var_obj (obj, lBound, uBound, t);
  return add_variable (v, a);
};


var ILP_Problem::add_variable (var_obj * v, Activation a)
{
  v->init (*this, nvars, a);
  varPool ()->insert (v->AVar ());
  nvars++;
  return v;
};

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

cons
ILP_Problem::add_basic_constraint (cons_obj * c, Activation a)
{
  c->init (*this, nconss, a);
  nconss++;
  if (conPool ()->number () == conPool ()->size ())
    conPool ()->increase (2 * conPool ()->size ());
  conPool ()->insert (c->Acons ());
  return c;
};


cons ILP_Problem::add_basic_constraint(cons_sense s, double r, Activation a) {
  /*{\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();
    I->set_sense(s);
    I->set_rhs(r);
    add_basic_constraint(I, a);
    return I;
}

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

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.}*/
  coeff_list.append(Coefficient(v,i,d));
};

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.}*/
  ABA_MASTER::optimize();
};


double ILP_Problem::get_solution(var v) { 
  /*{\Mop returns the value of $v$ in the best found solution.}*/
  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;
};

---