MP_data.hpp

Go to the documentation of this file.

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

#ifndef _MP_data_hpp_
#define _MP_data_hpp_

#include <vector>
#include <string>

#include "MP_index.hpp"    
#include "MP_set.hpp"      
#include "MP_constant.hpp" 
#include "MP_boolean.hpp" 

namespace flopc {

    class MP_data;

    class DataRef : public Constant_base, public Functor {
    public:
        DataRef(MP_data* d, 
                const MP_index_exp& i1,
                const MP_index_exp& i2,
                const MP_index_exp& i3,
                const MP_index_exp& i4,
                const MP_index_exp& i5,
                int s = 0) : 
            D(d),I1(i1),I2(i2),I3(i3),I4(i4),I5(i5),C(0),stochastic(s) {}

        ~DataRef() {} 
        DataRef& such_that(const MP_boolean& b);
        double evaluate() const;
        int getStage() const;
        const DataRef& operator=(const DataRef& r); 
        const DataRef& operator=(const Constant& c);
        void evaluate_lhs(double v) const;
        void operator()() const;
    private:
        MP_data* D;
        MP_index_exp I1,I2,I3,I4,I5;
        Constant C;
        int stochastic;
        MP_boolean B;
    };

    class MP_data : public RowMajor, public Functor , public Named {
        friend class MP_variable;
        friend class DisplayData;
        friend class DataRef;
        friend class MP_model;
    public:
        void operator()() const;
        void initialize(double d) {
            for (int i=0; i<size(); i++) {
                v[i] = d;
            }
        }
        MP_data(const MP_set_base &s1 = MP_set::getEmpty(), 
                const MP_set_base &s2 = MP_set::getEmpty(), 
                const MP_set_base &s3 = MP_set::getEmpty(),
                const MP_set_base &s4 = MP_set::getEmpty(), 
                const MP_set_base &s5 = MP_set::getEmpty()) :
            RowMajor(s1.size(),s2.size(),s3.size(),s4.size(),s5.size()),
            S1(s1),S2(s2),S3(s3),S4(s4),S5(s5),
            v(new double[size()]), manageData(true) 
            {
                initialize(0); 
            }

        MP_data(double* value,
                const MP_set_base &s1 = MP_set::getEmpty(), 
                const MP_set_base &s2 = MP_set::getEmpty(), 
                const MP_set_base &s3 = MP_set::getEmpty(),
                const MP_set_base &s4 = MP_set::getEmpty(), 
                const MP_set_base &s5 = MP_set::getEmpty()) :
            RowMajor(s1.size(),s2.size(),s3.size(),s4.size(),s5.size()),
            S1(s1),S2(s2),S3(s3),S4(s4),S5(s5),
            v(value), manageData(false) 
            {
            }

        ~MP_data() {
            if (manageData == true) delete[] v;
//          for (unsigned int i=0; i<myrefs.size(); i++) {
//              cout<<"# "<<i<<"   "<<myrefs[i]<<endl;
//              delete myrefs[i]; //Gives segmentation fault. I dont know why!
//          }
        }
    
        void value(const double* d) {
            for (int i=0; i<size(); i++) {
                v[i] = d[i];
            }
        }

        operator double() {
            return operator()(0);
        }
    
        double& operator()(int lcli1, int lcli2=0, int lcli3=0, int lcli4=0, int lcli5=0) {
            lcli1 = S1.check(lcli1);
            lcli2 = S2.check(lcli2);
            lcli3 = S3.check(lcli3);
            lcli4 = S4.check(lcli4);
            lcli5 = S5.check(lcli5);
            int i = f(lcli1,lcli2,lcli3,lcli4,lcli5);
            if (i == outOfBound) {
                outOfBoundData = 0;
                return outOfBoundData;
            } else {
                return v[i];
            }
        }
    
        DataRef& operator() (
            const MP_index_exp& lcli1 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli2 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli3 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli4 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli5 = MP_index_exp::getEmpty()
            ) {
            myrefs.push_back(new DataRef(this, lcli1, lcli2, lcli3, lcli4, lcli5));
            return *myrefs.back();
        }
    

        void display(std::string s = "");
    protected:
        std::vector<DataRef*> myrefs;
    private:
        MP_data(const MP_data&); // Forbid copy constructor
        MP_data& operator=(const MP_data&); // Forbid assignment

        static double outOfBoundData;

        MP_index i1,i2,i3,i4,i5;
        const MP_set_base &S1,&S2,&S3,&S4,&S5;
        double* v;
        bool manageData;
    };

    class MP_stochastic_data : public MP_data {
    public:
        MP_stochastic_data(const MP_set_base &s1 = MP_set::getEmpty(), 
                           const MP_set_base &s2 = MP_set::getEmpty(), 
                           const MP_set_base &s3 = MP_set::getEmpty(),
                           const MP_set_base &s4 = MP_set::getEmpty(), 
                           const MP_set_base &s5 = MP_set::getEmpty()) :
            MP_data(s1,s2,s3,s4,s5) {}

        using flopc::MP_data::operator();
        DataRef& operator() (
            const MP_index_exp& lcli1 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli2 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli3 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli4 = MP_index_exp::getEmpty(),
            const MP_index_exp& lcli5 = MP_index_exp::getEmpty()
            ) {
            myrefs.push_back(new DataRef(this, lcli1, lcli2, lcli3, lcli4, lcli5, 1));
            return *myrefs.back();
        }
    };

} // End of namespace flopc
#endif