MP_expression.hpp

Go to the documentation of this file.

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

#ifndef _MP_expression_hpp_
#define _MP_expression_hpp_

#include <vector>
#include <set>

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

namespace flopc {

    class Boolean;
    class MP_domain;
    class MP_constraint;
    class Row;
    class MP_variable;
    class VariableRef;
    class CoefLess;

    struct Coef {
        Coef(int c, int r, double v, int s = 0) : 
            col(c), row(r), stage(s), val(v)  {}
        int col, row, stage;
        double val;
    };

    class TerminalExpression;

    class GenerateFunctor : public Functor {
    public:
        GenerateFunctor(std::vector<Coef>& coefs) : Coefs(coefs) {}

        virtual ~GenerateFunctor(){}

        void setConstraint(MP_constraint* r) {
            R = r;
        }
        void setMultiplicator(std::vector<Constant>& mults, double m) {
            multiplicators = mults;
            m_ = m;
        }
        void setTerminalExpression(const TerminalExpression* c) {
            C = c;
        }
        virtual int row_number() const;

        void operator()() const;

        double m_;
        std::vector<Constant> multiplicators;
        MP_constraint* R;
        const TerminalExpression* C;
        std::vector<Coef>& Coefs;
    };

    class ObjectiveGenerateFunctor : public GenerateFunctor {
    public:
        ObjectiveGenerateFunctor(std::vector<Coef>& coefs) : GenerateFunctor(coefs) {}
        virtual int row_number() const {
            return -1;
        }
    };

    class MP_expression_base {
        friend class MP_expression;
        friend class Handle<MP_expression_base*>;
    private:
        int count;
    public:
        MP_expression_base() : count(0) {}

        virtual double level() const = 0;
        virtual void generate(const MP_domain& domain,
                              std::vector<Constant> multiplicators,
                              GenerateFunctor& f,
                              double m) const = 0;
        virtual void insertVariables(std::set<MP_variable*>& v) const = 0;

        virtual ~MP_expression_base() {}
    };

    class MP_expression : public Handle<MP_expression_base*> {
        friend class MP_constraint;
    public:
        MP_expression() : Handle<MP_expression_base*>(0) {}
        MP_expression(MP_expression_base* r) : Handle<MP_expression_base*>(r) {}
        MP_expression(const Constant& c);
        MP_expression(const VariableRef& v);
        virtual ~MP_expression() {}
    };

    class TerminalExpression : public MP_expression_base {
    public:
        virtual double getValue() const = 0; 
        virtual int getColumn() const = 0;
        virtual int getStage() const = 0;
    };

    class Expression_operator : public MP_expression_base {
    public:
        Expression_operator(const MP_expression& e1, const MP_expression& e2) : 
            left(e1),right(e2) {}
        void insertVariables(std::set<MP_variable*>& v) const {
            left->insertVariables(v);
            right->insertVariables(v);
        }
    protected:
        MP_expression left,right;
    };

    MP_expression operator+(const MP_expression& e1, const MP_expression& e2);
    MP_expression operator+(const MP_expression& e1, const Constant& e2);
    MP_expression operator+(const Constant& e1, const MP_expression& e2);
    MP_expression operator-(const MP_expression& e1, const MP_expression& e2);
    MP_expression operator-(const MP_expression& e1, const Constant& e2);
    MP_expression operator-(const Constant& e1, const MP_expression& e2);
    MP_expression operator*(const Constant& e1, const MP_expression& e2); 
    MP_expression operator*(const MP_expression& e1, const Constant& e2);
    MP_expression sum(const MP_domain& d, const MP_expression& e);

} // End of namespace flopc
#endif