ilp_problem.h

#ifndef SCIL_ILP_PROBLEM_H
#define SCIL_ILP_PROBLEM_H

#include<tr1/tuple>
#include<map>
#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>
#include<scil/primal_heur.h>
#include<scil/implicator.h>

#include<vector>

//FIXME
#include<scil/row_constraint.h>

namespace SCIL {

class sym_constraint;
class subproblem;
class monomial;
class polynomial;
class pol_constraint;
class monomial_inst;
class bool_inst;
class QuadRef;
class mon_split_strategy;
class bool_split_strategy;
class boolfunction;

typedef std::tr1::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;
  std::list<sym_constraint*> sym_constraints;
  std::list<Coefficient> coeff_list;
  std::list<monomial> monomials;
  Optsense os;
  std::map<std::string, std::string> ConfMap;
  monomial_inst* monomialinstance;
  bool_inst* boolinstance;
  int nvars; 
  int nconss;
  bool objint;
  int numcon;
  bool spb;
  double pb;
  mon_split_strategy* mon_splitstrat;
  bool_split_strategy* bool_splitstrat;
  bool qr_on_separate;
  quadRefStatus qrType;
  std::list<boolfunction*> bf_list;
  std::list<boolfunction*> bf_toDelete;
  



  subproblem* myroot;

 public:
  primal_heuristic* primal_heur;
  implicator* implic;
  QuadRef* qr;
  virtual 
    ABA_SUB *firstSub();
  //FIXME
  //virtual int enumerationStrategy (const ABA_SUB *s1, const ABA_SUB *s2);
  

  ILP_Problem(Optsense optSense, bool price=false, int numcon=-1, const char* problemName = "none");

virtual 
    ~ILP_Problem();






  var add_binary_variable(double obj, Activation a=Static);

  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, quadRefStatus qrStatus=CHECK);

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

  row add_polynomial(polynomial p, bool update = true);
  row add_polynomial(monomial m, bool update = true);
  
  var add_boolfunction(boolfunction* bf, double c);

  void add_bool_constraint(std::list<boolfunction*>& bcl, bool_cons_type bct);

  void add_bool_constraint(boolfunction* bf, bool_cons_type bct);

  void add_sym_constraint(sym_constraint* c);

  void add_pol_constraint(pol_constraint c);

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

  void set_obj_coefficient(var v, double d);

  void set_primal_heuristic(primal_heuristic* P);
 
  void extendSolution(solution& S);

  void set_implicator(implicator* P);

  void set_monomial_split_strategy(mon_split_strategy* spst);

  void set_bool_split_strategy(bool_split_strategy* spst);

  void set_qr_on_separate(bool qr);

  void set_qrType(quadRefStatus qt);




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

  double get_obj_coefficient(var v) const;

  quadRefStatus get_qrType();

  bool get_qr_on_separate();



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

  void configuration(const std::string&, const std::string&);

  void read_configuration_file(const char*);



  void optimize();



  Optsense opt_sense() { return os;  };

  double get_solution(var v);

  double get_solution(row& r);

  solution get_solution();

  double get_optimum();
  

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

  void primal_bound(double b) {
     pb = b;
     spb = true;
  };

  bool 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);
      return true;
    }
    return false;
  };

 private:
  void updateBestSolution(solution&);

  void initializeOptimization();
  
  virtual void initializeParameters();
};

};

#endif

---