MP_index.hpp

Go to the documentation of this file.

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

#ifndef _MP_index_hpp_
#define _MP_index_hpp_

#include "MP_utilities.hpp"
#include "MP_constant.hpp"

namespace flopc {

    class MP_index;
    class MP_domain;
    class MP_set;

    class MP_index_base {
        friend class Handle<MP_index_base*>;
        friend class MP_index_exp;
    public:
        virtual int evaluate() const = 0;
        virtual MP_index* getIndex() const = 0;
        virtual MP_domain getDomain(MP_set* s) const = 0;
        virtual void display()const;
    protected:
        MP_index_base() : count(0) {}
        virtual ~MP_index_base() {}
    private:
        int count;
    };

    class MP_index : public MP_index_base {
    public:
        MP_index() : index(0), instantiated(false) {}
        int evaluate() const { 
            return index; 
        }
        bool isInstantiated() const { 
            return instantiated; 
        }
        void assign(int i) { 
            index = i;
        }
        void unInstantiate() {
            instantiated = false; 
        }
        void instantiate() {
            instantiated = true; 
        }
        MP_index* getIndex() const {
            return const_cast<MP_index*>(this);
        }
        virtual MP_domain getDomain(MP_set* s) const;
        static MP_index& Any;
        static MP_index &getEmpty();

    private:
        static MP_index& Empty;
        int index;
        bool instantiated;
    };


    Constant operator+(MP_index& a, MP_index& b);
    Constant operator-(MP_index& a, MP_index& b);

    MP_index_exp operator-(MP_index& i,const int& j);
    MP_index_exp operator+(MP_index& i,const int& j);
    MP_index_exp operator+(MP_index& i,const Constant& j);
    MP_index_exp operator*(MP_index& i,const Constant& j);

    class SUBSETREF;

    class MP_index_exp : public Handle<MP_index_base*> {
    public:
        MP_index_exp(MP_index_base* r) : Handle<MP_index_base*>(r) {} 
        MP_index_exp(int i=0); 
        MP_index_exp(const Constant& c);
        MP_index_exp(MP_index& i);
        MP_index_exp(const SUBSETREF& d);
        MP_index_exp(const MP_index_exp& other);
        virtual ~MP_index_exp() {}
        static const MP_index_exp &getEmpty();
    private:
        static MP_index_exp Empty;
    };

    class MP_index_mult : public MP_index_base {
        friend MP_index_exp operator*(MP_index& i,const Constant& j);
    private:
        MP_index_mult(MP_index& i, const Constant& j) : left(i), right(j) {}
    
        int evaluate() const {
            return left->evaluate()*int(right->evaluate()); 
        }
        MP_index* getIndex() const {
            return left->getIndex();
        }
        virtual MP_domain getDomain(MP_set* s) const;
        MP_index_exp left;
        Constant right;
    };

    class MP_index_sum : public MP_index_base {
        friend MP_index_exp operator+(MP_index& i,const Constant& j);
        friend MP_index_exp operator+(MP_index& i,const int& j);
    private:
        MP_index_sum(MP_index& i, const Constant& j) : left(i), right(j) {}
    
        int evaluate() const {
            return left->evaluate()+int(right->evaluate()); 
        }
        MP_index* getIndex() const {
            return left->getIndex();
        }
        virtual MP_domain getDomain(MP_set* s) const;
        MP_index_exp left;
        Constant right;
    };

    class MP_index_dif : public MP_index_base {
        friend MP_index_exp operator-(MP_index& i,const Constant& j);
        friend MP_index_exp operator-(MP_index& i,const int& j);
    private:
        MP_index_dif(MP_index& i, const Constant& j) : left(i), right(j) {}
   
        int evaluate() const {
            return left->evaluate()-int(right->evaluate()); 
        }
        MP_index* getIndex() const {
            return left->getIndex();
        }
        virtual MP_domain getDomain(MP_set* s) const;
        MP_index_exp left;
        Constant right;
    };

} // End of namespace flopc
#endif