polynom.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 POLYNOM_H
#define POLYNOM_H

#include "standard.h"
#include "func.h"
#include "sampling.h"
#include "decomp.h"
#include "MINLPData.h"

class MultiIndex : public multiset<int> {
        friend ostream& operator<<(ostream& out, const MultiIndex& x) {
                for (MultiIndex::const_iterator it(x.begin()); it!=x.end(); it++) out << (it==x.begin() ? "" : " ") << *it;
                return out;
        }
        
        public:
                MultiIndex()
                : multiset<int>()
                { }
                
                MultiIndex(int i)
                : multiset<int>()
                { insert(i);
                }
                
                MultiIndex(int i, int j)
                : multiset<int>()
                { insert(i);
                  insert(j);
                }
                
                bool operator<(const MultiIndex& x) {
//                      if (size()==x.size()) return ::operator<(*(const multiset<int>*)this, *(const multiset<int>*)&x);
                        if (size()==x.size()) return std::operator<(*this, x);
                        if (size()<x.size()) return true;
                        return false;
                }
        
};

class Monom : public Func {
        private:
                MultiIndex indices;

                double part_derivate_rek(const UserVector<double>& x, MultiIndex& alpha, MultiIndex& beta) const;
                
        public:
                Monom(int dim_, MultiIndex& indices_)
                : Func(dim_), indices(indices_)
                { }
                
                
//              Monom(int dim_, MultInd& indices_);     

                double eval(const UserVector<double>& x) const {
                        double val=1.;
                        for (MultiIndex::const_iterator it(indices.begin()); it!=indices.end(); it++) val*=x(*it);
                        return val;
                }
                using Func::eval;

                void grad(UserVector<double>& grad, const UserVector<double>& x) const;
                using Func::grad;

                void HessMult(UserVector<double>& y, const UserVector<double>& x, const UserVector<double>& z) const;
                using Func::HessMult;

                double part_derivate(const UserVector<double>& x, const MultiIndex& ind) const {
                        MultiIndex alpha(indices);
                        MultiIndex beta(ind);
                        return part_derivate_rek(x, alpha, beta);
                }

                virtual void set_curvature(CurvatureType ct) { out_err << "Monom::set_curvature() not implemented. Aborting." << endl; exit (-1); };
                virtual CurvatureType get_curvature() const  { out_err << "Monom::get_curvature() not implemented. Aborting." << endl; exit (-1); return Func::UNKNOWN; };

                void print(ostream& out) const {
                        out << "[" << indices << "]";
                }
};


class PolynomialUnderestimator2 {
        private:
                Pointer<Param> param;

                int max_degree;
                int maxdegree1_size, maxdegree2_size;

                Sampling sampling0; // for K0
                Sampling sampling1; // for K1
                Sampling sampling2; // for K2
                Sampling_Vertices sampling_vertices;
                Sampling_Minimizer sampling_minimizer;
                int sampling_initial; // should we add the initial point
                vector<dvector> sample_set;
                ivector ss_size;

                list<MultiIndex> multiindices;
                list<Monom> monoms;

                Decomposition decomp;

                void new_multiindices(const SparsityInfo& si, int n);
                void polynomial_underestimator(SparseMatrix2& A, SparseVector<double>& b, double& c, Func& f, ivector& indices);

        public:
                SparseVector<double> c_add1, c_add2;

                PolynomialUnderestimator2(Pointer<Param> param_=NULL);

                void polynomial_underestimator(MinlpProblem& prob, MINLPData& minlpdata, ivector& ineq_index, SparseVector<double>& obj_c_add, vector<SparseVector<double> >& con_c_add);
                Pointer<SepQcFunc> polynomial_underestimator(Pointer<SepQcFunc> f, bool eq, dvector& lower, dvector& upper, dvector& primal);
                void new_sampleset(const dvector& lower, const dvector& upper);
                void check_for_nan(const Func& f);
                bool add_point_to_sampleset(const dvector& point);
                bool add_minimizer_to_sample(Pointer<Func> f, const dvector& lower, const dvector& upper, dvector& start);
                void remove_last_point_from_sample();

                void check(MinlpProblem& prob, MinlpProblem& quad, ivector& ineq_index);
};

#endif

---