corenode_base.hpp

Go to the documentation of this file.

#ifndef CORENODE_BASE_HPP
#define CORENODE_BASE_HPP


#include "flopc.hpp"

namespace FlopSmiEx {
using namespace flopc;
using namespace std;



class CoreNodeBase {
protected:

        static CoreNodeBase * p2activeNode;


        static double const * p2varValues;

        MP_expression objFuncNode; 
        MP_expression objFuncRec;  

public:
        CoreNodeBase(CoreNodeBase *p2pred, int nodeStage = -1)
        :  p2parent(p2pred), p2child(NULL), stage(nodeStage)
        {
                if (p2parent != NULL) {
                        assert (p2parent->p2child == NULL && "only one child per node in Core");
                        p2parent->p2child = this; // register with the parent
                }
                CoreNodeBase::p2activeNode = this; // point the static pointer to itself
        }

        virtual ~CoreNodeBase() {} 

        CoreNodeBase * p2parent; 
        CoreNodeBase * p2child;  
        int stage;               


        vector<VariableRef const *> all_variables; 
        vector<MP_constraint *> all_constraints;   
        vector<int> constr_row_offsets;            

        void set_var_values(double const *p2values) {
                p2varValues = p2values;
        }


        MP_expression & get_obj_func() {
                if (p2parent != NULL) {
                        cerr << "Warning: get_obj_func called from a non-root node!" << endl;
                }
                make_obj_func_rec();
                return objFuncRec;
        }

protected:

        class SP_variable : public MP_variable {
        private:
                CoreNodeBase * p2node; 
                int varIndx; 
        public:
                SP_variable(MP_set const &s1 = MP_set::getEmpty(),
                            MP_set const &s2 = MP_set::getEmpty())
                : MP_variable(s1, s2), p2node(CoreNodeBase::p2activeNode),
                        varIndx(static_cast<int>(p2node->all_variables.size()))
                {
                        #ifndef NDEBUG
                        cout << "Stage " << p2node->stage << ": adding SP_variable with "
                             << s1.size() * s2.size() << " element(s), starting at col "
                             << varIndx << endl;
                        #endif
                        for (int i1 = 0; i1 < s1.size(); i1++) {
                                for (int i2 = 0; i2 < s2.size(); i2++) {
                                        p2node->all_variables.push_back(& this->operator()(i1,i2));
                                }
                        }
                }


                double value(int const i1 = 0, int const i2 = 0) const {
                        assert (CoreNodeBase::p2varValues != NULL
                                && "variable values must be set before they are accessed!");
                        return CoreNodeBase::p2varValues[varIndx + f(i1, i2)];
                }
        };


        class SP_constraint : public MP_constraint {
        private:
                CoreNodeBase * p2node; 
                int constrIndx;
        public:
                SP_constraint (MP_set const &s1 = MP_set::getEmpty())
                : MP_constraint(s1), p2node(CoreNodeBase::p2activeNode),
                  constrIndx(static_cast<int>(p2node->all_constraints.size()))
                {
                        #ifndef NDEBUG
                        cout << "Stage " << p2node->stage << ": adding SP_constr.  with "
                             << s1.size() << " element(s), starting at row " << constrIndx
                             << endl;
                        #endif
                        for (int i1 = 0; i1 < s1.size(); i1++) {
                                p2node->all_constraints.push_back(this);
                                p2node->constr_row_offsets.push_back(i1);
                        }
                }
        };


        void make_obj_func_rec();
};


} // namespace FlopSmiEx
#endif