subproblem.h

#ifndef SCIL_SUBPROBLEM_H
#define SCIL_SUBPROBLEM_H

#include<abacus/sub.h>
#include<scil/global.h>
#include<abacus/lpsub.h>
#include<scil/row.h>
#include<scil/sym_constraint.h>

namespace SCIL {

class solution;
class var;
class sym_constraint;
class cons;
class cons_obj;
class ABA_Variable;
class ABA_Constraint;
class ILP_Problem;

#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) )
  

class subproblem : private ABA_SUB
{

 public: //TODO remake private
  friend class ABA_Variable;
  friend class ABA_Constraint;
  friend class ILP_Problem;

  int t;
  ILP_Problem & GM;
  bool initpricing;
  ABA_BUFFER < ABA_VARIABLE * >*newvarbuffer;
  std::list < sym_constraint * >sym_constraints;
  int updateLP;
  bool check_LP ();
  double prio;

 protected:
  virtual void fixByLogImp(ABA_BUFFER<int>& variable, ABA_BUFFER<ABA_FSVARSTAT*>& status);
  virtual void setByLogImp(ABA_BUFFER<int>& variable, ABA_BUFFER<ABA_FSVARSTAT*>& status);

 private:
  // Some typedefs for iteration
  typedef std::list <sym_constraint*>::iterator sym_constraint_iterator;
  typedef std::list <sym_constraint*>::const_iterator sym_constraint_constiterator;

 public:

  ABA_LPSUB* get_lp() {
     return lp();
  }

  ABA_BRANCHRULE* get_branch_rule() {
     return branchRule();
  }
  

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

  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, Validity v = Global);

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

  virtual
  cons _add_basic_constraint (cons_obj * c, Activation a = Dynamic, Validity v = Global);

  void add_sym_constraint (sym_constraint * c);

  void remove_variable (var V);

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




  Varstat get_varstat(var v);
  var get_var (int i);

  int nVar () const;

  double get_coeff (var v, cons i);

  int get_level() const {

     return level();
  }
  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;
  };

  // TODO: possibility to iteratoe over sym_constraints. Maybe via

  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);

  bool save_solution(solution& s);



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

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


  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 &); 

  virtual int improve (double&);

  double *MxVal ();

  virtual ABA_SUB * generateSon (ABA_BRANCHRULE * rule);

};

}
#endif

---