subproblem.cc

#include<scil/scil.h>
#include<scip/objscip.h>
#include"scip_constraint_handler.h"

namespace SCIL {

  subproblem::subproblem(ILP_Problem* ILP_) 
    : ILP(ILP_) {
    Subproblem_Data=((ILP_Problem_Data*) ILP->DATA)->scipp;
  };

  var subproblem::add_variable(double obj, double lBound, double uBound, Vartype vt, Activation a) {
    var_obj* vo=new var_obj(obj, lBound, uBound, vt);
    return add_variable(vo, a);
  }

  var subproblem::add_continous_variable(double obj, double lBound, double uBound, Activation a) {
    return add_variable(obj, lBound, uBound, Vartype_Float, a);
  };


  var subproblem::add_integer_variable(double obj, int lB, int uB, Activation a) {
    return add_variable(obj, lB, uB, Vartype_Integer, a);
  };
  
  var subproblem::add_binary_variable(double obj, Activation a) {
    return add_variable(obj, 0, 1, Vartype_Integer, a);
  };

  var subproblem::add_variable(var_obj* vo, Activation a) {
    CHECK_ABORT( SCIPcreateVar((SCIP*) Subproblem_Data, 
      &((Variable_Data*) vo->DATA)->varP, "x", 
      vo->lower_bound(), vo->upper_bound(), vo->obj(), 
      vo->type() == Vartype_Integer ? SCIP_VARTYPE_INTEGER : SCIP_VARTYPE_CONTINUOUS, 
      true, a == Static ? false : true, NULL, NULL, NULL, NULL) );
    CHECK_ABORT( SCIPaddVar((SCIP*) Subproblem_Data, ((Variable_Data*) vo->DATA)->varP) );
    ((ILP_Problem_Data*) ILP->DATA)->VM[SCIPvarGetProbindex(((Variable_Data*) vo->DATA)->varP)]=var(vo);
    return var(vo);
  }

  cons subproblem::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 subproblem::add_basic_constraint(cons_obj* co, Activation a) {
    CHECK_ABORT( SCIPcreateEmptyRow((SCIP*) Subproblem_Data, 
      &((Basic_Constraint_Data*) co->DATA)->rowp, "c", 
      co->sense() == Less ? -SCIPinfinity((SCIP*) Subproblem_Data) : co->rhs(), 
      co->sense() == Greater ? SCIPinfinity((SCIP*) Subproblem_Data) : co->rhs(), 
      true, false /* true for pricing */, a==Static ? false : true ));
    row r;
    co->non_zero_entries(r);
    row_entry re;
    forall(re, r) { // TODO kein NULLPOINTER!
      if(re.Var.var_pointer()!=NULL) {
        VAR* V=((Variable_Data*) re.Var.var_pointer()->DATA)->varP;
        CHECK_ABORT( SCIPaddVarToRow((SCIP*) Subproblem_Data, 
         ((Basic_Constraint_Data*) co->DATA)->rowp, V, re.Coeff) );
      };
    };
    CHECK_ABORT( SCIPaddCut((SCIP*) Subproblem_Data, 
      ((Basic_Constraint_Data*) co->DATA)->rowp, 
      a==Static ? SCIPinfinity((SCIP*) Subproblem_Data) : co->slack(*this)) );
    SCIPreleaseRow((SCIP*) Subproblem_Data, &((Basic_Constraint_Data*) co->DATA)->rowp);
    ((Basic_Constraint_Data*) co->DATA)->scipp=(SCIP*) Subproblem_Data;
    ((ILP_Problem_Data*) ILP->DATA)->CL.append(co);
    cons c(co);
    return c;
  };

  double subproblem::value(var v) {
    return SCIPgetVarSol((SCIP*) Subproblem_Data, ((Variable_Data*) v.var_pointer()->DATA)->varP);
  };

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

  double subproblem::value(cons c) {
    // TODO as_what. default?
    return SCIProwGetDualsol(((Basic_Constraint_Data*) c.cons_pointer()->DATA)->rowp);
  }

  bool subproblem::found_constraint() {
    return SCIPgetLPSolstat((SCIP*) Subproblem_Data)!=SCIP_LPSOLSTAT_OPTIMAL;
  };

  double subproblem::get_obj_value() {
    return SCIPgetLPObjval((SCIP*) Subproblem_Data);
  };

  subproblem::~subproblem() {
  };

  void subproblem::save_solution(solution& s) {
    SOL* sol;
    CHECK_ABORT( SCIPcreateSol((SCIP*) Subproblem_Data, &sol, NULL) );
    
    var v;
    forall_variables(v, *this) {
      CHECK_ABORT( SCIPsetSolVal((SCIP*) Subproblem_Data, sol, 
        ((Variable_Data*) v.var_pointer()->DATA)->varP, s.value(v)) );
    };

    Bool stored;
    CHECK_ABORT( SCIPaddSolFree((SCIP*) Subproblem_Data, &sol, &stored) );
  };

  void subproblem::add_sym_constraint(sym_constraint* c) {
    ((ILP_Problem_Data*) ILP->DATA)->sconshdlr->addCons((SCIP*) Subproblem_Data, c);
  };

  double subproblem::get_solution(var v) {
    SOL* sol=SCIPgetBestSol((SCIP*) Subproblem_Data);
    if(sol==NULL) return 0;
    return SCIPgetSolVal((SCIP*) Subproblem_Data, sol, ((Variable_Data*) v.var_pointer()->DATA)->varP);
  };

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

  subproblem::var_item subproblem::first_variable_item() {
    if(SCIPgetNOrigVars((SCIP*) Subproblem_Data)==0) return no_var;
    return 0;
  };

  subproblem::var_item subproblem::next_variable_item(subproblem::var_item vi) {
    if(vi>=SCIPgetNOrigVars((SCIP*) Subproblem_Data)-1) return no_var;
    return vi+1;
  };

  var subproblem::get_variable(subproblem::var_item vi) {
    return ((ILP_Problem_Data*) ILP->DATA)->VM[vi];
  };

  subproblem::sc_item subproblem::first_sym_constraint_item() {
    if(SCIPconshdlrGetNConss(((ILP_Problem_Data*) ILP->DATA)->conshdlr)==0) 
      return no_sym_cons;
    return 0;
  };

  subproblem::sc_item subproblem::next_sym_constraint_item(subproblem::sc_item si) {
    if(si>=SCIPconshdlrGetNConss(((ILP_Problem_Data*) ILP->DATA)->conshdlr)-1) 
      return no_sym_cons;
    return si+1;
  };

  sym_constraint* subproblem::get_sym_constraint(subproblem::sc_item si) {
    if(si==no_sym_cons) return NULL;
    CONSDATA* consdata;
    CONS* con;
    con=SCIPconshdlrGetConss(((ILP_Problem_Data*) ILP->DATA)->conshdlr)[si];
    consdata=SCIPconsGetData(con);
    return consdata->sc;
  };

  //TODO lower_bound, upper_bound, red_cost

  //TODO Configurations
};

---