MINLPData.h

Go to the documentation of this file.

// Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Author: Stefan Vigerske

#ifndef _MINLPDATA_H_
#define _MINLPDATA_H_

#include "standard.h"
#include "func.h"
#include "problem.h"

#include <string>

class MINLP;

class MinlpOpt;
class Reformulation;
class LinearizedConCutGenerator;
class PolynomialUnderestimator2;
class QuadraticUnderestimator;

class MINLPData {
        friend class MINLP;
        friend class MinlpOpt;
        friend class Reformulation;
        friend class LinearizedConCutGenerator;
        friend class PolynomialUnderestimator2;
        friend class QuadraticUnderestimator;
private:
        class ObjCon {
        public:
                string name;
                Pointer<SepQcFunc> func;
                SepQcFunc::ftype functype;
                Func::CurvatureType curvtype;
                
                Pointer<SepQcFunc> polynomial_underestimator;
                map<int, double> polynomial_approx_constants_lower;
                
                map<int, double> convexification_characteristica_lower;
                
                Pointer<SepQcFunc> convex_underestimator;
                
                map<int, int> reformulation_constraints_lower;
                
                ObjCon(const Pointer<SepQcFunc>& func_, const string& name_=string());
                
                ObjCon()
                : functype(SepQcFunc::CONSTANT), curvtype(Func::LINEAR)
                { }
                
                friend ostream& operator<<(ostream& out, const ObjCon& objcon);

                // TODO: information about usage of blocks, sparsity, relaxations, ...
        };
        friend ostream& operator<<(ostream& out, const ObjCon& objcon);
        
public:
        class Variable {
        public:
                int index;
                int block_nr;
                int index_in_block;

                string name;
                
                double lower;
                double upper;
                bool discrete;

                Variable(int index_, double lower_, double upper_, bool discrete_=false, const string& name_=string())
                : index(index_), block_nr(-1), index_in_block(-1), name(name_), lower(lower_), upper(upper_), discrete(discrete_)
                { }

        };

        class Constraint : public ObjCon {
        public:
                int index;
                bool equality;

                Pointer<SepQcFunc> polynomial_overestimator;
                map<int, double> polynomial_approx_constants_upper;

                map<int, double> convexification_characteristica_upper;
                Pointer<SepQcFunc> concave_overestimator;

                map<int, int> reformulation_constraints_upper;

//              int ineq_index;
                
                Constraint(int index_, const Pointer<SepQcFunc>& func_, bool equality_, const string& name_=string())
                : ObjCon(func_, name_), index(index_), equality(equality_)
                { }

                friend ostream& operator<<(ostream& out, const Constraint& con);
        };
        friend ostream& operator<<(ostream& out, const Constraint& con);
        
        class Objective : public ObjCon {
        public:
                Objective(const Pointer<SepQcFunc>& func_, const string& name_=string())
                : ObjCon(func_, name_)
                { }
                
                Objective()
                : ObjCon()
                { }
        };
        
        typedef vector<int> Block;
        typedef vector<Block> BlockStructure;
        
        
private:
        string name;
        vector<Variable> var;
        
        vector<Constraint> con;
        
        Objective obj;
        
        BlockStructure block;
        
        vector<int> discrete_var;


public:
        MINLPData();
        MINLPData(const MinlpProblem& prob);
        virtual ~MINLPData();
};

#endif //_MINLPDATA_H_

---