relax.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 RELAX_H
#define RELAX_H

#include "standard.h"
#include "param.h"
#include "func.h"
#include "problem.h"
#include "opt.h"
#include "decomp.h"
#include "sampling.h"


class Convexify {
        private:
                Pointer<Param> param;

                Sampling sampling;
                vector<vector<dvector> > sample_set;

                Decomposition decomp;

                double very_large, cgu_eps;

                pair<Pointer<UserVector<double> >, Pointer<UserVector<double> > > convexify_a;
                pair<Pointer<UserVector<double> >, Pointer<UserVector<double> > > convexify_b;

                vector<bool> convexified_by_cgu;

                void convexify_cgu(SepQcFunc& f, int k);
                pair<double, double> convexify_alpha(SepQcFunc& f, int k, const dvector& low, const dvector& up, Pointer<set<int> > i_quad, Pointer<set<int> > i_nonquadlin);
                pair<double, double> convexify_alpha(SepQcFunc& f, int k, const dvector& low, const dvector& up);
                pair<double, double> convexify_alpha2(SepQcFunc& f, int k, const dvector& low, const dvector& up);
        public:
                vector<pair<double, double> > convexify_c;
                
                map<int, double> characteristica1, characteristica2;
        
                Convexify(Pointer<Param> param_)
                : param(param_), sampling(param_, "Convexify"), decomp(param)
                { very_large=param->get_d("Relax very large", 1E+99);
                        cgu_eps=param->get_d("Relax CGU epsilon", 0.);
                }
                
                void new_sampleset(UserVector<double>& lower, UserVector<double>& upper, SepQcFunc& f);
                
                double convexify(SepQcFunc& f, bool eq, vector<double>& min_eigval, vector<double>& max_eigval, UserVector<double>& lower, UserVector<double>& upper);
                
                void get_decomposed_functions(pair<Pointer<SepQcFunc>, Pointer<SepQcFunc> >& f);

                void check_convex2(vector<double>& min_eigval, vector<double>& max_eigval, SepQcFunc& f, const vector<vector<dvector> >& sample_set);

                void check_convexification(MinlpProblem& conv_prob, MinlpProblem& orig_prob, const ivector& ineq_index, int test_pts=20);
};

#endif

---