MP_domain.hpp

Go to the documentation of this file.

// ******************** FlopCpp **********************************************
// File: MP_domain.hpp
// $Id$
// Author: Tim Helge Hultberg (thh@mat.ua.pt)
// Copyright (C) 2003 Tim Helge Hultberg
// All Rights Reserved.
// ****************************************************************************
#ifndef _MP_domain_hpp_
#define _MP_domain_hpp_

#include <vector>
#include <map>
#include "MP_utilities.hpp"
#include "MP_boolean.hpp" 
#include "MP_index.hpp" 

namespace flopc {

class MP_set_base;
class MP_set;
class MP_index;

template<int nbr> class MP_subset;

class MP_domain_base : public Functor, public MP_index_base {
    friend class MP_domain;
    friend class Handle<MP_domain_base*>;
    friend MP_domain operator*(const MP_domain& a, const MP_domain& b);
private:
    int count;
public:
    MP_domain_base();
        virtual ~MP_domain_base();

    virtual Functor* makeInsertFunctor() const;
    virtual MP_index* getIndex() const = 0;
    virtual const MP_set_base* getSet() const = 0;
    void display()const;
    virtual size_t size() const ;
    const Functor* donext;
};

class MP_domain : public Handle<MP_domain_base*> {
    friend MP_domain operator*(const MP_domain& a, const MP_domain& b);
    
    friend class MP_constraint;
    friend class MP_index_exp;
public:
    MP_domain();
        ~MP_domain();
    MP_domain(MP_domain_base* r);

    MP_domain such_that(const MP_boolean& b);

    void Forall(const Functor* op) const;
    size_t size() const;
    static const MP_domain& getEmpty();
private:
        std::vector<MP_boolean> condition;
    Handle<MP_domain_base*> last;
    static const MP_domain* Empty;
};

class MP_domain_set : public MP_domain_base {
public:
    MP_domain_set(const MP_set* s, MP_index* i);
    void operator()() const;
    int evaluate() const;
    const MP_set_base* getSet() const;
    MP_index* getIndex() const;
    MP_domain getDomain(MP_set* s) const ;
    ~MP_domain_set();
private:
    const MP_set* S;
     MP_index* I;
};

template<int nbr> class MP_domain_subset;

    template<int nbr> class insertFunctor : public Functor {
public:
    insertFunctor(MP_domain_subset<nbr>* d) : D(d) {}
    void operator()() const { 
        std::vector<int> elm(nbr);
        for (int i=0; i<nbr; i++) {
            elm[i] = D->I[i]->evaluate();
        }
        D->S->insert(elm);
    }
private:
    MP_domain_subset<nbr>* D;
};

template<int nbr> class MP_domain_subset : public MP_domain_base {
    friend class insertFunctor<nbr>;
public:
    MP_domain_subset<nbr> (MP_subset<nbr>* s, 
                           const std::vector<MP_index*> &i) : S(s), I(i){}

    int evaluate() const {
        return S->evaluate(I);
    }
    MP_set_base* getSet() const {
        return S;
    }
    MP_index* getIndex() const {
        return S;
    }
    MP_domain getDomain(MP_set* s) const {
        return MP_domain(const_cast<MP_domain_subset<nbr>*>(this));
    }
    void operator()() const {
        bool isBound[nbr];
        bool allBound = true;
        for (int j=0; j<nbr; j++) {
            if (I[j]->isInstantiated() == true) {
                isBound[j] = true;
            } else {
                isBound[j] = false;
                allBound = false;
                if (I[j]!=&MP_index::getEmpty()) { 
                    I[j]->instantiate();
                }
            }
        }
        if (allBound == true) {
            (*donext)(); 
        } else {
            std::map<std::vector<int>, int>::const_iterator i;
            int counter = 0;
            for (i = S->elements.begin(); i != S->elements.end(); i++) {
                S->assign(counter);
                counter++;
                bool goOn = true;
                for (int j=0; j<nbr; j++) {
                    if (isBound[j] == true) {
                        if (I[j]->evaluate() != i->first[j]) {
                            goOn = false;
                            break;
                        }
                    } else {
                        I[j]->assign(i->first[j]);
                    }
                }
                if (goOn == true) {
                    (*donext)();
                }
            }
        }
        for (int j=0; j<nbr; j++) {
            if (isBound[j] == false) {
                I[j]->assign(0);
                I[j]->unInstantiate();
            }
        }
    }    

    Functor* makeInsertFunctor() const {
        return new insertFunctor<nbr>(
            const_cast<MP_domain_subset<nbr>*>(this));
    }
private:
    MP_subset<nbr>* S;
    std::vector<MP_index*> I;
};

MP_domain operator*(const MP_domain& a, const MP_domain& b);
  
}  // End of namespace flopc
#endif