MP_model.hpp

Go to the documentation of this file.

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

#ifndef _MP_model_hpp_
#define _MP_model_hpp_

#include <ostream>
#include <vector>
#include <set>
#include <string>

#include "MP_expression.hpp"
#include "MP_constraint.hpp"
#include <CoinPackedVector.hpp>
class OsiSolverInterface;

namespace flopc {

    class MP_variable;
    class MP_index;
    class MP_set;

    class Messenger {
    public:
        virtual void logMessage(int level, const char * const msg){}
        friend class MP_model;
    private:
        virtual void constraintDebug(std::string name, const std::vector<Coef>& cfs) {}
        virtual void objectiveDebug(const std::vector<Coef>& cfs) {}
        virtual void statistics(int bm, int m, int bn, int n, int nz) {}
        virtual void generationTime(double t) {}
    protected:
        virtual ~Messenger() {}
    };

    class NormalMessenger : public Messenger {
        friend class MP_model;
    private:
        virtual void statistics(int bm, int m, int bn, int n, int nz);
        virtual void generationTime(double t);
    };

    class VerboseMessenger : public NormalMessenger {
        friend class MP_model;
    private:
        virtual void constraintDebug(std::string name, const std::vector<Coef>& cfs);
        virtual void objectiveDebug(const std::vector<Coef>& cfs);
    };

    class MP_model {
        friend class MP_constraint;
    public:
        typedef enum {MINIMIZE=1, MAXIMIZE=-1} MP_direction;

        typedef enum {  
            OPTIMAL, 
            PRIMAL_INFEASIBLE, 
            DUAL_INFEASIBLE, 
            ABANDONED,
            SOLVER_ONLY,
            ATTACHED,
            DETACHED
        } MP_status;

        MP_model(OsiSolverInterface* s, Messenger* m = new NormalMessenger);

        ~MP_model() {
            delete messenger;
        }

        MP_status getStatus()const {
            return mSolverState;
        }
        void silent() {
            delete messenger;
            messenger = new Messenger;
        }
        void verbose() {
            delete messenger;
            messenger = new VerboseMessenger;
        }

        void setSolver(OsiSolverInterface* s) {
            Solver = s;
        }

        OsiSolverInterface* operator->() {
            return Solver;
        }

        MP_model& add(MP_constraint& c);

        void maximize();
        void maximize(const MP_expression &obj);
        void minimize();
        void minimize(const MP_expression &obj);
   
        void minimize_max(MP_set& d, const MP_expression &obj);

        void setObjective(const MP_expression& o);
        void attach(OsiSolverInterface *solver=NULL);
        void detach();
        MP_model::MP_status solve(const MP_model::MP_direction &dir);
        const double* solution;
        const double* reducedCost;
        const double* rowPrice;
        const double* rowActivity;
        double getInfinity() const;

        void add(MP_variable* v);
        void addRow(const Constraint& c); 

        static MP_model &getDefaultModel();
        static MP_model *getCurrentModel();
        Messenger *getMessenger(){ 
            return messenger;
        }
    private:
        typedef std::set<MP_variable* >::iterator varIt;
        typedef std::set<MP_constraint* >::iterator conIt;
        static MP_model& default_model;
        static MP_model* current_model;
        MP_model(const MP_model&);
        MP_model& operator=(const MP_model&);

        Messenger* messenger;
   
    
        static void assemble(std::vector<Coef>& v, std::vector<Coef>& av);
        void add(MP_constraint* c);
        MP_expression Objective;
        std::set<MP_constraint *> Constraints;
        std::set<MP_variable *> Variables;
    public:
        OsiSolverInterface* Solver; 
    private:
        int m;
        int n;
        int nz;
        int *Cst;
        int *Clg;
        int *Rnr;
        double *Elm;
        double *bl;
        double *bu;
        double *c;
        double *l;
        double *u;
        MP_status mSolverState;
    };
    
    std::ostream &operator<<(std::ostream &os, 
                             const MP_model::MP_status &condition);
    std::ostream &operator<<(std::ostream &os, 
                             const MP_model::MP_direction &direction);

} // End of namespace flopc
#endif