ilp_problem.h

#ifndef SCIL_ILP_PROBLEM_H
#define SCIL_ILP_PROBLEM_H

#include<LEDA/tuple.h>
#include<LEDA/list.h>
#include<LEDA/map.h>
#include<LEDA/d_array.h>
#include<abacus/master.h>
#include<abacus/sub.h>
#include<abacus/row.h>
#include<abacus/conbranchrule.h>
#include<abacus/column.h>

#include<scil/cons.h>
#include<scil/variable.h>
#include<scil/solution.h>

namespace SCIL {

class primal_heuristic;
class sym_constraint;
class subproblem;

typedef LEDA::three_tuple<var, cons, double> Coefficient;

class ILP_Problem : public ABA_MASTER // TODO make private
{
  friend class subproblem;
  friend class ABA_Constraint;
  friend class ABA_Variable;
  
private:
  solution Sol;
  int lpsolverset;
  LEDA::list<sym_constraint*> sym_constraints;
  LEDA::list<Coefficient> coeff_list;
  Optsense os;
  LEDA::d_array<LEDA::string, LEDA::string> ConfMap;
  int nvars; 
  int nconss;

  subproblem* myroot;

 public:
  

  ILP_Problem(Optsense optSense, bool price=false);

  virtual 
    ~ILP_Problem();

  virtual 
    ABA_SUB *firstSub();

  primal_heuristic* primal_heur;

  void ChangeToCompiledLpSolver() {
#ifdef ABACUS_LP_SOPLEX
    lpsolverset=ABA_MASTER::Soplex;
#endif
#ifdef ABACUS_LP_CPLEX
    lpsolverset=ABA_MASTER::Cplex;
#endif
  };


  var add_variable(double obj, double lBound, double uBound, Vartype vt,
                   Activation a=Static);

  cons add_basic_constraint(cons_sense s, double r, Activation a=Static);

  cons add_basic_constraint(cons_obj* c, Activation a=Static);

  var add_variable(var_obj* v, Activation a=Static);

  void add_sym_constraint(sym_constraint* c);

  void set_coefficient(var v, cons i, double d);

  void set_primal_heuristic(primal_heuristic* P);



  int number_of_variables() {
    return nvars;
  }
  
  int number_of_constraints() {
    return nconss;
  }



  const
  LEDA::string& configuration(const LEDA::string&) const;

  LEDA::string& configuration(const LEDA::string&);

  void read_configuration_file(LEDA::string);



  void optimize();



  Optsense opt_sense() { return os;  };

  double get_solution(var v);

  double get_solution(row& r);
  

  void set_silent() {
    outLevel(ILP_Problem::Silent);
  };

  void save_solution(solution& S) {
    var v;
    double obj=0;
    forall_variables(v, *myroot) {
      obj+=S.value(v)*v.obj();
     };
 
    if(betterPrimal(obj)) {
      updateBestSolution(S);
      primalBound(obj);
    }
  };

 private:
  void updateBestSolution(solution&);

  void initialize_Optimization();
  
  virtual void initializeParameters();

};

}

#endif

---