boolfunction.h

#ifndef SCIL_BOOLFUNCTION
#define SCIL_BOOLFUNCTION

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

namespace SCIL {
  
   class boolfunction {
      
      friend class bool_inst;

      private:
         row rLinear;
         var v;
         boolfunction* left;
         boolfunction* right;
         boolOperator op;
         bool negated;
         std::string originalTerm;
         void remove_negation(bool root=true);
         void remove_xor_equ();

         inline void set_rLinear(row r) { rLinear = r;}

         inline void set_left(boolfunction* _left) { left = _left; }

         inline void set_right(boolfunction* _right) { right = _right; }

         inline void set_op(boolOperator _op) { op = _op; }


      public:
         boolfunction() : left(NULL), right(NULL), v(NULL), negated(false), rLinear(0) {};
         boolfunction(var _v, bool _negated = false)
            : left(NULL), right(NULL), v(_v), op(BASIC), negated(_negated), rLinear(0) { };

         boolfunction(var _v1, var _v2, boolOperator _op, bool _negated = false)
            : v(NULL), op(_op), negated(_negated), rLinear(0) {
            left = new boolfunction(_v1);
            right = new boolfunction(_v2);
         };

         boolfunction(boolfunction* _left, var _v2, boolOperator _op, bool _negated = false)
            : v(NULL), op(_op), negated(_negated), left(_left->copy()), rLinear(0) {
            right = new boolfunction(_v2);
         }

         boolfunction(var _v1, boolfunction* _right, boolOperator _op, bool _negated = false)
            : v(NULL), op(_op), negated(_negated), right(_right->copy()), rLinear(0) {
            left = new boolfunction(_v1);
         }

         boolfunction(boolfunction* _left, boolfunction* _right, boolOperator _op, bool _negated = false)
            : v(NULL), op(_op), negated(_negated), left(_left->copy()), right(_right->copy()), rLinear(0) { }; 

         ~boolfunction() {
            if(left!=NULL)
               delete left;
            if(right!=NULL)
               delete right;
         }

         boolfunction* copy();

         inline row get_rLinear() const { return rLinear; }

         inline boolfunction* get_left() const { return left; }

         inline boolfunction* get_right() const { return right; }
         
         inline var get_v() const { return v; }

         inline boolOperator get_op() const { return op; }

         inline bool is_negated() const { return negated; }

         inline void negate() { negated = !negated; }

         void add(boolOperator _op, var _v, bool negated = false);

         void add(var _v, boolOperator _op, bool negated = false);

         void add(boolfunction* _left, boolOperator _op, bool negated = false);

         void add(boolOperator _op, boolfunction* _right, bool negated = false);

         var& linearize(ILP_Problem& IP);

         void simplify();

         bool evaluate(solution& S);

         inline std::string get_originalTerm() {return originalTerm;}

         std::string toString();

         bool isHomogeneous(boolOperator _op = BASIC);

         std::vector<var> get_vars();


   };

   std::ostream& operator<<(std::ostream& o, const boolfunction* bf);

   bool bfcompare_less(const boolfunction* bf1, const boolfunction* bf2);

   bool bfcompare_equal(const boolfunction* bf1, const boolfunction* bf2);
};
#endif

---