polynom.h

Go to the documentation of this file.
00001 // Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
00002 // All Rights Reserved.
00003 // This code is published under the Common Public License.
00004 //
00005 // Author: Stefan Vigerske
00006 
00007 #ifndef POLYNOM_H
00008 #define POLYNOM_H
00009 
00010 #include "standard.h"
00011 #include "func.h"
00012 #include "sampling.h"
00013 #include "decomp.h"
00014 #include "MINLPData.h"
00015 
00018 class MultiIndex : public multiset<int> {
00019         friend ostream& operator<<(ostream& out, const MultiIndex& x) {
00020                 for (MultiIndex::const_iterator it(x.begin()); it!=x.end(); it++) out << (it==x.begin() ? "" : " ") << *it;
00021                 return out;
00022         }
00023         
00024         public:
00027                 MultiIndex()
00028                 : multiset<int>()
00029                 { }
00030                 
00035                 MultiIndex(int i)
00036                 : multiset<int>()
00037                 { insert(i);
00038                 }
00039                 
00045                 MultiIndex(int i, int j)
00046                 : multiset<int>()
00047                 { insert(i);
00048                   insert(j);
00049                 }
00050                 
00055                 bool operator<(const MultiIndex& x) {
00056 //                      if (size()==x.size()) return ::operator<(*(const multiset<int>*)this, *(const multiset<int>*)&x);
00057                         if (size()==x.size()) return std::operator<(*this, x);
00058                         if (size()<x.size()) return true;
00059                         return false;
00060                 }
00061         
00062 };
00063 
00066 class Monom : public Func {
00067         private:
00068                 MultiIndex indices;
00069 
00077                 double part_derivate_rek(const UserVector<double>& x, MultiIndex& alpha, MultiIndex& beta) const;
00078                 
00079         public:
00084                 Monom(int dim_, MultiIndex& indices_)
00085                 : Func(dim_), indices(indices_)
00086                 { }
00087                 
00088                 
00089 //              Monom(int dim_, MultInd& indices_);     
00090 
00091                 double eval(const UserVector<double>& x) const {
00092                         double val=1.;
00093                         for (MultiIndex::const_iterator it(indices.begin()); it!=indices.end(); it++) val*=x(*it);
00094                         return val;
00095                 }
00096                 using Func::eval;
00097 
00098                 void grad(UserVector<double>& grad, const UserVector<double>& x) const;
00099                 using Func::grad;
00100 
00107                 void HessMult(UserVector<double>& y, const UserVector<double>& x, const UserVector<double>& z) const;
00108                 using Func::HessMult;
00109 
00116                 double part_derivate(const UserVector<double>& x, const MultiIndex& ind) const {
00117                         MultiIndex alpha(indices);
00118                         MultiIndex beta(ind);
00119                         return part_derivate_rek(x, alpha, beta);
00120                 }
00121 
00122                 virtual void set_curvature(CurvatureType ct) { out_err << "Monom::set_curvature() not implemented. Aborting." << endl; exit (-1); };
00123                 virtual CurvatureType get_curvature() const  { out_err << "Monom::get_curvature() not implemented. Aborting." << endl; exit (-1); return Func::UNKNOWN; };
00124 
00125                 void print(ostream& out) const {
00126                         out << "[" << indices << "]";
00127                 }
00128 };
00129 
00130 
00146 class PolynomialUnderestimator2 {
00147         private:
00148                 Pointer<Param> param;
00149 
00150                 int max_degree;
00151                 int maxdegree1_size, maxdegree2_size;
00152 
00153                 Sampling sampling0; // for K0
00154                 Sampling sampling1; // for K1
00155                 Sampling sampling2; // for K2
00156                 Sampling_Vertices sampling_vertices;
00157                 Sampling_Minimizer sampling_minimizer;
00158                 int sampling_initial; // should we add the initial point
00159                 vector<dvector> sample_set;
00160                 ivector ss_size;
00161 
00162                 list<MultiIndex> multiindices;
00163                 list<Monom> monoms;
00164 
00165                 Decomposition decomp;
00166 
00167                 void new_multiindices(const SparsityInfo& si, int n);
00168                 void polynomial_underestimator(SparseMatrix2& A, SparseVector<double>& b, double& c, Func& f, ivector& indices);
00169 
00170         public:
00171                 SparseVector<double> c_add1, c_add2;
00172 
00173                 PolynomialUnderestimator2(Pointer<Param> param_=NULL);
00174 
00175                 void polynomial_underestimator(MinlpProblem& prob, MINLPData& minlpdata, ivector& ineq_index, SparseVector<double>& obj_c_add, vector<SparseVector<double> >& con_c_add);
00176                 Pointer<SepQcFunc> polynomial_underestimator(Pointer<SepQcFunc> f, bool eq, dvector& lower, dvector& upper, dvector& primal);
00177                 void new_sampleset(const dvector& lower, const dvector& upper);
00178                 void check_for_nan(const Func& f);
00179                 bool add_point_to_sampleset(const dvector& point);
00180                 bool add_minimizer_to_sample(Pointer<Func> f, const dvector& lower, const dvector& upper, dvector& start);
00181                 void remove_last_point_from_sample();
00182 
00183                 void check(MinlpProblem& prob, MinlpProblem& quad, ivector& ineq_index);
00184 };
00185 
00186 #endif

Generated on Tue Oct 21 03:12:10 2008 for LaGO by  doxygen 1.4.7