ilp_problem.cc

#include<scil/scil.h>

#include<scip/objscip.h>
extern"C" {
#include<scip/scipdefplugins.h>
#include<scip/cons_linear.h>
}

#include"scip_constraint_handler.h"
#include<LEDA/list.h>

using namespace scip;

namespace SCIL {

  ILP_Problem::ILP_Problem(Optsense sense) {
    DATA=new ILP_Problem_Data;

    CHECK_ABORT( SCIPcreate(&((ILP_Problem_Data*) DATA)->scipp) );
    ((ILP_Problem_Data*) DATA)->MYSub=
      new subproblem(this);
    ((ILP_Problem_Data*) DATA)->sconshdlr=
      new SCIPConsHandler(((ILP_Problem_Data*) DATA)->MYSub);

    CHECK_ABORT( SCIPincludeDefaultPlugins(((ILP_Problem_Data*) DATA)->scipp) );

    CHECK_ABORT( SCIPincludeObjConshdlr(((ILP_Problem_Data*) DATA)->scipp, ((ILP_Problem_Data*) DATA)->sconshdlr, true) );
    ((ILP_Problem_Data*) DATA)->conshdlr=
      SCIPfindConshdlr(((ILP_Problem_Data*) DATA)->scipp, "CH");
    assert(conshdlr!=NULL);
    CHECK_ABORT( SCIPcreateProb(((ILP_Problem_Data*) DATA)->scipp, "bla", NULL, NULL, NULL, NULL, NULL, (PROBDATA*) this) );
  };

  ILP_Problem::~ILP_Problem() {
    /*
      CHECK_ABORT( SCIPfreeSolve(((ILP_Problem_Data*) DATA)->scipp) );

      var v;
      LEDA::list<var> L;
      forall_variables(v, *((ILP_Problem_Data*) DATA)->MYSub) L.append(v);
      forall(v, L) {
      SCIPreleaseVar(((ILP_Problem_Data*) DATA)->scipp, &v.var_pointer()->varP); 
      delete v.var_pointer();  
      };
    */

    cons c;
    forall(c, ((ILP_Problem_Data*) DATA)->CL) {
      delete c.cons_pointer();
    };

    CHECK_ABORT( SCIPfree(&((ILP_Problem_Data*) DATA)->scipp) );

    //delete ((ILP_Problem_Data*) DATA)->sconshdlr;
    delete ((ILP_Problem_Data*) DATA)->MYSub;
    delete (ILP_Problem_Data*) DATA;
  }

  var ILP_Problem::add_variable(double obj, double lBound, double uBound, Vartype t, Activation a) {
    return ((ILP_Problem_Data*) DATA)->MYSub->add_variable(obj, lBound, uBound, t, a);
  };

  var ILP_Problem::add_variable(var_obj* v, Activation a) {
    return ((ILP_Problem_Data*) DATA)->MYSub->add_variable(v, a);
  };

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


  cons ILP_Problem::add_basic_constraint(cons_obj* co, Activation a) {
    //CHECK_ABORT( SCIPcreateEmptyRow(scipp, &co->rowp, "c", co->sense() == Less ? -SCIPinfinity(scipp) : co->rhs(), co->sense() == Greater ? SCIPinfinity(scipp) : co->rhs(), true, false /* true for pricing */, a==Static ? false : true ));
    row r;
    co->non_zero_entries(r);
    row_entry re;
    double CS[r.size()];
    VAR* VS[r.size()];
    int i=0;
    forall(re, r) { // TODO kein NULLPOINTER!
      if(re.Var.var_pointer()!=NULL) {
        VS[i]=((Variable_Data*) re.Var.var_pointer()->DATA)->varP;
        CS[i]=re.Coeff;
        i++;
      };
    };
    CONS* C; //TODO
    CHECK_ABORT( 
      SCIPcreateConsLinear(
        ((ILP_Problem_Data*) DATA)->scipp, &C, "C", r.size(), VS, CS, 
        co->sense() == Less ? -SCIPinfinity(((ILP_Problem_Data*) DATA)->scipp) : co->rhs(), 
        co->sense() == Greater ? SCIPinfinity(((ILP_Problem_Data*) DATA)->scipp) : co->rhs(),
         TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
    CHECK_ABORT( SCIPaddCons(((ILP_Problem_Data*) DATA)->scipp, C) );
    CHECK_ABORT( SCIPreleaseCons(((ILP_Problem_Data*) DATA)->scipp, &C) );
    ((Basic_Constraint_Data*) co->DATA)->scipp=
      ((ILP_Problem_Data*) DATA)->scipp;
    ((ILP_Problem_Data*) DATA)->CL.append(co);
    cons c(co);
    return c;
  };


  void ILP_Problem::add_sym_constraint(sym_constraint* c) {
    ((ILP_Problem_Data*) DATA)->MYSub->add_sym_constraint(c);
  };

  void ILP_Problem::save_solution(solution& s) { 
    ((ILP_Problem_Data*) DATA)->MYSub->save_solution(s);
  };

  double ILP_Problem::get_solution (var v) {
    return ((ILP_Problem_Data*) DATA)->MYSub->get_solution(v);
  };

  double ILP_Problem::get_solution (row& r) {
    return ((ILP_Problem_Data*) DATA)->MYSub->get_solution(r);
  };
  
  void ILP_Problem::optimize() {
    CHECK_ABORT( SCIPsolve(((ILP_Problem_Data*) DATA)->scipp) );
  };

  double cons_obj::slack(subproblem& s) {
    row r;
    non_zero_entries(r);
    row_entry re;
    double d=rhs();
    forall(re,r) {
      d-=re.Coeff*s.value(re.Var);
    };
    if(sense()==Equal) return fabs(d);
    if(sense()==Less) return -d;
    return d;
  };

bool var::operator== (const var& v) const {
  return compare(*this, v)==0;
}

row var::operator+ (const row& r) const {
  return row(*this)+r;
}

row var::operator- (const row& r) const {
  return row(*this)-r;
}

row var::operator* (double d) const {
  return row(*this)*d;
}

bool var::operator!= (const var& v) const {
  return compare(*this,v)!=0;
}

bool var::operator< (const var& v) const {
  return compare(*this,v)<0;
}
bool var::operator> (const var& v) const {
  return compare(*this,v)>0;
}

bool var::operator<= (const var& v) const {
  return compare(*this,v)<=0;
}

bool var::operator>= (const var& v) const {
  return compare(*this,v)>=0;
}

int SCIL::compare(const var& t1, const var& t2) {
  if((void*) t1.var_pointer()>(void*) t2.var_pointer()) return 1;
  if((void*) t1.var_pointer()<(void*) t2.var_pointer()) return -1;
  return 0;
}

row SCIL::operator* (double d, var v) {
  return row(v)*d;
}

} // END NAMESPACE

int SCIL::Hash(var v) { 
  return LEDA::Hash(v.var_pointer()); 
}

int SCIL::ID_Number(const var & v) {
  return LEDA::ID_Number(v.var_pointer());
}

---