global.h

#ifndef SCIL_GLOBAL_H
#define SCIL_GLOBAL_H
//FIXME
#include <iostream>

class ABA_VARIABLE;
class ABA_CONSTRAINT;

namespace SCIL {
   class var;
   class column_entry;
   class row_entry;
   class cons;
   class row;
   class monomial;
   class pol_entry;

typedef int var_item;
#define UNDEFINED_VARIABLE -1
#define minimal_size 1000
#define foreach(it,S) for( (it)=(S).begin();(it)!=(S).end();(it)++ )
#define forall_vertices(v,v_end,G) for(tie((v),(v_end))=vertices((G)); (v)!=(v_end); ++(v))

enum Activation     { Dynamic, Static };
enum Validity       { Global, Local };
enum Liftability    { Liftable, Nonliftable };
enum Vartype        { Vartype_Integer, Vartype_Float, Vartype_Binary };
enum Optsense       { Optsense_Min, Optsense_Max};
enum cons_sense     { Equal, Less, Greater };
enum Opt_Inequality { Static_Inequalities, Dynamic_Inequalities };
enum Opt_Variables  { Static_Variables, Dynamic_Variables };
enum Branching_Type { Inequality_Branching, Set_Variable_Branching, 
                      Variable_Bounds_Branching };
enum Varstat        { Free, SetToLowerBound, Set, SetToUpperBound,
                      FixedToLowerBound, Fixed, FixedToUpperBound };

enum as_what { as_is, as_min, as_max };

enum quadRefStatus { NONE, CHECK, SQK2, SQK3, SQK2_SQK3 };
enum bool_cons_type { C0, C1, CS, CE };
enum boolOperator {
      BASIC, // basic variable
      AND,   // conjunction
      NAND,  // non-conjunction
      OR,    // disjunction
      NOR,   // non-disjunction
      XOR,   // exclusive disjunction
      EQU,   // equivalence
      IMP,   // implication
      NIMP,  // non-implication
      PMI,   // inverse implication
      PMIN   // inverse non-implication  
   };


void debug_out(const char* outp, int paramnum = 0, ...);

// compare functions
/* These functions are used to determine a linear order of custom data types.
 */
int compare(const SCIL::row& r1, const SCIL::row& r2);
int compare(const SCIL::row_entry& t1, const SCIL::row_entry& t2);
int compare(const SCIL::var& v1, const SCIL::var& v2);
int compare(SCIL::var& v1, const SCIL::var& v2);
int compare(const SCIL::cons& v1, const SCIL::cons& v2);

std::istream& operator>>(std::istream& in, SCIL::var& b);
}

template<class A, class B>
class ABA_ACTIVE;
typedef ABA_ACTIVE<ABA_VARIABLE, ABA_CONSTRAINT> Active_Variables;
typedef ABA_ACTIVE<ABA_CONSTRAINT, ABA_VARIABLE> Active_Inequalities;

class ABA_ROW;
typedef ABA_ROW Row;
class ABA_COLUMN;
typedef ABA_COLUMN Column;

#endif

---