subproblem.cc

#include<LEDA/list.h>
#include<scil/cons.h>
#include<scil/cons_obj.h>
#include<scil/var_obj.h>
#include<scil/subproblem.h>
#include<scil/sym_constraint.h>
#include<scil/ilp_problem.h>
#include<scil/primal_heur.h>
#include<scil/row.h>
#include<scil/solution.h>

void subproblem::add_sym_constraint (sym_constraint * c)
{
  cout<<"Warning: No local symbolic constaints allowed\n";
  sym_constraints.append (c);
}

subproblem::subproblem(ILP_Problem* IP_) : GM(*IP_) {
};

const
string& subproblem::configuration(const string& s) const {
  return GM.configuration(s);
};

string& subproblem::configuration(const string& s) {
  return GM.configuration(s);
};

void
subproblem::add_basic_constraint (cons_obj * c, Activation a = Static)
{
  if(!GM.optimization_started()) {
    GM.add_basic_constraint(c, a);
    return;
  };

  c->init();
  
  //if(Cuts->numberCuts==1) return;

  EKKCut Cut;
  Cut.lowerBound=c->lower_bound();
  Cut.upperBound=c->upper_bound();
  Cut.numberElements=c->non_zeros;
  Cut.variable=c->rows;
  Cut.coefficient=c->coeffs;
  Cut.cutsOffSolution = 1;
  Cut.localCut=0;
  Cut.doNotDelete= 1;
  Cut.dummy=1;
  Cut.extraInfo=28;
  Cuts->cut[Cuts->numberCuts]=Cut;
  Cuts->numberCuts++;
};

cons
subproblem::add_basic_constraint (cons_sense s, double rhs,
                                  Activation a = Static)
{
  cons_obj *
    c = new cons_obj (s, rhs);
  add_basic_constraint (c, a);
  return c;
};

var
subproblem::add_variable (double obj,
                          double lBound, double uBound,
                          Vartype t, Activation a = Static)
{
  if(a!=Static) 
    cout<<"Warning: No local variables allowed yet\n";
  return GM.add_variable(obj, lBound, uBound, t, a);
};

void
subproblem::add_variable (var_obj* v, Activation a = Static)
{
  if(a!=Static) 
    cout<<"Warning: No local variables allowed yet\n";
  GM.add_variable(v, a);
}

bool
subproblem::feasible () {

  solution SOL;

  double d;
  for(int i=0; i<GM.number_of_variables(); i++) {
    d=value(get_var(i));
    if(d>0.0001) {
      if(d<0.9999) return false;
      SOL.set_value(get_var(i),1);
    };
  };

  return feasible(*this, SOL);
}

bool
subproblem::feasible (subproblem & S, solution& Sol)
{

  sym_constraint * s;
  forall (s, GM.sym_constraints)
  {
    if (s->feasible (Sol) == sym_constraint::infeasible_solution)
      return false;
  }

  /*
  if (father () != 0)
    {
      if (!((subproblem *) father ())->feasible (S, Sol))
        return false;
    }
  */

  return true;
};

int
subproblem::separate ()
{

  // Cuts->numberCuts=0;
  //Cuts->maxCuts=100;
  //Cuts->cut=new EKKCut[100];

  return separate (*this);
};

int
subproblem::separate (subproblem & S)
{
  int t = 0;

  sym_constraint *
    s;
  forall (s, GM.sym_constraints)
  {
    if (s->separate (S) == sym_constraint::constraint_found)
      t++;
  };

  /*
  if (father () != 0)
    {
      t += ((subproblem *) father ())->separate (S);
    }
  */

  return t;
};

void subproblem::set_coefficient (var v, cons i, double d)
{
  /*{\Mop sets the coefficient for variable $v$ and basic constraint $i$
    to $d$ in the LP-Matrix.} */
  //TODO
};

var subproblem::get_var (int i)
{
  /*{\Mop {\bf better give the possibility to iterate over the variables!}} */
  return nil;
  //if(i>=nVar()) return nil;
  //return var (((ABA_Variable *) ABA_SUB::variable (i))->SVar ());
};

int subproblem::nVar () const
{
  /*{\Mop returns the number of active variables in the current node.} */
  return GM.number_of_variables();
};

cons subproblem::get_cons (int i)
{
  /*{\Mop {\bf better give the possibility to iterate over the basic
    constraints!}} */
  return nil;
  // return cons (((ABA_Constraint *) ABA_SUB::constraint (i))->Scons ());
};

int subproblem::ncons ()
{
  /*{\Mop returns the number of active basic constraints in the current 
    node.} */
  return 1; // TODO
};


double subproblem::value (var v)
{
  /*{\Mop returns the value of |v| of the last solved LP.} */
  if(v==nil) return 1;

  if(v.index()==fixvar) return fixvalue;

  return ekk_colsol(mipModel)[v.index()];
};

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

double subproblem::lower_bound (var v)
{
  /*{\Mop returns the lower bound of the variable in the current node.} */
  return 0; // TODO
}


double subproblem::upper_bound (var v)
{
  /*{\Mop returns the upper bound of the variable in the current node.} */
  return 0; //TODO
}

double subproblem::value (cons i, as_what as = as_is) {
  /*{\Mop returns the value of |i| of the last solved LP.} */
  if (i.cons_pointer () == nil)
    {
      cout << "nil basic constraint\n"; return 0;}
  double d = 0; //TODO
  if (as == as_is) return d;
  if ((as == as_max) && (GM.opt_sense () == Optsense_Max)) return d;
  if ((as == as_min) && (GM.opt_sense () == Optsense_Min)) return d;
  return -d;
}



int subproblem::separate (subproblem &); 

void subproblem::activate (subproblem & S)
{
  sym_constraint * s; 
  
  forall (s, sym_constraints) 
    {
      s->open_subproblem (S);
    }
}

void subproblem::activate ()
{
  activate (*this);
}; 


void subproblem::deactivate (subproblem & S)
{
  sym_constraint * s; 
  forall (s, sym_constraints)
    {
      s->close_subproblem (S);
    }; 
}; 


void subproblem::deactivate ()
{
  deactivate (*this);
  if (GM.primal_heur != nil)
    GM.primal_heur->heuristic (*this);
}; 

double subproblem::red_cost(var v) {
  /*{\Mop returns the value of |v| of the last solved LP.}*/
  return 0; // TODO lp()->reco(v.var_pointer()->index());
};

---