subproblem.h

#ifndef SCIL_SUBPROBLEM_H
#define SCIL_SUBPROBLEM_H

#include<LEDA/list.h>
#include<LEDA/string.h>
#include<abacus/sub.h>
#include<scil/global.h>
//#include<abacus/sub.h>
#include<scil/row.h>
#include<scil/sym_constraint.h>

namespace SCIL {

class solution;
class var;
class sym_constraint;
class cons;
class cons_obj;

#define forall_variables(x,S)\
for(int loop_var = (S).first_variable_item();\
x=(S).get_var(loop_var), x != nil; \
loop_var=(S).next_variable_item(loop_var) )

#define forall_basic_constraints(x,S)\
for(int loop_var = (S).first_constraint_item();\
x=(S).get_cons(loop_var), x != nil; \
loop_var=(S).next_constraint_item(loop_var) )

#define forall_sym_constraints(x,S)\
for(LEDA::list_item loop_var = (S).first_sym_constraint_item();\
x=(S).get_sym_cons(loop_var), x != nil; \
loop_var=(S).next_sym_constraint_item(loop_var) )
  

class subproblem : private ABA_SUB
{
  friend class ABA_Variable;
  friend class ABA_Constraint;
  friend class ILP_Problem;

 public: //TODO remake private
  int t;
  ILP_Problem & GM;
  bool initpricing;
  ABA_BUFFER < ABA_VARIABLE * >*newvarbuffer;
  LEDA::list < sym_constraint * >sym_constraints;
  int updateLP;
  bool check_LP ();

 public:
  

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

  void add_variable (var, Activation a = Static);

  virtual
  cons add_basic_constraint (cons_sense, double, Activation a = Dynamic);

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

  void add_sym_constraint (sym_constraint * c);

  void remove_variable (var V);

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



  var get_var (int i);

  int nVar () const;

  double get_coeff (var v, cons i);

  int first_variable_item() const { 
    return 0; }

  int next_variable_item(int i) const {
    return i+1;
  };

  int first_constraint_item() const { 
    return 0; }

  int next_constraint_item(int i) const {
    return i+1;
  };

  LEDA::list_item first_sym_constraint_item() const;

  LEDA::list_item next_sym_constraint_item(LEDA::list_item i) const;

  sym_constraint* get_sym_cons(LEDA::list_item i);

  cons get_cons (int i);

  int found_constraint() {
    return t>0;
  };

  int ncons ();

  virtual
  double value (var v);

  double value(row& r);

  double lower_bound (var v);

  double upper_bound (var v);

  double value (cons i, as_what as = as_is);

  double red_cost(var v);

  void save_solution(solution& s);



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

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


  subproblem(ABA_MASTER * master);

  subproblem(ABA_MASTER * master, ABA_SUB * father, ABA_BRANCHRULE * branchRule);

  virtual ~ subproblem ();

  virtual bool feasible ();

  virtual bool feasible (subproblem &, solution&);

  void update_indices (); 

  virtual int separate ();
  
  virtual int separate (subproblem &); 

  void activate (subproblem & S);

  void activate ();

  void deactivate (subproblem & S);

  void deactivate ();

  double myvalue (int i);

  virtual int pricing ();

  virtual int pricing (subproblem &);

  virtual int mf_pricing (subproblem &); 

  double *MxVal ();

  virtual ABA_SUB * generateSon (ABA_BRANCHRULE * rule);

};

}
#endif

---