qelement.h

#ifndef QELEMENT_H
#define QELEMENT_H

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/adjacency_matrix.hpp>
#include <boost/graph/graph_traits.hpp>
#include <scil/core/monomial.h>
#include <scil/core/boolfunction.h>

namespace SCIL {

using namespace boost;

template <typename Graph>
class qelement {
      
      protected:
         
         typedef graph_traits<Graph> GraphTraits;
         typedef typename GraphTraits::vertex_descriptor vertex_descriptor;
         typedef typename GraphTraits::edge_descriptor edge_descriptor;



         void checkGraphConcepts() {
            //Graph has to provide the vertex_descriptor type
            BOOST_CONCEPT_ASSERT((GraphConcept<Graph>));
         }

         qelement<Graph>* l; //a pointer to the left part of the quadratic decomposition
         qelement<Graph>* r; //a pointer to the right part of the quadratic decomposition
                       //for singletons l and r are  NULL and basic is true
         bool maximal; //true if the element is maximal in the decomposition
                       //i.e. it is not part of a decomposition
         bool basic;   //true if the qelement belongs to a basic variable
         qelement<Graph>* in_SG;
         vertex_descriptor sg_node; //the corresponding node in the separation graph

      public:


         //set the maximal flag to false
         //this means that this qelement is part of a decomposition
         void setNotMaximal() {
            maximal = false;
            return;
         }

         //return the left part of the decomposition
         qelement<Graph>* getLeft() const {
            return l;
         }

         //return the right part of the decomposition
         qelement<Graph>* getRight() const {
            return r;
         }

         //set the left part of the decomposition
         void setLeft(qelement<Graph>* li) {
            l = li;
            return;
         }

         //set the right part of the decomposition
         void setRight(qelement<Graph>* ri) {
            r = ri;
            return;
         }

         void set_in_separation_graph(qelement<Graph>* bfsg){
            in_SG = bfsg;
         }

         qelement<Graph>* in_separation_graph(){
            return in_SG;
         }

         //return true if qelement is maximal, else false
         bool isMaximal() const {
            return maximal;
         }

         //return true if qelement belongs to a basic variables, else false
         bool isBasic() {
            return basic;
         }

         //return the node in the separation graph
         vertex_descriptor  getSGNode() {
            return sg_node;
         }

         //set the node in the separation graph
         void setSGNode(vertex_descriptor  v) {
            sg_node = v;
            return;
         }

         qelement(){
            in_SG = NULL;
         }

         virtual row get_linVar() {};
         virtual monomial* getMonomial() const {};
         virtual boolfunction* getBoolfunction() const {};


         //the linear transformations
         virtual row trans() {};
         virtual row transLeft() {};
         virtual row transRight() {};

         //add the constraints coupling the element to its decomposition
         virtual void linearize(ILP_Problem& IP){};

         //output the variables making up the element (if NONLINEAR_INST_DEBUG)
         virtual void printName(){};
   };

}
#endif

---